Documentation
Everything DevFlow does, why it does it that way, and how to drive it.
DevFlow is a Claude Code plugin that turns a description of what you want into shipped, verified code. It does that by keeping the system complicated so your workflow doesn’t have to be: context engineering, XML-structured prompts, subagent orchestration and durable state all sit behind a handful of commands.
Where to start
If you have never used DevFlow, read these three in order. Twenty minutes total.
- Installation — the two-line install and what it registers.
- Quickstart — build something small, end to end.
- Context rot — the problem the whole design answers.
How this site is organised
- Getting started — install, first project, adopting an existing codebase.
- Concepts — the ideas you need to predict what DevFlow will do.
- Commands — all 2.5.0-era skills, grouped by what you’re trying to accomplish.
- Architecture — the agents, hooks and plugin layout underneath.
- Configuration —
config.json, model profiles, gates, environment variables. - Guides — task-shaped walkthroughs for GitHub sync, workstreams, UI eval and releases.
- Reference — the
df-toolsCLI, the.planning/file structure, the defaults table, a glossary.
Generated from source
The command, agent, hook and CLI tables on this site are generated from the plugin source at build time byscripts/gen-docs-data.cjs. If a table here disagrees with
your installed version, check which version you have — the tables cannot drift from
the release they were built against.Troubleshooting
The failures people actually hit, and what to do about each.
Contributing
Working on DevFlow itself: layout, tests, conventions and the release gate.
Getting started
Install the plugin, run your first objective, and point DevFlow at code you already have.
Installation
DevFlow ships as a Claude Code plugin. Two lines, no build step, works on macOS, Windows and Linux.
Quickstart
Ten minutes: initialise a project, plan one objective, build it, verify it.
Your first project
A closer look at what new-project produces, and how to steer it before it commits to a plan.
Existing codebases
Adopting DevFlow on code that already exists — map it first, then plan against reality.
Concepts
The ideas behind the commands. Read these and DevFlow’s behaviour stops being surprising.
Context rot
The problem DevFlow exists to solve, and why the answer is structural rather than a prompting trick.
The loop
Six phases, each writing files the next one reads. What each phase produces and when to skip it.
The .planning directory
Every file DevFlow creates, who writes it, and who reads it back.
The intent model
kind × work → TDD posture, planning depth, model profile and verification rigor. A spike is not tested like a payments API.
Waves and checkpoints
How independent jobs run in parallel, and the four ways execution can legitimately stop.
State and memory
What survives a /clear, a reboot and a week away — and how to get it back.
Context discipline
Measured guidance on keeping an agent's window small. The lever is behaviour, not configuration.
Commands
Every skill, grouped by what you’re trying to get done. All tables on these pages are generated from the plugin source.
Core workflow
The commands that plan, build and verify. These are the ones you use daily.
Status and navigation
Finding out where you are, what's next, and what everyone else is doing.
Managing the plan
Changing scope mid-milestone: adding objectives, auditing, archiving, and fixing drift.
Advanced execution
Parallel worktrees, chained skills, and handing TTY-bound commands to your own shell.
Integrations and analysis
GitHub sync, strategic initiatives, UI evaluation, security auditing and codebase mapping.
Settings
Changing which agents run, which models they use, and how much the workflow asks you.
Architecture
The agents, hooks and plugin layout that make the commands work.
Agents
The 13 subagents skills dispatch to, what each is for, and which model tier each runs at.
Hooks
How DevFlow turns advisory rules into enforced ones — and every documented way out.
Plugin layout
Where everything lives in the repository, and how the pieces reference each other.
Configuration
config.json, model profiles, gate severity, and every environment variable.
config.json
The full workflow configuration schema, field by field, with the defaults DevFlow ships.
Model profiles
Three profiles map every agent onto a model tier. What each costs, and why budget isn't Haiku everywhere.
Gates and enforcement
Which gates block, which merely ask, how to tune each, and how to log an override rather than hiding it.
Environment variables
Every DEVFLOW_ variable, what it changes, and the Claude Code variables worth leaving alone.
Guides
Task-shaped walkthroughs for the parts of DevFlow you opt into.
GitHub integration
Mirror planning state to issues, milestones and releases. One-way — planning files stay the source of truth.
Parallel workstreams
Running whole objectives concurrently in git worktrees, then merging them back.
The handoff watcher
A local daemon that runs TTY-bound commands in your shell so Claude never has to stop and ask.
UI evaluation
Machine-judged visual correctness — capture each declared UI state, score it offline, gate verification on the result.
Telemetry and auditing
Measuring where context goes, where agents get blocked, and whether gates are earning their friction.
Changelog and releases
Generating Keep-a-Changelog entries from conventional commits, and the gate that stops an undocumented release tag.
Reference
The CLI surface, the file structure, and the vocabulary.