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:setup                             # Set up global routing in ~/.claude/CLAUDE.md
/afc:init                              # Detect your stack, generate project 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

Skill Advisor checkpoints (A–E) between phases dynamically invoke
auxiliary skills (ideate, consult, architect, security, test, qa, learner)
when LLM evaluation detects they would add value. Budget: max 5 per run.

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"

# Triage open PRs and issues
/afc:triage              # all open PRs + issues
/afc:triage --pr         # PRs only
/afc:triage --deep       # deep analysis with diff review
/afc:triage 42 99        # specific items by number

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

Expert Consultation

Get advice from domain specialists — each with persistent memory of your project:

/afc:consult backend "Should I use JWT or session cookies?"
/afc:consult infra "How should I set up CI/CD?"
/afc:consult pm "How should I prioritize my backlog?"
/afc:consult design "Is this form accessible?"
/afc:consult marketing "How to improve SEO?"
/afc:consult legal "Do I need GDPR compliance?"
/afc:consult security "Is storing JWT in localStorage safe?"
/afc:consult advisor "I need a database for my Next.js app"

# Auto-detect domain from question
/afc:consult "My API is slow when loading the dashboard"

# Exploratory mode — expert asks diagnostic questions
/afc:consult backend

Features:

• Persistent memory: experts remember your project's decisions across sessions
• Overengineering Guard: recommendations scaled to your actual project size
• Domain adapters: industry-specific guardrails (fintech, ecommerce, healthcare)
• Pipeline-aware: when a pipeline is active, experts consider the current phase context

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:setup    # One-time: inject routing block into ~/.claude/CLAUDE.md
/afc:init     # Per-project: detect stack and generate .claude/afc.config.md

• /afc:setup — Manages the AFC routing block in your global ~/.claude/CLAUDE.md. Run once after install and again after plugin updates. Idempotent — skips if version matches.
• /afc:init — Auto-detects your tech stack (package manager, framework, architecture, testing, linting) and generates project-local config files. No manual preset selection needed.

Development Docs

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:clean). /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