What the installer writes
A small state file the tool owns and keeps current, a skill and a handful of commands under your Claude configuration, a session hook, and four lines added to your context file. That is the whole footprint.
Install
One command, and your Claude Code knows the method
npx halfcycle There is nothing to read first and nothing left behind in your repository afterwards. You do not need to learn a process before you start. It works out where your project has got to and tells you what to do next, in plain language, at the point where it matters.
Your code, your data and everything the model does stay on your machine and your own Claude seats.
What happens next
The first hour, turn by turn
No dashboard to configure, no template repository to fork. You talk to it, it drafts, and it starts arguing.
Turn 1
It reads your repository and proposes the setup
Six engagement decisions, each arriving with a recommended default drawn from what it found in your project rather than a blank form. It writes the context files your agents will read on every future session, plus hooks and tracker wiring. It refuses to record a decision with no reason attached.
Turn 2
It drafts the product spec, then grills you on it
You describe what you are building and get a full PRD back. Then the questions start: one at a time, ordered so that nothing gets asked before the thing it depends on, each with a recommended answer and the reasoning. Facts it can resolve itself it resolves and shows you. Decisions it cannot make for you it actually asks.
Turn 3
It writes the architecture and mines the invariants
An architecture document, a container level diagram, and the rules your system must never break pulled out and given IDs so later specs reference them instead of restating them. The diagram and the prose have to agree: a reviewer reading only the diagram must be able to reconstruct the system.
Turn 4
It slices the work into phases that ship
A four question sizing diagnostic runs on each phase. Two or more answers point the wrong way and the phase gets split. Anything the scoping pass assumed rather than verified is marked as assumed, so it cannot travel downstream wearing the same confident voice as a checked fact.
The gate
It refuses to write feature specs on a spec that is not ready
Eight checks run as an independent verdict, off your machine, against the work so far. Too many red is a hard stop, and the gate holds until you fix them. This is the check no template can run on itself, and it is the reason the rest is worth doing.
A second verdict runs later on the feature specs: a reviewer that has never seen this spec before, checking claims are anchored to real lines in real files, that every feature has acceptance criteria a reviewer can check, and that no two specs quietly assume contradictory things.
Then
It decomposes the phase into a dependency ordered task graph
The specs become work items in the order they can actually be done, with what each one touches and depends on written down.
The build
A team of agents builds the phase, and you can watch it
One agent coordinates and the others each work on a separate copy of the code, so the phase gets built the way a team would build it rather than one task at a time. What they write is checked as well as the plan, and the project page shows where everything stands: what each agent is doing, what passed, and what was stopped and why.
What lands on disk
Almost nothing
What it never writes
No method folder. The runbooks, templates and question sets are served to the session that asks for them, scoped to the step you are on, and are never at rest in your repository. The rubrics and matchers behind the verdicts never leave our infrastructure at all. Only the verdict crosses.
Where your code goes
Nowhere. Inference runs on your machine against your own Claude seats. We never hold or proxy your credential. Content submitted for a verdict is checked and discarded, which forecloses training on your documents by construction.
What your repository gains
The documents the method produces, under your own
docs/, in your git history, in plain
markdown. Spec, architecture, phases, feature specs, task graph. Yours
whether you keep paying or not.
Plans
Three, and the first one is free
Plans, not products. All three run the same method and call the same verdicts.
Free
Solo
Senior team discipline for a team of one. The full method and every check, on your own seat.
- Everything on this page
- One developer
- No card required
Per seat
Team
The ratchet. The requirement lives in the repository, so every contributor inherits the same gates with no personal setup, and a new hire is compliant in one command.
- Identical gates across every seat
- Build Record per phase
- Shared spec index and drift checks
Under contract
Sovereign
For teams whose data cannot leave a defined perimeter. Pulled rather than pushed.
- Data sovereignty perimeter
- Region and residency controls
- Negotiated terms
Questions we actually get
Before you install
Do I need to read the method first?
No. The guidance arrives when a step needs it. Read the method page if you want to know why the layers exist, not to be able to start.
Does this replace Cursor, or Claude Code, or the agent I already use?
No. It runs inside Claude Code and governs what the agents produce. If your team already has a framework installed, the question is not whose runbook is better. It is whether anything independent ever checks the work.
Every other method is free and open source. Why is this not?
The method text is free too, in the sense that it is worth nothing on its own and we do not sell it. What is not free is having somebody other than you check the work, getting a written record that a piece of work really finished, everybody on the team getting the same checks with nothing to set up, and a method that keeps learning: when a project goes wrong in a new way, what caused it and what fixed it both reach your project automatically, so most of those problems never arrive and the ones that do arrive with the answer already attached. A copy you download knows what its author knew on the day they wrote it, and it will never know anything more.
What if I have an existing codebase?
It works, through a bootstrap scan that reads your repository and labels what it inferred rather than pretending to know.
What does it cost me in tokens?
The drafting and grilling run on your seats, so the cost is your normal Claude usage. The two verdicts run on ours.
Install it
npx halfcycle