all-for-claudecode

Claude Code plugin that automates the full development cycle — spec → plan → implement → review → clean.

One command (/afc:auto) runs the entire cycle. Zero runtime dependencies — pure markdown commands + bash hook scripts.

Quick Start

# Option A: Inside Claude Code
/plugin marketplace add jhlee0409/all-for-claudecode
/plugin install afc@all-for-claudecode

# Option B: npx
npx all-for-claudecode

Then:

/afc:init                              # Detect your stack, generate config
/afc:auto "Add user authentication"    # Run the full pipeline

The pipeline will:

1. Write a feature spec with acceptance criteria
2. Design an implementation plan with file change map
3. Implement tasks with CI gates (auto task decomposition + parallel execution)
4. Run code review with architecture/security agent analysis
5. Clean up artifacts and prepare for commit

How It Works

/afc:auto "Add feature X"

Spec (1/5) → Plan (2/5) → Implement (3/5) → Review (4/5) → Clean (5/5)
  │              │              │                │              │
  │              │              │                │              └─ Artifact cleanup
  │              │              │                └─ 8 perspectives + agent review
  │              │              └─ Auto task decomposition, parallel execution, CI gates
  │              └─ File change map, ADR recording, research persistence
  └─ Acceptance criteria, pre-implementation gates

Hooks run automatically at each step.
CI failure → debug-based RCA (not blind retry).
Critic Loops verify quality at each gate until convergence.

Walkthrough: What a Pipeline Run Looks Like

Running /afc:auto "Add password reset flow" produces this (abbreviated):

Spec (1/5) — Generates spec.md with requirements and acceptance criteria:

FR-001: POST /auth/reset sends email with token
FR-002: GET /auth/reset/:token validates and shows form
FR-003: Token expires after 1 hour
Acceptance: Given expired token, When user submits, Then show error

Plan (2/5) — Creates plan.md with file change map and architecture decisions:

File Change Map:
  src/routes/auth.ts        — ADD reset endpoint handlers
  src/services/email.ts     — ADD sendResetEmail()
  src/middleware/validate.ts — MODIFY add token validation
  tests/auth.test.ts        — ADD reset flow tests

Implement (3/5) — Auto-decomposes into tasks, executes with CI gates:

Tasks: 4 total (2 parallel)
  [1] Add reset endpoint     ✓
  [2] Add email service       ✓  ← parallel with [1]
  [3] Add token validation    ✓  ← depends on [1]
  [4] Add tests               ✓
CI: npm test → passed

Review (4/5) — 8-perspective review + specialist agent analysis:

Architecture (afc-architect): ✓ layer boundaries respected
Security (afc-security): ⚠ rate-limit reset endpoint
Performance: ✓ no N+1 queries
→ Auto-fixed: added rate limiter middleware

Clean (5/5) — Removes pipeline artifacts, final CI check.

Slash Commands

Individual Command Examples

# Write a spec for a specific feature
/afc:spec "Add dark mode toggle"

# Design a plan from an existing spec
/afc:plan

# Debug a specific error
/afc:debug "TypeError: Cannot read property 'user' of undefined"

# Run code review on current changes
/afc:review

# Explore and structure a product idea
/afc:ideate "real-time collaboration feature"

Hook Events

Every hook fires automatically — no configuration needed after install.

Handler types: command (shell scripts, all events), prompt (LLM single-turn, TaskCompleted).

Persistent Memory Agents

Task Orchestration

The implement phase automatically selects execution strategy:

Dependencies are tracked via DAG. CI gate + Mini-Review + Auto-Checkpoint run at each phase boundary.

Configuration

/afc:init

Auto-detects your tech stack (package manager, framework, architecture, testing, linting) and generates .claude/afc.config.md with CI commands, architecture rules, and code style conventions. No manual preset selection needed — the init command analyzes your project structure directly.

FAQ

Does it work with any project?

Yes. Run /afc:init to auto-detect your stack. Works with JavaScript/TypeScript, Python, Rust, Go, and any project with a CI command.

Does it require any dependencies?

No. Pure markdown commands + bash hook scripts. No npm packages are imported at runtime.

What happens if CI fails during the pipeline?

Debug-based RCA: traces the error, forms a hypothesis, applies a targeted fix. Halts after 3 failed attempts with full diagnosis.

Can I run individual phases?

Yes. Each phase has its own command (/afc:spec, /afc:plan, /afc:implement, /afc:review). /afc:auto runs them all.

What are Critic Loops?

Convergence-based quality checks after each phase. They evaluate output against criteria and auto-fix issues until stable. 4 verdicts: PASS, FAIL, ESCALATE (asks user), DEFER.

How many tokens does a pipeline run use?

Depends on project size and feature complexity. A typical /afc:auto run for a medium feature uses roughly the same as a detailed manual implementation session — the pipeline adds structure, not overhead.

Can I customize the pipeline behavior?

Yes. Edit .claude/afc.config.md to change CI commands, architecture rules, and code style conventions. The pipeline reads this config at every phase.

Does it work with monorepos?

Yes. Run /afc:init in the monorepo root. The init command detects workspace structure and configures accordingly.

Can multiple team members use it on the same repo?

Yes. Each developer runs their own pipeline independently. The .claude/afc.config.md config is shared (commit it to the repo), but pipeline state is local and session-scoped.

How is this different from Cursor / Copilot / other AI tools?

All-for-claudecode is not a code completion tool — it is a structured development pipeline. It enforces spec → plan → implement → review flow with quality gates, persistent memory agents, and CI verification at every step.

License

MIT