Claude Orchestrator Starter Kit

Turn Claude Code into a personal AI assistant — with persistent memory, custom skills, and structured workflows.

This starter kit is extracted from a real-world personal orchestrator built for daily use in engineering, research, and knowledge management. What you see here are the foundational building blocks — the architecture and patterns that make everything else possible. Obsidian and SQLite are optional add-ons — the kit works standalone with plain markdown files.

The Problem

You spend 10 minutes re-explaining your project every Monday morning. You build the same summarization workflow for the third time because last week's session is gone. You open 5 tabs, and Claude doesn't know about any of them. Your quality varies wildly because there's no feedback loop — just single-pass generation and hope.

This kit fixes that.

What You Get

You                                     Claude (with Orchestrator)
─────────────────────────────           ──────────────────────────────────
"Summarize this article"                → Phase: Clarify
                                          Invokes distill skill
                                          Produces structured summary
                                          Next: /express to write output

"Is this analysis solid?"               → Phase: Verify
                                          Invokes signal-check skill
                                          Evaluates across 4 axes
                                          Next: /express to improve

"What could go wrong with this plan?"   → Phase: Verify
                                          Invokes challenge skill
                                          Stress-tests from 3 perspectives
                                          Next: /express to harden

"Is this analysis accurate?"            → Phase: Verify
                                          Invokes quality-gate skill
                                          Triage → Deep Check (Level 2)
                                          Verifies claims, calculates quality score
                                          Next: /express to revise

"Save state for next time"              → Invokes handoff skill
                                          Captures decisions + context
                                          Writes project state file
                                          Next session picks up where you left off

How It Works

flowchart TB
    subgraph INPUT ["🎯 Your Message"]
        direction LR
        msg["'Summarize this article'"]
    end

    subgraph BRAIN ["🧠 CLAUDE.md — The Orchestrator Brain"]
        direction TB
        mode["Mode Detection<br/><i>cognitive state → skill cluster</i>"]
        route["Routing Rules<br/><i>keyword → skill matching</i>"]
        patterns["User Patterns<br/><i>learned preferences</i>"]
    end

    subgraph SKILLS ["⚡ Skills"]
        direction LR
        capture["📥 capture"]
        distill["🔬 distill"]
        express["✍️ express"]
        analyze["🔍 analyze"]
        signal["🎯 signal-check"]
        challenge["⚔️ challenge"]
        qgate["🛡️ quality-gate"]
        handoff["💾 handoff"]
    end

    subgraph MEMORY ["💾 Three-Layer Memory"]
        direction TB
        short["Short-term<br/><i>Context window (1 session)</i>"]
        mid["Mid-term<br/><i>Routing log + handoffs (weeks)</i>"]
        long["Long-term<br/><i>CLAUDE.md + memory files (permanent)</i>"]
    end

    subgraph OUTPUT ["📤 Output"]
        result["Structured result<br/>+ next step suggestion"]
    end

    INPUT --> BRAIN
    BRAIN --> SKILLS
    SKILLS --> MEMORY
    MEMORY --> SKILLS
    SKILLS --> OUTPUT

    style INPUT stroke:#e94560
    style BRAIN stroke:#0f3460
    style SKILLS stroke:#16213e
    style MEMORY stroke:#533483
    style OUTPUT stroke:#e94560

The Architecture

Three-Phase Workflow

Every task follows three phases — don't skip any:

  Clarify              Build               Verify
  ─────────────────    ─────────────────    ─────────────────
  What's the problem?  Produce the output   Is it good enough?

  analyze              express              signal-check
  distill              capture              quality-gate
                                            challenge

This prevents aimless skill-chaining. Each skill belongs to a phase, and each phase has a clear question to answer before moving on.

Three-Layer Memory

	Layer	What	Where	Lifetime
1	Short-term	Current conversation	Context window	1 session
2	Mid-term	Past sessions, routing log	`orchestrator/routing-log.jsonl`, project states	Weeks to months
3	Long-term	Rules, preferences, knowledge	`CLAUDE.md`, `memory/`, Obsidian	Permanent

┌─────────────────────────────────────────────────────┐
│  ░░░░░░░░ SHORT-TERM  (Context Window) ░░░░░░░░░░  │
│  Current conversation, temporary results             │
│  ⏱ Lifetime: 1 session                              │
├─────────────────────────────────────────────────────┤
│  ▒▒▒▒▒▒▒ MID-TERM  (State + Episodic) ▒▒▒▒▒▒▒▒▒  │
│  Past sessions, routing decisions, handoffs          │
│  ⏱ Lifetime: weeks to months                        │
├─────────────────────────────────────────────────────┤
│  ████████ LONG-TERM  (CLAUDE.md + Knowledge) █████  │
│  Routing rules, preferences, glossary, context       │
│  ⏱ Lifetime: permanent                              │
└─────────────────────────────────────────────────────┘

Eight Core Skills

Each skill is a SKILL.md file — instructions, not code. They tell Claude how to behave, what tools to use, and what output to produce.

	Skill	Purpose	You say...
📥	capture	Quick note-taking	"Note this", "Save this idea"
🔬	distill	Summarize and condense	"Summarize", "Key takeaways"
✍️	express	Write polished output	"Write", "Draft", "Formulate"
🔍	analyze	Deep analysis with structured thinking	"Analyze", "Investigate"
🎯	signal-check	Quality check / fact check	"Is this solid?", "Quality check"
⚔️	challenge	Adversarial stress-testing	"What could go wrong?", "Stress-test this"
🛡️	quality-gate	Output quality orchestration	"Check this", "Is this accurate?"
💾	handoff	Save session state for next time	"Save state", "Handoff"

Four Key Loops

These 8 skills form four powerful feedback loops:

Evaluator-Optimizer Loop — Write, evaluate, improve:

flowchart LR
    E["✍️ express<br/><i>Generate output</i>"]
    S["🎯 signal-check<br/><i>Evaluate quality</i>"]
    E2["✍️ express<br/><i>Improve based on feedback</i>"]

    E -->|"evaluate"| S
    S -->|"optimize"| E2

    style E stroke:#e94560
    style S stroke:#0f3460
    style E2 stroke:#e94560

Evaluator-Challenger Loop — Write, stress-test, harden:

flowchart LR
    E["✍️ express<br/><i>Generate output</i>"]
    CH["⚔️ challenge<br/><i>Adversarial stress-test</i>"]
    E2["✍️ express<br/><i>Harden against objections</i>"]

    E -->|"stress-test"| CH
    CH -->|"harden"| E2

    style E stroke:#e94560
    style CH stroke:#e94560
    style E2 stroke:#e94560

Evaluator-Gate-Optimizer Loop — Write, verify with triage, improve:

flowchart LR
    E["✍️ express<br/><i>Generate output</i>"]
    QG["🛡️ quality-gate<br/><i>Triage + verify</i>"]
    E2["✍️ express<br/><i>Revise based on findings</i>"]

    E -->|"verify"| QG
    QG -->|"revise"| E2

    style E stroke:#e94560
    style QG stroke:#0f3460
    style E2 stroke:#e94560

Knowledge Cycle — Capture, process, output, verify:

flowchart LR
    C["📥 capture"]
    D["🔬 distill"]
    X["✍️ express"]
    S["🎯 signal-check"]
    A["🔍 analyze"]
    H["💾 handoff"]

    C --> D --> X --> S
    S -.->|"back to"| A
    A -.-> H
    H -.-> C

    style C stroke:#533483
    style D stroke:#533483
    style X stroke:#e94560
    style S stroke:#0f3460
    style A stroke:#16213e
    style H stroke:#16213e

Routing

The CLAUDE.md file contains routing rules that map keywords to skills. When you say something, Claude checks for matching patterns and invokes the right skill automatically.

You: "Summarize this article"
      │
      ▼
CLAUDE.md routing table
      │ matches "summarize" → distill
      ▼
Invokes distill skill
      │
      ▼
Structured summary → suggests: /express to write output

Memory

The memory/ directory provides long-term storage:

memory/
├── glossary.md          — Domain terms and jargon
├── context/
│   └── company.md       — Your work context (role, company, tools)
├── people/              — Key contacts and stakeholders
├── projects/            — Active project documentation
├── decisions/           — Decision log with rationale
└── workflows/           — Proven workflows and best practices

Quick Start

Time: ~5 minutes | Prerequisites: Claude Code + a terminal

# 1. Clone
git clone https://github.com/janrummel/claude-orchestrator-starter.git
cd claude-orchestrator-starter

# 2. Copy to your Claude config
cp CLAUDE.md.example ~/.claude/CLAUDE.md
cp -r orchestrator/ ~/.claude/orchestrator/
cp -r memory/ ~/.claude/memory/
cp -r hooks/ ~/.claude/hooks/

# 3. Start Claude Code — done.
claude

Claude will now:

Read CLAUDE.md at startup and understand its role
Route your requests to matching skills
Remember context across sessions via memory files

Session Chaining (CLI)

When context fills up, you no longer need to open a new terminal. The hooks handle it automatically:

# Use claude-loop instead of claude
claude-loop

# When context gets critical, Claude saves state automatically.
# Press Y to start a fresh session — it picks up where you left off.

See hooks/README.md for setup details.

Optional Add-ons

🟣 Obsidian Integration

Connect your Obsidian vault as Claude's knowledge base. Skills like capture write to it, analyze and express read from it.

See Obsidian Setup for instructions.

🗃️ Knowledge Database (SQLite)

For structured data storage (research items, imported datasets, skill usage stats).

See Knowledge DB Setup for instructions.

Developing Your Own Skills

See the Skill Development Guide for a detailed walkthrough.

The short version:

# 1. Create a skill directory
mkdir -p ~/.claude/orchestrator/skills/my-skill

# 2. Write the SKILL.md
cat > ~/.claude/orchestrator/skills/my-skill/SKILL.md << 'EOF'
---
name: my-skill
description: What this skill does and when to use it.
---

# My Skill

Instructions for Claude on how to execute this skill.

## Workflow
1. Step one
2. Step two
3. Step three
EOF

# 3. Add routing rules to CLAUDE.md
# Add keyword → skill mapping to the routing table

Why Use This?

Most people use Claude Code as a stateless tool — powerful, but amnesiac. Every session is a blank slate.

This starter kit turns it into a stateful assistant that grows with you:

	Without Orchestrator	With Orchestrator
Memory	Forgets everything after each session	Remembers decisions, context, preferences
Workflows	You describe the same steps every time	Skills automate your common patterns
Quality	Output quality varies unpredictably	Evaluator-Optimizer loop catches issues
Knowledge	Scattered across tools and notes	Centralized in memory files (+ optional Obsidian/SQLite)
Continuity	"Where were we?" every morning	Handoff picks up exactly where you left off

The core insight: Claude is already smart. What it lacks is structure, memory, and habits. That's what an orchestrator provides — not more intelligence, but better infrastructure around it.

Growing Beyond the Starter Kit

This kit gives you the architecture and patterns. It's intentionally focused — 8 skills, three-phase workflow, basic memory.

From here, you can:

Add domain-specific skills (research, strategy, decision-making)
Connect Obsidian as a long-term knowledge base (setup guide)
Add a SQLite database for structured data (setup guide)
Build workflow chains that combine multiple skills for complex tasks

The goal isn't to give you everything. It's to show you the building blocks — so you can build your own system on top.

Project Structure

claude-orchestrator-starter/
│
├── CLAUDE.md.example          ← The brain: routing rules + memory architecture
│
├── orchestrator/
│   ├── skills/
│   │   ├── capture/           ← 📥 Quick capture
│   │   ├── distill/           ← 🔬 Summarize and condense
│   │   ├── express/           ← ✍️ Write polished output
│   │   ├── analyze/           ← 🔍 Deep structured analysis
│   │   ├── signal-check/      ← 🎯 Quality & substance check
│   │   ├── challenge/         ← ⚔️ Adversarial stress-testing
│   │   ├── quality-gate/      ← 🛡️ Output quality orchestration
│   │   └── handoff/           ← 💾 Session state persistence
│   ├── routing-log.jsonl.example
│   ├── user-patterns.md.example
│   └── workflow-templates.md
│
├── memory/                    ← Long-term knowledge base
│   ├── glossary.md.example
│   ├── context/company.md.example
│   ├── people/
│   ├── projects/
│   ├── decisions/
│   └── workflows/
│
├── hooks/                     ← Session lifecycle hooks + session chaining
├── obsidian/                  ← Obsidian vault integration guide
├── knowledge-db/              ← SQLite knowledge database
└── docs/                      ← Architecture, guides, FAQ

Learn More

Resource	Description
Getting Started	Step-by-step setup guide
Architecture	Deep dive into the three-layer model
Skill Development	Build your own skills
FAQ	Common questions answered
Obsidian Setup	Connect your Obsidian vault
Knowledge DB	Set up the SQLite database

License

MIT — use it, fork it, make it yours.

Example Session

Here's what a typical session looks like with the orchestrator:

$ claude-loop

> Your active project is EV Charging Analysis. Next step: Verify data sources. Continue?

You: "Yes, check if the DOE dataset is still current"

Claude: Using analyze skill...
  → Checking knowledge DB: 3 entries found for DOE/charging data
  → Most recent: 2025-11-15. Gap: 4 months.
  → Searching for updates...

  Result: DOE AFDC dataset updated 2026-02-28.
  Your local data is stale. Shall I update?

You: "Yes, then summarize what changed"

Claude: Phase: Build → invoking distill skill
  → 47 new stations added, 3 decommissioned
  → New fast-charging corridor: I-80 Nevada segment
  → Summary saved to memory/projects/ev-charging.md

  Next step: /signal-check to verify these numbers?

Every response follows the three-phase workflow. Context carries over between sessions. Skills chain automatically.

Privacy & Data

100% local. All memory files, routing logs, and project states live in ~/.claude/ on your machine.
No cloud uploads. The orchestrator is pure markdown — no server, no telemetry, no analytics.
No API keys needed for the core kit. Only Claude Code itself requires an Anthropic account.
You own everything. All files are plain text. Export, backup, or delete anytime.

Optional add-ons (Obsidian, SQLite) also run locally.

Why Claude Code Only?

This is a deliberate choice, not a limitation. The orchestrator is built around Claude Code's specific capabilities:

CLAUDE.md is read automatically at startup — no plugin or wrapper needed
Hooks (context monitor, session chaining) use Claude Code's native hook system
Skills are SKILL.md files that Claude Code loads via its skill mechanism

The architecture patterns (three-phase workflow, memory layers, quality loops) are transferable. But the implementation leverages what Claude Code does uniquely well: treating markdown as executable instructions.

Contributing

Contributions welcome! See CONTRIBUTING.md.