Ignite

The autonomous-first tech-lead workflow for Claude Code.

19 commands · 2 narrow worker agents · 4 hooks ~3,800 LOC — minimal surface area by design

Why · What it does · Install · First 5 minutes · Commands · How it works · Comparison · Design principles

npx @dev-mn/ignite@latest --claude --global --hooks

Receipts first

Dogfood numbers from a production Next.js SaaS — ~291k LOC, 1,600+ commits of audited git history.

| Metric | With a heavy-spec SDD tool | Same project, 3 weeks raw | Delta | |---|---|---|---| | Planning-only commits | 36% (580 / 1,609) | 6.3% (26 / 412) | −5.7× | | Token spend on cache reloads | 97% of a representative milestone | ~0% | — | | Time on one UI refactor | 11.8h / 59 commits | ~3h / 17 commits | −4× | | "Built the wrong thing" incidents | Recurring | Zero | — |

Conclusion from the engineer running it: the spec tool was eating more time than it saved. Raw Claude Code shipped faster. Ignite v2 is the opinionated minimum that earned its place back in the workflow — and only that.

The problem nobody admits

Most spec-driven development tools for AI coding (GitHub Spec Kit, BMAD-METHOD, Kiro, Claude Flow) share one design choice:

They chain specialized agents through a linear pipeline of artifacts. planner → spec → tasks → executor → verifier — each stage runs with a fresh context window, reading only the transformed artifacts the previous stage wrote.

That works well when the spec itself is the deliverable. It works less well when shipping the code is the deliverable — your original intent decays at every hop. By the time the executor runs, the planner's reasoning is compressed into a task list. By the time anything verifies, the executor's trade-offs are invisible. You ship "done" but not always the thing you asked for.

Ignite v2 doesn't use a pipeline. There's one agent. The main thread keeps your full 1M context window from plan through release. Subagents fire only in parallel — for time savings or context isolation — never for linear hand-off.

What it does

Fills Claude Code's real gaps (only — never wraps)

Claude Code ships /plan, /review, /security-review, /init. Ignite does not wrap these. It adds what's missing around them.

| Gap in raw Claude Code | Ignite's answer | |---|---| | /plan doesn't persist the plan | /ignite:save-plan writes it to .ignite/milestones/<v>/ | | /review output stays in chat | /ignite:post-review --pr 42 posts it via gh pr comment / glab mr note | | No warning when context drops low | context-monitor hook injects WARNING at 35% / CRITICAL at 25% into the agent's own conversation | | No guardrail against batched commits during autonomous runs | atomic-commit-guard PreToolUse hook nudges the agent when a staged commit exceeds 5 files or 200 line changes — advisory, never blocks | | No end-to-end milestone execution | /ignite:autonomous iterates every phase in the main thread with full context | | No automated release notes | /ignite:release auto-detects gh/glab, writes notes from milestone folder + git log, archives, cleans up | | No architectural docs for brownfield repos | /ignite:onboard spawns 3 parallel Explore agents, drafts ARCHITECTURE.md + STANDARDS.md | | No weekly cadence ritual | /ignite:week pulls merged PRs + closed issues + 7-day commit log, prompts for this week's plan | | No pre-release gate | /ignite:pre-release runs 5 parallel audits (review + security + perf + debt + deps), produces GO / NO-GO |

Ten more prompts (zero code cost)

Tier 2 prompt-* commands are pure markdown. Free to fork, free to add.

prompt-mentor · prompt-critique · prompt-tradeoff · prompt-compare · prompt-research · prompt-audit · prompt-deps · prompt-day · prompt-friction · prompt-friction-review · prompt-value-review

Protocols, not commands

When hooks are enabled, CONVENTIONS.md loads on every session start. You type freely:

"Make a tradeoff memo for Postgres vs Mongo for this project."

Claude follows the A/B/C framework. No slash command needed. Ten protocols cover what other tools ship as 30 commands.

The headline: autonomous milestone execution

/ignite:autonomous

You walk away for four hours. Ignite iterates every incomplete phase in the main thread:

1. Reads the phase spec + ARCHITECTURE.md + STANDARDS.md + TRADEOFFS.md
2. Enters Claude Code's native /plan mode, refines, ExitPlanMode
3. Executes with Edit / Write / Bash. Task fires only for parallel scans.
4. Commits each task atomically with conventional prefix
5. Logs non-obvious decisions to checkpoints.md for your async review
6. Context-monitor injects warnings at 35% / 25% remaining — autonomous aborts cleanly before cascade
7. Stops after two consecutive reworks on the same phase

You come back to shipped phases and a pre-release report. If GO, one command to release.

Why this works where prior tools failed: nothing about the architecture fragments your context. One Opus 1M window holds the full milestone goal, every phase, every decision made along the way.

Sleep mode — grind the plan overnight

/ignite:autonomous is careful — it bails on test failures and pauses for plan-mode review each phase. Sometimes you want the opposite: "I wrote a detailed plan, finish it, don't wake me up for anything except context exhaustion."

# Evening: write .ignite/tonight.md from the bundled template
# Bedtime: from a terminal
caffeinate -i claude -p "/ignite:sleep"

Sleep mode pushes through test failures (3 edit-test cycles per task, then wip(...) commit + move on) and ambiguity (picks STANDARDS.md-aligned option, documents the choice). Halts only on:

• all tasks processed
• context-monitor CRITICAL (25% remaining)
• you touch .ignite/halt from another terminal

Morning: git log --oneline shows atomic commits per task. .ignite/tonight-log.md shows decisions made + unresolved TODOs. git revert <sha> undoes any single task.

Hard guardrails (override "push through"): never push, never merge to main, never tag, never release, never remove deps, never edit .env.

Who it's for

| ✅ Built for | ❌ Not for | |---|---| | Senior engineer / tech lead running many projects | 50-person teams needing Jira integration | | Shipping milestones over days or weeks | Writing throwaway scripts (any overhead too much) | | Reviewing team PRs, wants structured feedback | Anyone wanting a plugin marketplace | | Values ADRs + system design as first-class docs | Anyone expecting multi-user state sync | | Wants to walk away and return to shipped work | Anyone who wants a chat-bot, not a tool | | Rejects ceremony — if a command is ritual, delete | Anyone who likes 60+ slash commands |

Install

npx @dev-mn/ignite@latest --claude --global --hooks

| Flag | Meaning | |---|---| | --claude / --copilot | Target runtime | | --global / --local | Install to ~/.claude/ or current project's ./.claude/ | | --hooks | Register SessionStart + Stop + StatusLine + PostToolUse + PreToolUse hooks (strongly recommended — ~40% of value lives here) | | --uninstall | Remove installed files (per-project .ignite/ preserved) |

The installer auto-detects and cleans up legacy ignite install artifacts with confirmation.

First five minutes

# 1. Install globally (hooks on)
npx @dev-mn/ignite@latest --claude --global --hooks

# 2. In an existing project, generate architectural docs
cd ~/Projects/my-app

# Inside Claude Code:
/ignite:onboard
# → drafts .ignite/ARCHITECTURE.md and .ignite/STANDARDS.md

# 3. Start a milestone
/plan                              # CC native — draft goal + scope
# After ExitPlanMode:
/ignite:save-plan --milestone v0.5
# → .ignite/milestones/v0.5/MILESTONE.md

# 4. Add phases
/plan
/ignite:save-plan --phase auth
# → .ignite/milestones/v0.5/phase-01-auth.md

# 5. Walk away
/ignite:autonomous
# Ignite iterates each phase: plan → execute → commit → checkpoint → next
# At the end: pre-release audits run automatically
# If GO: offer /ignite:release

# 6. Monday morning
/ignite:week
# → summary of last week + prompt for this week's priorities

Commands

Tier 1 — Real-code workflow (7)

State writes. Multi-step orchestration. gh/glab automation. Non-trivial to add; each earns its place.

| Command | What it does | |---|---| | /ignite:save-plan --milestone <v> / --phase <slug> | Persist the most recent /plan output | | /ignite:post-review --pr <ref> | Post /review findings to a PR via gh/glab | | /ignite:onboard [--refresh] | Scan codebase, draft ARCHITECTURE.md + STANDARDS.md | | /ignite:week | Weekly cadence — shipped, closed, planned | | /ignite:pre-release | 5 parallel audits → single GO / NO-GO report | | /ignite:release [--draft] | Auto-detect forge, create release, archive milestone, clean up | | /ignite:autonomous [--dry-run] [--stop-at <phase>] | End-to-end milestone execution in main thread | | /ignite:sleep [<plan-file>] [--dry-run] | Overnight unattended execution of a user-written plan — pushes through test failures, halts only on context-CRITICAL or .ignite/halt |

Tier 2 — Stored prompts (10)

Pure markdown. Free to fork. New prompt = new file, zero code cost.

| Command | What it does | |---|---| | /ignite:prompt-mentor [pr\|problem] | Teaching-tone PR review, or deep problem research | | /ignite:prompt-critique <scope> | Brutal forward-looking critique of existing code | | /ignite:prompt-tradeoff <problem> | Structured A/B/C tradeoff memo | | /ignite:prompt-compare <X> <Y> | Head-to-head library / pattern comparison | | /ignite:prompt-research <topic> | Latest-stack research via Context7 + WebSearch | | /ignite:prompt-audit <concern> | Single-concern audit — a11y / i18n / perf / secrets / debt / n+1 / dead-code | | /ignite:prompt-deps | Dependency vulnerability scan via gh/glab API + npm audit / cargo audit | | /ignite:prompt-day [--eod] | Morning standup or end-of-day archive into WEEK.md | | /ignite:prompt-friction <note> | Log a friction note locally (never leaves your machine) | | /ignite:prompt-friction-review | Scan friction logs across all projects, propose a fix plan | | /ignite:prompt-value-review [--days N] | Measure each ignite command's token cost vs a raw-prompt baseline across sessions — KEEP/SIMPLIFY/DEMOTE/CUT verdict |

Tips & patterns

When to use Ignite — and when not to

| Work size | Tooling | |---|---| | Typo · single-file bug fix · 1-2 hour task | Raw Claude Code. Don't use Ignite commands. | | Half-day to 2-day feature | Prompts only. Use prompt-* macros; skip save-plan / autonomous. | | 3-day to 2-week milestone | Full Ignite. save-plan → autonomous → pre-release → release. | | PR review · audit · release | Tier 1 commands. post-review · pre-release · release. |

If a command becomes ritual — you run it because the tool expects it, not because it helps — delete that command. No attachment.

Daily rhythm

Morning      → /ignite:prompt-day          # 3 priorities into TODAY.md
Midday       → /review (CC native) + /ignite:post-review --pr <N>
               /ignite:prompt-mentor pr <N>   # teaching-tone review
               /ignite:prompt-critique <file> # forward-looking harsh
Afternoon    → /plan + /ignite:save-plan --phase <name>   # then execute
End of day   → /ignite:prompt-day --eod     # archive TODAY into WEEK.md
Monday       → /ignite:week                 # past 7d + plan for this week
Before ship  → /ignite:pre-release          # GO/NO-GO
Release day  → /ignite:release              # gh/glab + archive + clean

Autonomous mode — get the most out of it

1. Always --dry-run first to see the phase order + context budget estimate.
2. Working tree must be clean before starting. No uncommitted changes.
3. milestones/<v>/ needs phase files. Autonomous iterates them in order — no phase files, no autonomous.
4. Don't babysit. Walk away. Check checkpoints.md when you return.
5. If it stops on a 2-rework phase — read the reason, fix the root cause, resume.
6. Use --stop-at <phase-slug> for cautious first-runs: stop after phase 1, review, then continue.

Context hygiene (with --hooks enabled)

• React to injected WARNINGs. When the context-monitor injects CONTEXT WARNING: Usage at 68%... into the conversation, that's you getting told to wrap up. Not optional.
• Use /compact between phases if you're going long. Autonomous can suggest it but can't invoke it.
• Don't fight the 35% / 25% thresholds. They're tuned to prevent cascade failures, not to inconvenience you.

Type freely — CONVENTIONS.md has you covered

With hooks on, these all work in plain chat — no command needed:

• "Make a tradeoff memo for Postgres vs Mongo for this project" → A/B/C framework
• "Audit this module for a11y" → checklist walkthrough
• "Append this decision as an ADR" → proper TR-NNNN entry in TRADEOFFS.md
• "Do a daily standup" → yesterday's commits + today's priorities
• "Research vitest 4 vs vitest 2 migration" → Context7 + WebSearch with citations

Commands are for workflows that need real code automation. Everything else is just typing.

State file discipline

• ARCHITECTURE.md — update when fundamentals change (new module, new boundary, new data flow). Never per-feature notes. Keep under 500 lines.
• STANDARDS.md — aspirational, forward-looking. "What we want the code to look like", not what exists. Not a linter rule set.
• TRADEOFFS.md — append-only, never edit past entries. Each decision numbered TR-NNNN. Link from code comments when a file implements a specific decision.
• milestones/<v>/ — will be wiped on release. Don't put anything here you want to keep long-term — put it in ARCHITECTURE or TRADEOFFS.

Friction log habits

1. Log every awkward moment with /ignite:prompt-friction. It's local, no consequences, zero cost.
2. Don't self-edit — your actual raw words are what's useful ("ignite:week-г milestone-той conflict-лээ" is better than a sanitized summary).
3. Review weekly with /ignite:prompt-friction-review. Patterns emerge after ~20 entries across 2-3 projects.
4. v1.1 command candidates must show up 3 or more times in friction review before they land.

Team PR review

• Code review flow: /review (CC native) → /ignite:post-review --pr 42 (auto-posts findings to the PR).
• Teaching review: /ignite:prompt-mentor pr 42 — frames feedback as questions + learning opportunities instead of commands. Different from /review's fair-audit tone.
• Harsh self-critique: /ignite:prompt-critique <file> — brutal, forward-looking, on YOUR code. Not for team PRs.

Common mistakes to avoid

• Running /ignite:autonomous without phase files. It needs milestones/<v>/phase-NN-*.md. Run /ignite:save-plan --phase first.
• Committing .ignite/friction.log to public repos. It's personal notes and may include raw frustrations. Gitignore per-project or stage selectively.
• Adding a new command because it "sounds useful". 10-question gate. Same-pattern friction 3+ times in the review. Otherwise no.
• Treating CONVENTIONS.md as CC-native. It only loads with --hooks. Without hooks, protocol-mode doesn't fire.
• Skipping --dry-run on autonomous for a milestone you haven't seen the tool execute before.
• Editing TRADEOFFS.md past entries. It's append-only. If a decision is obsolete, append a new ADR that supersedes it.

How it works

One page of architecture

~/.claude/
├── agents/
│   ├── ignite-auditor.md              single-concern audit (security/a11y/perf/debt/deps/…)
│   └── ignite-reviewer-teaching.md    mentoring-tone PR review
├── commands/ignite/*.md               19 slash commands
├── ignite/
│   ├── CONVENTIONS.md                 loaded at SessionStart
│   └── templates/                     scaffolds for .ignite/
└── settings.json                      SessionStart + Stop + StatusLine + PostToolUse + PreToolUse hooks

<your-project>/.ignite/
├── ARCHITECTURE.md                    PERSISTENT — system design
├── STANDARDS.md                       PERSISTENT — aspirational coding standards
├── TRADEOFFS.md                       PERSISTENT — append-only ADR log
├── WEEK.md                            ROLLING — this week's journal
├── TODAY.md                           ROLLING — today's priorities
└── milestones/v0.5/                   EPHEMERAL — cleared on /ignite:release
    ├── MILESTONE.md
    ├── phase-01-auth.md
    ├── phase-02-db.md
    ├── week-NN.md                     weekly snapshots archived here
    └── checkpoints.md                 autonomous-run decisions

Three classes of state

1. Persistent system truth. ARCHITECTURE.md, STANDARDS.md, TRADEOFFS.md. Evolves when fundamentals change. Never cleared.
2. Rolling current state. WEEK.md, TODAY.md. Auto-updated by week and prompt-day.
3. Ephemeral milestone folder. milestones/<v>/. Cleared on release — content archived into the gh/glab release body. Architectural truth lives on; milestone cruft doesn't.

Subagents: parallel workers, never a pipeline

Two narrow specialist agents — ignite-auditor and ignite-reviewer-teaching — spawned only for parallel time savings or context isolation. Never for linear hand-off.

| Command | Parallel fan-out | |---|---| | /ignite:pre-release | 5 parallel (Explore-review + Explore-security + 3× ignite-auditor for perf / debt / deps) | | /ignite:post-review --tone teaching | 1× ignite-reviewer-teaching to reframe findings before posting | | /ignite:onboard | 3 parallel Explore scans (stack + architecture + conventions) |

Every other command runs in the main thread, where your full context lives. The differentiator vs heavy SDD tools (GSD, BMAD, Claude Flow) is no cascading handoff between agents — not the count. Adding a 3rd specialist later doesn't change the architecture.

Context safeguards

When --hooks is on, the statusline writes /tmp/claude-ctx-<session>.json after each tool use. The PostToolUse context-monitor hook reads it and, at 35% remaining, injects a WARNING into Claude's conversation. At 25%, CRITICAL. Debounced to 5 tool uses between warnings; severity escalation (WARNING → CRITICAL) bypasses debounce.

This makes /ignite:autonomous safe to leave unattended — the agent itself learns it's running out of room and stops at a natural boundary.

A sibling PreToolUse hook, atomic-commit-guard, watches every git commit (Bash matcher). If the staged diff exceeds 5 files or 200 line changes, it injects an advisory nudge toward git reset HEAD + staging one logical change at a time. It skips --amend and never blocks — Ignite's atomic-commit convention was prompt-only before; this hook turns it into feedback the agent actually sees during autonomous runs.

Comparison

Honest head-to-head with the most common spec-driven development tools. No tool wins every axis — pick the one whose tradeoffs match your work.

| Axis | Ignite v2 | GitHub Spec Kit | BMAD-METHOD | Kiro | Claude Flow | GSD | |---|---|---|---|---|---|---| | Philosophy | Execution-first — code is the product | Spec-first — the spec is the durable artifact | Multi-persona SDLC simulation | Autonomous IDE + spec/hook loop | Swarm orchestration / SPARC | Full-SDLC pipeline with per-stage specialists | | Primary surface | Plugin on Claude Code + Copilot | Plugin across Claude Code, Copilot, Cursor, Gemini, Windsurf, Qwen, opencode | Plugin across Claude Code, Cursor, any LLM | Own IDE (standalone, AWS) | Plugin on Claude Code | Plugin on Claude Code | | Agent model | 2 narrow specialists (ignite-auditor, ignite-reviewer-teaching), main thread holds context | Command chain — no persistent personas | 6+ persona agents (analyst, PM, architect, SM, dev, QA, …) | Autonomous agents + hooks + steering files | 50+ specialized agents in a swarm | 30+ specialist subagents (planner, plan-checker, executor, verifier, …) | | Context handoff between stages | None — full 1M window preserved | Via spec.md → plan.md → tasks.md artifacts | Via story/PRD/architecture/epic handoff between personas | Via spec files + steering docs | Via shared memory layer (MCP) | Via multi-doc pipeline (CONTEXT.md → PLAN.md → SUMMARY.md → VERIFICATION.md) | | Slash commands shipped | 17 (7 tier-1 + 10 tier-2 prompts) | ~7 (/constitution, /specify, /clarify, /plan, /tasks, /analyze, /implement) | ~30 (per-persona command surface) | N/A (IDE UI, not slash-driven) | 60+ | ~60 | | Artifacts per feature | 1 phase file (phase-NN-*.md) | spec + plan + tasks (+ research, contracts) | story + PRD + architecture + epic + QA gates | spec + hooks + steering | many (per agent + memory) | 4–5 state files per phase | | Claude Code native commands | Builds on top — never wraps /plan /review /security-review | Replaces with own commands | Replaces with own commands | N/A (own IDE) | Wraps and extends | Wraps and replaces | | Autonomous milestone run | Yes, main-thread, full context | No (spec-then-implement loop) | Multi-persona handoff chain | Yes, in-IDE | Swarm-parallel execution | Multi-agent chain (fresh context per stage) | | Opinionation on process | Milestone → phase → autonomous → release gate | Mandatory spec before code | Mandatory SDLC phases with gates | Spec-driven + hook-driven | SPARC / swarm patterns | Mandatory SDLC gates, heavy audit trail | | Best when you want… | Ship a milestone without ceremony, one or two engineers | A durable spec as a deliverable you hand off | A simulated full agile team with named roles | An IDE built around SDD, not a plugin | Massively parallel exploration on one problem | Maximal automation + audit artifacts for every decision |

Pick Ignite v2 if you already live in Claude Code, you're one or two engineers, and you want a milestone to finish on its own without a spec-heavy ritual eating your token budget. Pick Spec Kit if the spec is the thing you're writing for other humans or other agents to consume. Pick BMAD-METHOD if you want the full simulated agile-team experience with PMs, architects, scrum masters. Pick Kiro if you want an IDE built around SDD rather than a plugin that rides on an existing one. Pick Claude Flow if your work benefits from many agents running in parallel on a single problem. Pick GSD if you need a paper trail — every stage documented, every decision verified, and don't mind the context-handoff tax that costs.

Design principles

1. Never duplicate Claude Code native. /plan, /review, /security-review, /init are CC's.
2. Autonomous execution is first-class, main-thread only. No subagent chains carrying intent across phases.
3. Conventions are protocols, not commands. CONVENTIONS.md teaches Claude the format once; you type freely.
4. Subagents are parallel I/O workers. Spawn only when parallelism or context isolation genuinely helps.
5. Persistent docs are small and timeless. Three files. Milestone work is ephemeral.
6. New commands face a 10-question gate. Real frictions must repeat 3+ times before landing.
7. Tech-lead lens by default. Tradeoffs, security, design — not test-coverage theater.

Full principles + repo contracts: CLAUDE.md.

Reaping dead code

Custom TS-Compiler-API analyzer. No knip/ts-prune/depcheck wrappers — we walk the project's own import graph, detect dynamic-import patterns that static analysis can't see, and verify every proposed removal with pnpm typecheck && pnpm test --run on an isolated reap/YYYY-MM-DD-HHmm branch. Main is never touched.

# Analysis only — no writes, no branch
npx @dev-mn/ignite reap --dry-run

# Real run — up to 5 verified removals on a fresh branch
npx @dev-mn/ignite reap --max-candidates 5

# Scope to a monorepo workspace
npx @dev-mn/ignite reap --scope apps/app

# Save the full report next to the run
npx @dev-mn/ignite reap --save

Morning review: git diff main..reap/<date>, merge what you want, delete the branch if something looks off.

Flags: --dry-run · --keep-only (analysis only) · --scope <dir> · --save · --max-candidates N. Full architecture + limitations: docs/reap-architecture.md.

Status & roadmap

v2.0.0-dev — installable, testable, architecture validated against the failure modes of prior tools. Intentionally pre-v1 until 2–3 weeks of real dogfood close the loop.

• 19 commands · 1 agent · 4 hooks · 1 CLI subcommand (reap) · 61 passing tests · end-to-end bridge verified
• Full design spec: PLAN.md
• Session archive (every decision + every rejection + every user preference): docs/session-2026-04-17-design.md

v1.0 — after dogfood validates

• 2–3 weeks of real use on production projects
• prompt-friction-review surfaces v1.1 candidates
• npm publish · package name finalization

v1.1 — only if friction evidence supports it

prompt-audit --parallel · prompt-critique --all · triage · postmortem · retro · deps promoted to Tier 1

Every v1.1 candidate must have prompt-friction entries showing the same pain point three or more times before it lands. No speculative features.

v2 — multi-runtime + deeper tech-lead scope

Gemini / Cursor / Windsurf via the runtime extensibility hook · capacity-planning mode on architect · ADR audit

Explicit non-goals (forever)

1:1 prep · performance reviews · hiring pipelines · budget tracking · Slack/calendar integrations · plugin marketplace · multi-user state sync.

Development

pnpm install
pnpm typecheck           # tsc --noEmit
pnpm test                # vitest (14 tests)
pnpm build               # tsup → dist/main.js + dist/hooks/*.js

# Smoke test in isolated HOME
TEST_HOME=$(mktemp -d)
HOME=$TEST_HOME node dist/main.js --claude --global --hooks
ls $TEST_HOME/.claude/

Full repo conventions, commit rules, and the 10-question gate: CLAUDE.md.

License

MIT