Afc:auto

/afc:auto — Full Auto Pipeline

> Runs clarify? → spec → plan → implement → review → clean fully automatically from a single feature description. > Tasks are generated automatically at implement start (no separate tasks phase). > Critic Loop runs at each phase (unified safety cap: 5). Convergence terminates early when quality is sufficient. > Pre-implementation gates (clarify, TDD pre-gen, blast-radius) run conditionally. > Skill Advisor: 5 checkpoints (A–E) at phase boundaries; max 5 auxiliary invocations per pipeline. See skills/auto/skill-advisor.md for details.

Arguments

• $ARGUMENTS — (required) Feature description in natural language

Project Config (auto-loaded)

!cat .claude/afc.config.md 2>/dev/null || echo "[CONFIG NOT FOUND] .claude/afc.config.md not found. Create it with /afc:init."

Config Load

Always read .claude/afc.config.md first. Values referenced as {config.*}:

• {config.ci} — full CI command
• {config.gate} — phase gate command
• {config.test} — test command
• {config.architecture} — architecture rules
• {config.code_style} — code style rules

If config missing: ask user to run /afc:init. If declined → abort.

---

Critic Loop Rules

> Always read ${CLAUDE_SKILL_DIR}/../../docs/critic-loop-rules.md before running any Critic pass. Core: minimum 1 concern per criterion + mandatory Adversarial failure scenario each pass + quantitative evidence required. "PASS" as a single word is prohibited. On ESCALATE: pause and present options via AskUserQuestion even in auto mode.

---

Execution Steps

Phase 0: Preparation

1. If $ARGUMENTS is empty → print "Please enter a feature description." and abort
2. Check current branch → BRANCH_NAME. Determine feature name (2-3 keywords, kebab-case).
3. Preflight Check:

``bash "${CLAUDE_SKILL_DIR}/../../scripts/afc-preflight-check.sh" `` Exit 1 → abort. Warnings (exit 0) → print and continue.

1. Activate Pipeline Flag:

``bash "${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" start {feature} ` Creates afc/pre-auto` safety snapshot, activates Stop Gate Hook, starts change tracking.

1. Create .claude/afc/specs/{feature}/ → record as PIPELINE_ARTIFACT_DIR
2. Initialize Skill Advisor: ADVISOR_COUNT = 0, ADVISOR_TRANSFORM_USED = false

``bash afc_state_write "advisorCount" "0" afc_state_write "advisorTransformUsed" "false" ``

1. Start notification:

`` Auto pipeline started: {feature} ├─ Clarify? → 1/5 Spec → 2/5 Plan → 3/5 Implement → 4/5 Review → 5/5 Clean └─ Running fully automatically (tasks auto-generated, pre-implementation gates conditional) ``

Phase 0.3: Request Triage

1. Necessity: Explore codebase for existing implementations. If feature substantially exists → ask: "(1) Enhance existing (2) Replace entirely (3) Abort". Abort → release pipeline flag and end.
2. Scope: If $ARGUMENTS implies 10+ files or multiple unrelated concerns → warn and ask: "(1) Proceed (2) Reduce scope (3) Abort".
3. Proportionality: If trivially small (single file, single-line, config edit) → suggest fast-path skip.

Phase 0.8: Size-Based Fast-Path Detection (conditional)

ALL 3 criteria must be met to trigger fast-path:

| Criterion | Check | |-----------|-------| | Trivial scope | Explicitly mentions 1-2 specific files or a single-line fix | | No script impact | Does not reference .sh scripts, hooks, or pipeline logic | | Low ambiguity | Clarify gate score 2 files modified: rollback (git reset --hard afc/pre-auto) and restart with full pipeline

1. ```bash

"${CLAUDESKILLDIR}/../../scripts/afc-pipeline-manage.sh" phase fast-path "${CLAUDESKILLDIR}/../../scripts/afc-pipeline-manage.sh" ci-pass ```

1. Run mini-review (single Critic pass). Then run Phase 5 Clean logic.
2. Final output:

`` Fast path complete: {feature} ├─ Mode: ⚡ Fast path (spec/plan skipped) ├─ Changed files: {N} ├─ CI: ✓ └─ Review: mini-review passed ``

If ANY criterion fails: proceed to Phase 0.5 (full pipeline).

Phase 0.5: Auto-Clarify Gate (conditional)

"${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase clarify

Score $ARGUMENTS on 5 ambiguity signals (vague scope, missing quantifiers, undefined entities, unclear boundaries, multiple interpretations). If score >= 3: generate at most 3 questions via AskUserQuestion. Apply answers to refine $ARGUMENTS. In full-auto mode: auto-resolve with best-guess, tag [AUTO-RESOLVED: clarify].

**If score Evaluate BEFORE Phase 1. See skills/auto/skill-advisor.md#checkpoint-a--pre-spec for full evaluation prompts, invocation patterns, and state management. Budget: max 2 skills, max 1 Transform. Skip if ADVISOR_COUNT >= 5.

Signals: A1 (idea-level request → ideate Transform), A2 (domain expertise needed → consult({domain}) Enrich).

After advisor skill completes, append result summary to context.md:

## Advisor: {skill_name} (Checkpoint A)
- Insight: {1-line key finding}
- Action: {1-line required action or "none"}

---

Phase 1: Spec (1/5)

"${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase spec

Execute /afc:spec logic inline:

1. Explore codebase (Glob, Grep) by {config.architecture} layer
2. Research Gate (conditional): scan $ARGUMENTS for external library/API references not in codebase. If found: WebSearch (or Context7) for latest stable version, key constraints. Tag researched items [RESEARCHED]. Skip if all internal.
3. Create .claude/afc/specs/{feature}/spec.md
4. [NEEDS CLARIFICATION] items: research first, then auto-resolve remaining as [AUTO-RESOLVED]
5. Retrospective check: load most recent 10 .claude/afc/memory/retrospectives/ files (if exist) — flag [AUTO-RESOLVED] patterns that previously went wrong
6. Critic Loop until convergence (safety cap: 5, follow docs/critic-loop-rules.md):

• COMPLETENESS: every User Story has acceptance scenarios?
• MEASURABILITY: criteria measurable, quantitative evidence for numerical targets?
• INDEPENDENCE: no implementation details (code, library names) in spec?
• EDGE_CASES: at least 2 identified?
• TESTABILITY: every System Requirement follows EARS pattern? Each has mapped TC (→ TC: should_...)?
• Verdicts: follow docs/critic-loop-rules.md

1. Progress: ✓ 1/5 Spec complete (US: {N}, FR: {N}, researched: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))

---

Skill Advisor Checkpoint B (Post-Spec)

> Evaluate AFTER Phase 1, BEFORE Phase 2. See skills/auto/skill-advisor.md#checkpoint-b--post-spec for full invocation patterns. Budget: max 2 skills. Skip if ADVISOR_COUNT >= 5.

Signals: B1 (sensitive data/trust boundary → security Enrich), B2 (cross-architectural boundary → architect Enrich). If both >= 3: launch parallel. Security/architecture conflicts → ESCALATE.

After advisor skill completes, append result summary to context.md:

## Advisor: {skill_name} (Checkpoint B)
- Insight: {1-line key finding}
- Action: {1-line required action or "none"}

---

Phase 2: Plan (2/5)

"${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase plan

Execute /afc:plan logic inline:

1. Load spec.md
2. Research (ReWOO pattern, if needed): extract technical uncertainties. Plan → Execute parallel Tasks → Solve. Record to .claude/afc/specs/{feature}/research.md. 1-2 topics → resolve directly.
3. Memory loading (skip if absent):

• Quality history: most recent 10 files from .claude/afc/memory/quality-history/ — trend summary
• Decisions: most recent 30 from .claude/afc/memory/decisions/ — conflict check
• Reviews: most recent 15 from .claude/afc/memory/reviews/ — recurring finding patterns

1. Create .claude/afc/specs/{feature}/plan.md. Include structure-analysis-based estimates for numerical targets.
2. Critic Loop until convergence (safety cap: 5, follow docs/critic-loop-rules.md):

• COMPLETENESS, FEASIBILITY, ARCHITECTURE, CROSS_CONSISTENCY, RISK, PRINCIPLES
• CROSS_CONSISTENCY (check all 5): entity coverage, NFR traceability, terminology consistency, constraint propagation, acceptance anchor alignment
• RISK: enumerate at least 3 {config.ci} failure scenarios; check each risk pattern from Project Context
• ARCHITECTURE: describe import paths for moved/created files, pre-validate against {config.architecture} rules
• Each pass must explicitly note what was missed in the previous pass

1. Persist research to .claude/afc/memory/research/{feature}.md
2. ADR recording: invoke afc-architect agent to record architectural decisions. If conflicts found → ESCALATE
3. Session context — write .claude/afc/specs/{feature}/context.md:

```markdown # Session Context: {feature} ## Goal

• Original request: $ARGUMENTS
• Current objective: Implement {feature}

## Acceptance Criteria (from spec.md) {copy ALL FR-, NFR-, SC-* items and GWT acceptance scenarios verbatim} ## Key Decisions

• {what}: {rationale}

## Discoveries

• {file path}: {finding}

```

1. Progress: ✓ 2/5 Plan complete (Critic: converged ({N} passes, {M} fixes, {E} escalations), files: {N}, ADR: {N} recorded, Implementation Context: {W} words)

---

Skill Advisor Checkpoint C (Post-Plan)

> Evaluate AFTER Phase 2, BEFORE Phase 3. See skills/auto/skill-advisor.md#checkpoint-c--post-plan for full invocation patterns. Budget: max 2 skills. Skip if ADVISOR_COUNT >= 5.

Signals: C1 (high interconnection risk → dependency analysis Observe), C2 (unresolved domain uncertainties → consult({domain}) Enrich).

After advisor skill completes, append result summary to context.md:

## Advisor: {skill_name} (Checkpoint C)
- Insight: {1-line key finding}
- Action: {1-line required action or "none"}

---

Phase 3: Implement (3/5)

"${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase implement

Context optimization: If extensive exploration occurred in previous phases, consider /rewind → Summarize from here to compact investigation-heavy sections while preserving plan/spec context intact.

Session context reload: read .claude/afc/specs/{feature}/context.md. If complexity-analysis.md exists, read it and flag high-risk files for extra verification.

Follow all orchestration rules in skills/implement/SKILL.md (mode selection, batch/swarm, failure recovery).

Step 3.1: Task Generation + Validation

Generate tasks.md from plan.md File Change Map. Required format:

- [ ] T{NNN} {[P]} {[US*]} {description} `{file path}` {depends: [TXXX]}

Principles: 1 task = 1 file, same file = sequential, different files = [P] candidate. Append Coverage Mapping (every FR-/NFR- mapped to at least one task).

Check retrospective for past [P] conflict patterns. Run DAG and parallel overlap validation scripts — no critic loop, script-based only. Fix conflicts before proceeding.

Progress: ├─ Tasks generated: {N} ({P} parallelizable), Coverage: FR {M}%, NFR {K}%

Step 3.2: TDD Pre-Generation (conditional)

Trigger: tasks.md contains at least 1 task targeting a .sh file in scripts/.

"${CLAUDE_SKILL_DIR}/../../scripts/afc-test-pre-gen.sh" ".claude/afc/specs/{feature}/tasks.md" "spec/"

Verify skeletons are parseable: {config.test} should show Pending examples. Create tests-pre.md listing expectations per task. Progress: ├─ TDD pre-gen: {N} skeletons generated

Step 3.3: Blast Radius Analysis (conditional)

Trigger: plan.md File Change Map lists >= 3 files.

"${CLAUDE_SKILL_DIR}/../../scripts/afc-blast-radius.sh" ".claude/afc/specs/{feature}/plan.md" "${CLAUDE_PROJECT_DIR}"

Exit 1 (cycle) → ESCALATE. High fan-out (>5 dependents) → warning + RISK note. Save to impact.md. Progress: ├─ Blast radius: {N} planned, {M} dependents

Step 3.4: Execution

1. Baseline test: run {config.test} before task execution. Failure → ask user to proceed/fix/abort.
2. Execute tasks phase by phase per implement.md orchestration rules (sequential/batch/swarm based on [P] count)
3. Implementation Context injection: every sub-agent prompt includes plan.md ## Implementation Context and relevant FR/AC from spec.md
4. Phase gates: always read ${CLAUDE_SKILL_DIR}/../../docs/phase-gate-protocol.md first. On gate pass: "${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase-tag {phase_number}
5. Real-time [x] updates in tasks.md
6. After full completion, run {config.ci}:

• Pass: "${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" ci-pass
• Fail: run /afc:debug logic inline (RCA → hypothesis → targeted fix → re-run). If debug-fix fails 3× → abort

Step 3.5: Acceptance Test Generation (conditional)

Trigger: spec.md has GWT acceptance scenarios AND {config.test} is non-empty.

Map GWT → test cases (Given=Arrange, When=Act, Then=Assert). Run {config.test}. Failures reveal spec-implementation gaps — apply targeted fix or record as SC shortfall for Phase 4.

Progress: ├─ Acceptance tests: {N} generated, {M} passing

Step 3.6: Implement Critic Loop

Critic Loop until convergence (safety cap: 5, follow docs/critic-loop-rules.md):

• SCOPE_ADHERENCE: git diff changed files vs plan.md File Change Map. "M of N files match" count required.
• ARCHITECTURE: changed files vs {config.architecture} rules. "N of M rules checked" count required.
• CORRECTNESS: cross-check against spec.md AC. "N of M AC verified" count required.
• SIDEEFFECTSAFETY: for call order/error handling/state flow changes — verify callee behavior compatibility by reading callee implementation directly.
• Adversarial 3-perspective (mandatory each pass): Skeptic / Devil's Advocate / Edge-case Hunter — one failure scenario each.
• Verdicts: follow docs/critic-loop-rules.md

1. If unexpected problems arose not predicted in Plan: record in .claude/afc/specs/{feature}/retrospective.md
2. Progress: ✓ 3/5 Implement complete ({completed}/{total} tasks, CI: ✓, Critic: converged ({N} passes, {M} fixes, {E} escalations))

---

Skill Advisor Checkpoint D (Post-Implement)

> Evaluate AFTER Phase 3, BEFORE Phase 4. See skills/auto/skill-advisor.md#checkpoint-d--post-implement for full invocation patterns. Budget: max 2 skills. Skip if ADVISOR_COUNT >= 5.

Signals: D1 (testable files changed without test coverage → test generation Enrich), D2 (historical quality issues → pre-review QA Observe).

After advisor skill completes, append result summary to context.md:

## Advisor: {skill_name} (Checkpoint D)
- Insight: {1-line key finding}
- Action: {1-line required action or "none"}

---

Phase 4: Review (4/5)

"${CLAUDE_SKILL_DIR}/../../scripts/afc-pipeline-manage.sh" phase review

Follow all review perspectives in skills/review/SKILL.md (A through H). Context reload: re-read context.md and spec.md before starting.

Step 4.1–4.2: Collect Targets + Reverse Impact Analysis

Collect changed files via git diff HEAD — read full content of each (not just diff). For each changed file, find dependents via LSP(findReferences) or Grep fallback. Build Impact Map. Affected files are cross-reference context, not full review targets.

Step 4.3: Scaled Review Orchestration

For Parallel Batch and Review Swarm only — pre-scan: collect outbound call chain context and include Impact Map in each agent's ## Cross-File Context.

| File count | Mode | |------------|------| | ≤5 | Direct review — no delegation | | 6–10 | Parallel Batch — 2–3 files per agent, single message | | 11+ | Review Swarm — N workers = min(5, file count / 2), single message |

Step 4.4: Specialist Agent Delegation (parallel, perspectives B and C)

Launch in a single message:

• afc:afc-architect — architecture compliance vs rules and ADRs, update MEMORY.md
• `af

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: jhlee0409
• Source: jhlee0409/all-for-claudecode
• License: MIT
• Homepage: https://www.npmjs.com/package/all-for-claudecode

Install and usage instructions live in the source repository linked above.