Director Mode Lite

Use Claude Code like a Director, not a Programmer

Website | Quick Start | Features | Examples | Discord

"Don't write code. Direct Claude to write code for you."

Start Here

After installing, run these 3 commands:

/getting-started          # Guided 5-minute onboarding
/project-init             # Auto-detect project and configure
/workflow                 # Start your first feature

New to Director Mode? Read What is Director Mode? below, or jump to Quick Start.

Compatibility

Director Mode Lite v1.9.0 is aligned with the Claude 5-era Claude Code specification, including support for:

Claude 5 family model selection in agent/skill frontmatter (fable, opus, sonnet, haiku aliases)
Agent Teams (experimental multi-agent collaboration)
1M context window models (opus[1m], sonnet[1m])
All 30 hook event types including SessionStart, PreCompact, and PostCompact
Multi-account delegation via CLAUDE_CONFIG_DIR profiles (/handoff-claude)

Last tested with Claude Code CLI v2.1.201 in July 2026. Newer CLI releases may work, but should be re-verified rather than assumed compatible.

What is Director Mode?

Director Mode is a paradigm shift in AI-assisted development. Instead of writing code line by line, you direct Claude to execute your vision autonomously.

  Traditional Coding                    Director Mode
  ━━━━━━━━━━━━━━━━━━                    ━━━━━━━━━━━━━━

  You: Write code                       You: Define the vision
  AI:  Follow orders                    AI:  Execute autonomously
       ↓                                     ↓
  Micromanagement                       Strategic oversight
  One task at a time                    Parallel agent execution
  Manual intervention                   Continuous automation

Core Principles

Principle	Description
Efficiency First	Direct execution, minimal interruption
Parallel Processing	Multiple agents working simultaneously
Autonomous Execution	AI handles implementation details
Strategic Oversight	You focus on "what" and "why"

Key Feature: TDD-Driven Auto-Loop

Test-Driven Development Automation

Similar to Ralph Wiggum, Auto-Loop uses Stop hooks but focuses on TDD:

Acceptance Criteria Tracking - Parse - [ ] and auto-check completion
TDD Methodology - Red-Green-Refactor cycle guidance
Checkpoint Recovery - Resume from .auto-loop/checkpoint.json
Agent Collaboration - code-reviewer, test-runner integration

Stop anytime with:

touch .auto-loop/stop

/auto-loop "Create a calculator

Acceptance Criteria:
- [ ] add(a, b) function
- [ ] subtract(a, b) function
- [ ] Unit tests"

[Iteration 1] RED    → Write test...
[Iteration 2] GREEN  → Implement...
[Iteration 3] REFACTOR → Clean...
[Iteration 4] GREEN  → subtract()...
[Iteration 5] All criteria complete!

Self-Evolving Loop

Beyond Auto-Loop: Strategy Evolution

Self-Evolving Loop takes automation further by:

Dynamic Skill Generation - Creates custom skills for each task
Learning from Failures - Extracts patterns and root causes
Strategy Evolution - Improves its own execution approach
8-Phase Workflow - ANALYZE → GENERATE → EXECUTE → VALIDATE → DECIDE → LEARN → EVOLVE → SHIP

Key difference from auto-loop:

Feature	auto-loop	evolving-loop
Strategy	Fixed TDD	Dynamic
Learning	None	Extracts patterns
Adaptation	Low	High

/evolving-loop "Build REST API

Acceptance Criteria:
- [ ] GET /users endpoint
- [ ] POST /users endpoint
- [ ] Input validation
- [ ] Error handling
"

# The loop:
# 1. Analyzes requirements deeply
# 2. Generates custom executor skill
# 3. Executes with TDD
# 4. Validates results
# 5. If fails: learns & evolves skills
# 6. Repeats until all criteria pass
# 7. Ships the final result

Check status:

/evolving-status
/evolving-status --history
/evolving-status --evolution

See docs/SELF-EVOLVING-LOOP.md for complete documentation.

Quick Start

Option A: Native Plugin

# 1. Register the third-party marketplace (once per Claude profile)
claude plugin marketplace add claude-world/director-mode-lite

# 2. Install the marketplace-qualified plugin
claude plugin install director-mode-lite@director-mode-lite

# 3. Inside Claude Code, load the newly installed plugin without restarting
/reload-plugins

This portable path exposes namespaced skills and agents. It does not attach Auto-Loop, changelog, or validation hooks to the current project. Choose the clone path below when you want project-local assets and opt-in hooks; do not script against Claude Code's internal, versioned plugin-cache layout.

🔧 Plugin Management Commands

# Update plugin to latest version
claude plugin marketplace update director-mode-lite
claude plugin uninstall director-mode-lite@director-mode-lite
claude plugin install director-mode-lite@director-mode-lite

# Load plugin changes in an active Claude Code session
/reload-plugins

Option B: Project-Integrated Install

git clone https://github.com/claude-world/director-mode-lite.git
cd director-mode-lite
# Answer a few questions and pick the project's automation level:
./install.sh /path/to/your/project --wizard
# ...or accept the non-interactive defaults:
./install.sh /path/to/your/project
# Verify the project you configured:
./scripts/verify-install.sh /path/to/your/project

Option C: Try Demo First

git clone https://github.com/claude-world/director-mode-lite.git
cd director-mode-lite
./demo.sh ~/director-mode-demo

demo.sh uses a throwaway directory, not an operating-system sandbox. If the target already exists, the script can offer to delete and recreate it; inspect the path carefully before confirming.

Verify Installation

Run the verifier against the project where you installed Director Mode Lite:

# From the cloned checkout used for project integration
./scripts/verify-install.sh /path/to/your/project

# If the wizard intentionally selected no hooks
./scripts/verify-install.sh --allow-no-hooks /path/to/your/project

The script checks:

python3 and jq are available for settings and hook state handling
CLAUDE.md exists; an existing project's custom structure is accepted
The complete shipped inventory is present: 32 skills, including 27 user-invocable commands, and 14 agents (additional user assets are allowed)
Core and Evolving-Loop hook scripts exist and are executable
.claude/settings.local.json is valid JSON and contains at least one registered Director Mode hook

It prints colored PASS and FAIL lines, exits 0 when all checks pass, and exits 1 if any check fails.

If you deliberately selected a completely hook-free wizard setup, pass --allow-no-hooks. It still verifies CLAUDE.md and the complete skill/agent inventory, while skipping hook files, hook dependencies, settings, and registration checks that do not apply to that mode.

The verifier validates installation structure and configuration. It does not launch Claude Code, invoke a slash command, run your project tests, or prove that model-maintained acceptance criteria and outputs are correct.

✨ Installation Features

Setup Wizard - --wizard asks about your project and lets you pick which Stop-hook automation (none / Auto-Loop / Auto-Loop + Evolving-Loop) and safety/observability hooks to enable, instead of the fixed defaults
Automatic Backup - Backups existing .claude/ to .claude-backup-TIMESTAMP/
Portable Path Hooks - All hooks use $CLAUDE_PROJECT_DIR for portability (no more "file not found" errors)
Settings Preservation - Preserves existing settings; the verifier reports when no Director Mode hook was registered
Skip Existing - Won't overwrite already-installed commands/agents/skills
In-Place Upgrade - --update overwrites distributed files with the latest version
Scoped Uninstall - hooks-only removes Director Mode hook files and registrations while preserving custom hooks and runtime state; complete removal is intentionally broader
Automated Tests - ./tests/run-tests.sh validates installation

What's Included

Commands (27)

Workflow:

Command	Purpose
`/workflow`	5-step dev flow
`/focus-problem`	Problem analysis
`/test-first`	TDD cycle
`/smart-commit`	Auto commits
`/plan`	Task breakdown
`/auto-loop`	TDD loop
`/evolving-loop`	Self-evolving
`/evolving-status`	Loop status

Setup & Health:

Command	Purpose
`/getting-started`	5-min onboarding
`/project-init`	Quick setup
`/check-environment`	Env check
`/project-health-check`	7-point audit

Validators:

Command	Purpose
`/claude-md-check`	Validate CLAUDE.md
`/mcp-check`	Validate MCP config
`/agent-check`	Validate agent files
`/skill-check`	Validate skill files
`/hooks-check`	Validate hooks

Generators:

Command	Purpose
`/claude-md-template`	Generate CLAUDE.md
`/agent-template`	Generate agents
`/skill-template`	Generate skills
`/hook-template`	Generate hooks

Utilities:

Command	Purpose
`/changelog`	Session events
`/handoff-codex`	Delegate to Codex
`/handoff-gemini`	Delegate to Gemini
`/handoff-claude`	Multi-account Claude
`/agents`	List agents
`/skills`	List skills

Agents (14)

Core Agents:

Agent	Purpose
`code-reviewer`	Quality, security
`debugger`	Error analysis
`doc-writer`	Documentation

Expert Agents:

Agent	Purpose
`claude-md-expert`	CLAUDE.md design
`mcp-expert`	MCP configuration
`agents-expert`	Custom agents
`skills-expert`	Custom skills
`hooks-expert`	Automation hooks

Self-Evolving Agents:

Agent	Purpose
`evolving-orchestrator`	Loop coordination
`requirement-analyzer`	Deep analysis
`skill-synthesizer`	Generate skills
`completion-judge`	Decision making
`experience-extractor`	Learn from failures
`skill-evolver`	Evolve strategy

Skills (32)

27 of the skills are the slash commands listed left. The other 5 are internal knowledge bases, auto-loaded by agents or triggered by Claude:

Internal Skill	Purpose
`code-reviewer`	Review checklists
`debugger`	5-step method
`doc-writer`	Doc templates
`test-runner`	Test commands
`interop-router`	Auto CLI routing

Plus:

CLAUDE.md template
Starter hooks (Auto-Loop, changelog, validator)
4 hands-on examples

The 5-Step Workflow

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│    Step 1                Step 2                Step 3           │
│  ┌─────────┐           ┌─────────┐           ┌─────────┐        │
│  │ FOCUS   │    ──►    │ PREVENT │    ──►    │  TEST   │        │
│  │ PROBLEM │           │ OVERDEV │           │  FIRST  │        │
│  └─────────┘           └─────────┘           └─────────┘        │
│       │                     │                     │             │
│  Understand             Only build            Red-Green-        │
│  before coding          what's needed         Refactor          │
│                                                                 │
│                    Step 4                Step 5                 │
│                  ┌─────────┐           ┌─────────┐              │
│           ──►    │DOCUMENT │    ──►    │ COMMIT  │              │
│                  └─────────┘           └─────────┘              │
│                       │                     │                   │
│                  Auto-generated         Conventional            │
│                  documentation          Commits                 │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Parallel Agent Execution

One of Director Mode's key advantages is parallel processing:

Traditional (Sequential)

Agent 1 ─────►
              Agent 2 ─────►
                            Agent 3 ─────►
                                          Agent 4 ─────►

Total time: 4 × single_agent_time

Director Mode (Parallel)

Agent 1 ─────┐
Agent 2 ─────┼────► Results
Agent 3 ─────┤
Agent 4 ─────┘

Total time: max(single_agent_time)

Example: Problem Analysis

# Old way: Sequential manual searches
grep -r "authentication" src/
grep -r "login" src/
cat src/auth/index.ts
# ... slow, tedious

# Director Mode: One command, 5 parallel agents
/focus-problem "understand the authentication flow"

Scale Out: Multi-Account Delegation

Parallelism doesn't stop at one account. /handoff-claude delegates tasks to other authorized Claude Code instances — each with its own login, quota, and session state via CLAUDE_CONFIG_DIR profiles:

# One-time setup per profile (isolated login, sessions, settings)
CLAUDE_CONFIG_DIR=~/.claude-profiles/z-1 claude auth login

# Fan out to two accounts in parallel, conflict-free via git worktrees
(cd ../proj-task-a && claude-z-1 -p "Implement feature A" --permission-mode acceptEdits) &
(cd ../proj-task-b && claude-z-2 -p "Implement feature B" --permission-mode acceptEdits) &
wait

Run /handoff-claude for the full setup guide (wrapper commands, auth, result collection).

Agents

`code-reviewer`

Automatically reviews:

Code quality
Security vulnerabilities
Error handling
Performance
Test coverage

Triggers: Code changes, commits, "review"

`debugger`

5-step debugging:

Capture error info
Isolate problem
Form hypotheses
Investigate
Fix & verify

Triggers: Errors, test failures, "bug"

`doc-writer`

Creates and maintains:

README files
API documentation
Code comments
Architecture docs

Triggers: New features, structure changes

Expert Agents

Director Mode Lite includes 5 Expert Agents that deeply understand Claude Code's official features:

`claude-md-expert`

Your guide for:

CLAUDE.md design patterns
Project configuration
Best practices

Ask: "How should I structure my CLAUDE.md?"

`mcp-expert`

Your guide for:

MCP server setup
Available MCPs
Troubleshooting

Ask: "How do I add a Notion MCP?"

`agents-expert`

Your guide for:

Custom agent creation
Tool permissions
Agent patterns

Ask: "Create a security-reviewer agent"

`skills-expert`

Your guide for:

Slash command creation
Skill frontmatter
Workflow design

Ask: "Make a /deploy command"

`hooks-expert`

Your guide for:

Stop hooks (Auto-Loop)
PreToolUse/PostToolUse
Automation patterns

Ask: "How do I protect .env files?"

Why? Anthropic provides documentation, but no specialized helpers. These experts know the official docs and help you implement correctly.

Validators & Generators

Pair with Expert Agents for validate-then-fix or template-then-customize workflows:

Validators (5)

Validate your configurations and get actionable fix suggestions:

/claude-md-check              # Check CLAUDE.md structure
/mcp-check                    # Check MCP settings.json
/agent-check [file.md]        # Check agent file format
/skill-check [file.md]        # Check skill file format
/hooks-check                  # Check hooks config + scripts

Output format:

## Validation Report

### Status: ✅ PASS / ⚠️ WARNINGS / ❌ FAIL

| Check | Status | Notes |
|-------|--------|-------|
| ...   | ✅/❌  | ...   |

### Issues Found
1. [Issue and recommendation]

### Auto-Fix Available
- Run command X to fix...

Generators (4)

Generate properly-formatted files from templates:

/claude-md-template           # Generate CLAUDE.md
/agent-template [name] [purpose]  # Generate agent
/skill-template [name] [purpose]  # Generate skill
/hook-template [type] [purpose]   # Generate hook

Example:

/agent-template security-scanner "scan for vulnerabilities"

# Creates: .claude/agents/security-scanner.md
# with proper frontmatter, activation triggers,
# output format, and guidelines

Hook types:

PreToolUse - Block/validate before tool runs
PostToolUse - Log/react after tool runs
Stop - Continue automation loops
Notification - External alerts (Slack, etc.)

CLAUDE.md Configuration

The CLAUDE.md file configures Claude's behavior in your project:

# Project: My App
Tech: TypeScript, React, PostgreSQL

# Policies
- Always write tests first
- Use conventional commits
- Document public APIs

# Workflow
- Parallel agents: enabled
- Auto-commit: disabled
- Review before merge: required

See docs/CLAUDE-TEMPLATE.md for a complete template.

Comparison

	Traditional AI Coding	Director Mode Lite
Workflow	Ask → Wait → Copy → Test → Repeat	Direct → Auto-execute → Review
Parallelism	One task at a time	Multiple agents simultaneously
Automation	Manual intervention needed	Auto-Loop runs until done
Testing	Often forgotten	TDD built into workflow
Documentation	Afterthought	Auto-generated

Examples

Learn by doing with hands-on tutorials:

Example	Description	Time
Calculator	Auto-Loop TDD demo	5 min
REST API	Building an API with TDD	15 min
CLI Tool	Command-line tool	10 min
TypeScript Library	Publishable npm library	20 min

See examples/ for full tutorials.

Community

🌐 Website
claude-world.com

💬 Discord
Join the community

📊 Live Stats
Traffic & community growth

🐛 Issues
Report bugs, request features

Documentation

Document	Description
FAQ	Common questions answered
Concepts	Deep dive into methodology
CLAUDE.md Template	Project configuration guide
Hooks Guide	Hook implementation reference (30 event types)
Self-Evolving Loop	Dynamic skill evolution system
Development Patterns	Learned best practices

Related Projects

Other open-source tools from the Claude World community:

Project	Description	Link
cf-browser	Cloudflare Browser MCP server for headless browsing, screenshots, and web scraping within Claude Code	github.com/anthropic-community/cf-browser
trend-pulse	Real-time trend aggregation MCP server -- monitors 8+ sources (GitHub, Hacker News, Reddit, etc.) for content ideas	github.com/anthropic-community/trend-pulse

These tools work great alongside Director Mode Lite. Use cf-browser for web research agents and trend-pulse for staying on top of developer trends.

Author

Lucas Wang (@lukashanren1)

GitHub: @gn00295120
Product page: claude-world.com/director-mode-lite

License

MIT License - Free for personal and commercial use.

See LICENSE for details.

About Director Mode Lite

This is a free, open-source toolkit (v1.9.0) from the Claude World community, last tested with Claude Code CLI v2.1.201.

What's included (FREE):

27 Commands (incl. validators & generators)
14 Agents (3 Core + 5 Experts + 6 Self-Evolving)
32 Skills
Auto-Loop with TDD
Expert-guided project setup
Validation & template generation
Complete documentation

Want more?

Visit claude-world.com for:

Advanced methodologies
Enterprise support
Full Director Mode experience

Website | Discord | Twitter

_{Made with direction by Claude World Taiwan}

Name		Name	Last commit message	Last commit date
Latest commit History 89 Commits
.claude-plugin		.claude-plugin
.claude/skills/changelog-observer		.claude/skills/changelog-observer
.devcontainer		.devcontainer
.github		.github
.self-evolving-loop		.self-evolving-loop
agents		agents
docs		docs
examples		examples
hooks		hooks
scripts		scripts
skills		skills
tests		tests
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
VERSION		VERSION
demo.sh		demo.sh
install.sh		install.sh
uninstall.sh		uninstall.sh

Uh oh!

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

Director Mode Lite

Start Here

What is Director Mode?

Core Principles

Key Feature: TDD-Driven Auto-Loop

Test-Driven Development Automation

Self-Evolving Loop

Beyond Auto-Loop: Strategy Evolution

Quick Start

Option A: Native Plugin

Option B: Project-Integrated Install

Option C: Try Demo First

Verify Installation

What's Included

Commands (27)

Agents (14)

Skills (32)

The 5-Step Workflow

Parallel Agent Execution

Traditional (Sequential)

Director Mode (Parallel)

Example: Problem Analysis

Scale Out: Multi-Account Delegation

Agents

code-reviewer

debugger

doc-writer

Expert Agents

claude-md-expert

mcp-expert

agents-expert

skills-expert

hooks-expert

Validators & Generators

Validators (5)

Generators (4)

CLAUDE.md Configuration

Comparison

Examples

Community

Documentation

Related Projects

Author

License

About Director Mode Lite

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases 9

Sponsor this project

Uh oh!

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`code-reviewer`

`debugger`

`doc-writer`

`claude-md-expert`

`mcp-expert`

`agents-expert`

`skills-expert`

`hooks-expert`

Packages