devflow

devflow

Adaptive Claude Code workflow plugin. Lean for tiny work, strict for risky work, deterministic safety hooks, and every phase routed to a Fable agent running at the effort level the phase deserves.

devflow turns a coding request into the right depth of workflow. A classifier picks a mode (tiny / standard / deep / debug), then runs the matching flow: tiny work stays inline in the main session; everything heavier dispatches phase-isolated subagents that hand each other compact context packets instead of re-reading the repo.

Install

devflow installs as a real Claude Code plugin (hooks auto-wire, nothing is copied loose into ~/.claude):

./install.sh                 # macOS / Linux / WSL

.\install.ps1                # Windows

Manual equivalent:

claude plugin marketplace add <path-to-this-repo>
claude plugin install devflow@devflow

Uninstall with ./uninstall.sh / .\uninstall.ps1 (add --remove-marketplace / -RemoveMarketplace to drop the marketplace entry too).

Upgrading from a pre-2.0 manual install: remove the old copies first — ~/.claude/commands/devflow*.md, ~/.claude/agents/devflow-*.md, ~/.claude/skills/devflow-*, ~/.claude/devflow/.

Use

/devflow add a health endpoint to the payments service
/devflow-plan migrate the refund flow to the v2 provider API
/devflow-execute docs/devflow/plans/refund-v2.md
/devflow-debug PaymentServiceTest fails on CI with a 500
/devflow-review current branch
/devflow-finish
/devflow-auto on

/devflow classifies and runs the whole flow. The other commands enter a specific phase directly. /devflow-auto toggles auto-continue (below).

Modes

Mode	When	Flow
tiny	one-sentence, no behavior risk	inline — read, edit, focused verification. No subagent.
standard	behavior change, clear architecture	plan (file) → adversarial plan review → implementation → review + verify
deep	architecture, data model, auth/payments/PII, public API, unclear scope	discovery → spec + plan files → plan review → stop before execution
debug	existing failure, stack trace, regression	reproduce → evidence → root cause → minimal fix → verify + regression check

Conflict rules: debug+deep starts as debug until root cause is known; unsure tiny/standard → standard; unsure standard/deep → deep; unfamiliar code is never tiny.

The canonical routing rules and effort matrix live in one place: skills/devflow-adaptive-routing/SKILL.md. One model everywhere (Fable); tiers (max-reasoning/xhigh, working/medium) are pinned per agent in frontmatter — planning always gets xhigh, never downgraded; everything else runs medium. Every dispatch announces itself in the conversation: ▸ <agent> · fable @ <effort> printed immediately before each spawn. A PreToolUse hook (hooks/agent-status.sh) additionally guards against model= params overriding the frontmatter pin (its output is not rendered by current Claude Code versions — the printed line is the visible channel).

What makes it strict

• Deterministic safety hooks (auto-wired, deliberately narrow): git push routes to a user confirmation prompt and force-push (incl. git -C/-c … forms) is hard-blocked — other git commands are untouched. Destructive SQL (DROP/TRUNCATE, unscoped DELETE/UPDATE) and secret-file writes via shell (guard.sh) or the Write/Edit tools (guard-write.sh) are hard-blocked — even under --dangerously-skip-permissions. Deliberate bypass (only when the user explicitly asked): DEVFLOW_UNSAFE=1 <cmd> (bash) or $env:DEVFLOW_UNSAFE='1'; <cmd> (PowerShell). Hooks need bash on PATH (Git for Windows provides it); a one-line prose rule in every subagent prompt remains as the fallback layer.
• Mandatory plan review. Every standard/deep plan is adversarially reviewed by an independent subagent against the real repo before any code is written. Revision round 2 reviews only the diff. Cap 2 rounds, then findings go to the user.
• Evidence-gated completion. "Ran <cmd> — N passed" or it isn't done. "Should work" is forbidden vocabulary.
• Never guess — verify. Any uncertain external fact (API signature, version behavior, default, error meaning) triggers the research skill: repo source first, inline web search second, findings cached per-repo in docs/devflow/research/. Hard cap 5 research agents; default is zero.

What makes it cheap