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. Two or more red 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 the acceptance criteria are between three and eight, 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. That is where the current release stops and hands the keyboard back to you.
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.
Scope, stated plainly
What ships today, and what does not
In this release
Everything up to the point of building: setup, the product spec, the architecture, cutting the work into phases, the detailed design of each feature, and the ordered list of tasks to build it. Both independent checks, the readiness review and the fresh-reviewer consistency check. New projects are the better supported path.
Not in this release, and worth saying so
Three things. Halfcycle running the build itself across a team of agents. The dashboard that shows you where the project is and what each agent is doing. And the checks that run on the code after it is written, rather than on the plan before it. All three are being built now and none of them is included in what you install today.
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, both verdicts, on your own seat.
- Everything in the release above
- 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 those checks getting better every time we watch a build break in a new way. 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. New projects are the better supported path in this release, and we would rather say so.
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