Process Lifecycle
The flow for developing with pair, four phases, two workflows, three modes and the skills that drive them, with links to configuration and commands.
The lifecycle is the spine of working with pair. Four phases take a product from idea to merged code; two workflows run on top of them; three modes decide who drives; a stack of skills does the work. Every page in this section links out to the guide that configures a thing and the reference that documents its commands.
Figure: read it left to right. The phases are the ground; the two workflows sit on the last two phases; the three modes change who drives, never what runs.
The four parts
- Phases: induction (one-time setup), strategic planning, iteration and execution. Nine numbered steps, each with a how-to guide and a skill. See Phases.
- Two workflows: the analysis and refinement workflow turns an idea into a Ready card; the delivery workflow turns a Ready card into a review-approved pull request. In depth.
- Three modes: Assisted (pair guides you through every phase), Supervised (pair automates one card end to end) and Autonomous (pair watches the backlog and processes every card matching your criterion), like the levels of driving automation in cars. Same phases, same workflows; what changes is who drives. See Lifecycle modes.
- Skill layers: capability skills at the bottom, process skills in the middle, workflow, loop and batch skills on top. See Skill layers.
Ahead of the phases sits one optional entry point, before Induction: /pair-process-brainstorm, a structured discovery interview that turns a theme into a Draft epic and story tree. It never modifies the PRD.
Let /pair-next guide you
You do not need to memorize the sequence. Run /pair-next at any point: pair reads your project state (open issues, story states, task progress) and suggests the next step. Use it at the start of every session, after finishing a step, or whenever you are unsure.
Where to start
| You are... | Start at | Skill |
|---|---|---|
| Starting a brand new project | Step 1, PRD | /pair-process-specify-prd |
| Adopting pair on an existing project | Step 2, Bootstrap | /pair-process-bootstrap |
| Opening a new initiative or roadmap cycle | Step 3, Initiatives | /pair-process-plan-initiatives |
| Planning a sprint | Step 5, Stories | /pair-process-plan-stories |
| Picking up a story to develop | Step 8, Implement | /pair-process-implement |
| Reviewing a PR | Step 9, Review | /pair-process-review |
The risk-driven thread
Every story carries a risk tier, and the tier decides how much gate, review and merge ceremony its pull request gets. It enters at refinement (/pair-capability-classify writes the matrix and, when the project projects tags, the risk:* tag), is copied onto the PR by publish-pr, scales the pre-merge gate and the review, and filters what tag-driven automation may pick up. Review may raise a tier, never lower it. The model lives in Tag-driven quality gates and the Quality model; switching it on is a guide: Classify stories and use risk tags.
What to read next
| You want to | Read |
|---|---|
| Set up a project | Induction |
| Go from idea to Ready stories | Analysis and refinement workflow, then the brainstorming and refinement tutorials |
| Go from Ready story to PR | Delivery workflow, then Deliver a card |
| Choose how much to automate | Lifecycle modes, then Automated development |
| Know which skill drives which | Skill layers, then the Skills catalog |
| Configure behaviour | Guides for the recipe, Adoption settings for every key |
| Look up commands | CLI commands and /pair-assistant |
Terms you will meet here (card, macrostate, harness, engine, seal, handoff) are defined once in the glossary.
Next: Phases, the nine steps and what each one leaves behind.