How it works
Decide once. Build and prove every phase.
One piece of work, from an idea to tested software in production. Every step is a skill your agent runs, and each one writes down what it decided, so the next step, and the next session, starts from the documents instead of a chat history.
Swipe the diagram sideways to see all of it.
One piece of work, start to finish.
Follow a customer returns feature through the method. Steps 1 to 5 happen once for the PRD, steps 6 to 12 repeat for every phase, and steps 13 and 14 close out the PRD after the last one.
Decide what to build
Once per PRD
-
Describe it
prd-writing-standardsTalk the work through in your own words; the messy version is better than a tidy instruction. The agent writes a PRD in business language: why the work matters, what it must do as testable acceptance criteria, and what is out of scope. It’s the document your stakeholders read.
Writes
customer-returns-prd.mdRaw material, like long meeting transcripts or a prior attempt’s documents, goes through
requirements-intakefirst, which records what the stakeholders decided in their own words. An idea too big for one PRD is an initiative. It goes throughinitiative-breakdownfirst, which cuts it into PRDs that each end in something that ships. -
Review it in rounds
autonomous-prd-refinementBefore you read the PRD, a fresh-eyes agent reviews it, with its assumptions and mockups, against the material it was written from, and another fixes every finding. Rounds repeat until a full review finds nothing that would change what gets built. Later rounds check only what the last fixes touched, and facts checked against the real systems are checked once, so a long run stays affordable.
Your review then goes on the product decisions, not on contradictions and stale copies. A small PRD needs only one
deliverable-reviewround. To get a business owner’s answers before the design, runstakeholder-review-packagehere. -
Design it
technical-design-writing-standardsThe agent reads the code and writes the technical design: architecture, interfaces, data models and integration points, held to your team’s engineering standards. On an existing system it describes only the difference: what is kept, reused or switched off, and which behavior must not change.
Writes
technical-design.md -
Review the design
review-technical-designRuns automaticallyA fresh agent sketches its own design first, then checks the draft against the real code, the infrastructure and your team’s standards. It fixes every gap and error it finds. It replaces a working choice only for a defect it can prove, never for taste, so running it again doesn’t change the design back.
Your read of the design is best spent here, while it is still short. The review lists the sections worth it, starting with every choice it replaced and every decision that is hard to undo.
-
Refine it
autonomous-design-refinementThe agent asks what it would need to know if it were building this today, then answers each question itself: technical ones against the real code, data and APIs, business ones with the best evidence it can find. Each answer goes into the PRD and design as soon as it’s known, and the loop repeats until nothing is left to guess. It saves its progress as it goes, so an interrupted run picks up where it stopped. Once ready, it prepares a stakeholder review package for you to share.
Writes
assumptions.mdA business question it can’t settle at 95% confidence becomes an assumption: a proposed answer with its evidence and confidence, for stakeholders to confirm or correct. How assumptions work
Build and prove each phase
Plan once, then one session per phase
-
Plan the phases
phase-splitSizes the work before building and splits it into shippable phases when needed, each small enough for one AI session to finish reliably. Work that fits one session stays whole.
Writes
phase-1-return-intake.md, phase-2-… -
Build the phase
implement-from-requirementsLoads the PRD, the design, the assumptions and the phase document, then builds the phase and tests it against real resources wherever they exist. If the phase turns out bigger than planned, it splits again, 2 into 2a and 2b, without stopping to ask.
-
Review it
deliverable-reviewRuns automaticallyA separate agent with fresh eyes re-reads every changed file from disk and traces each requirement to what was built. A shortfall is fixed in the code; the review never trims a requirement to match it.
-
Harden the tests
test-hardeningRuns automaticallyEvery acceptance criterion in the phase gets a test that would fail if the behavior were wrong. Mocks become real sandbox resources and weak assertions become exact ones. It stays inside the phase’s acceptance criteria, so it can’t grow the scope.
-
Commit it
pre-commit-validationMarks the phase closed, stages only this work’s files, and checks them: no secrets, a diff that matches the work, and nothing another session committed in the meantime. Then it commits.
-
Tidy it
refactor-passRuns automaticallyJudges whether the new code left the structure worse. Usually it didn’t, and it says so in a line; when it did, it restructures with the tests still green, in a commit of its own. Then the work is pushed when it is on a feature branch. A push to develop or main waits for your word.
-
Hand off the next phase
continuation-promptWrites the prompt that starts the next phase in a fresh session: the PRD and phase it serves, the skill to run and the first action. Anything the next session needs to know goes into the phase document first, so nothing depends on what the old chat remembered. After the last phase, the prompt starts the delivery audit instead.
Close out the PRD
Once, after the last phase
-
Check it was all built
delivery-auditA fresh agent reads each acceptance criterion from the PRD and traces it through the code, to confirm every part exists and that a user or the calling system can actually reach it. It writes no code. Anything missing becomes a phase at the end of the plan, marked as added by the audit, and is built like any other.
Each phase was reviewed on its own. This is the first check across the whole PRD, where a part that fell between two phases, or that a later phase broke, shows up.
-
Prove every criterion
test-auditGrades how well the tests prove each acceptance criterion, taking the criteria from the PRD rather than from the agent that wrote the code, and breaks the code on purpose to see which tests notice. Then it fills the gaps, missing tests first, until every criterion is proven. Anything it finds unbuilt becomes a phase too.
Writes
test-audit.mdIt can also check a single finished phase when you ask.
Where you come in.
The agent does the research and the building. Your part is the decisions only you can make, and none of them requires sitting in the chat while it works.
-
At the start
Describe the work
The PRD conversation is where your judgment goes in. Say what you want and why; the agent turns it into acceptance criteria you can check.
-
Before the build
Read the documents
The PRD is written for people, not agents, and review rounds have already fixed its defects, so your reading goes on the decisions. The design review lists the few design sections worth your time. Run
implementation-readiness-checkto see every open question and its proposed answer before anything is built. -
Any time
Answer the assumptions
Stakeholders can review key requirements, every open assumption and mockups together in an HTML package from
stakeholder-review-package. Their downloaded answers, including changes to requirements and mockups, return throughassumptions-document-feedback. Corrections amend the PRD; once the build has started, new requests go to a follow-on PRD, so the build finishes on the scope it started with. See what they receive → -
After each phase
Review the commit
Each phase ends tested, reviewed and committed. A push to develop or main waits for your word, so you can read the diff first. Anything the session noticed along the way was fixed, dismissed, or written down where the next session will find it.
-
When the last phase closes
Close out the PRD
The last build hands you the prompt for the delivery audit, and each step after it hands you the next. Gaps come back as marked phases to build like the others. When the test audit finishes, the PRD is built and proven.
The rest of the kit.
The main line above runs on sixteen skills. These eleven do the rest. Skills load by name and description, so most of them start on their own when the agent needs them.
Checks and research
implementation-readiness-check- One pass over the PRD and design that lists every open question, with a proposed answer, a confidence level and the impact if it’s wrong, for you to review.
investigate-question- Takes one question to an answer by reading the code, querying the data and calling the APIs, and reports how confident it is.
Stakeholder reviews
assumptions-document-writing- How a business assumption is written: a specific answer in plain English, its evidence, its confidence, and a place to confirm or correct it.
assumptions-document-feedback- Folds stakeholders’ confirmations, corrections and partial answers back into the documents and the phase plan, sends new requests that arrive mid-build to a follow-on PRD, and keeps the work moving.
stakeholder-review-package- Packages key requirements, every open assumption and contextual mockups into one HTML review, with feedback to download. See an example →
Off the main line
using-the-enso-method- The map: reads where a piece of work stands in the repo and says which skill runs next. Ask it “where do I start?” or “what’s next?”
implement-from-discovery- Builds a fix found mid-work or raised in a bug report, after checking it against the PRD and design of the part it changes.
build-preflight- Run it just before a long build, while you’re still there. It checks that every sign-in the plan needs works and will last the run, and that the tests pass on this machine, then names each place the build will stop. It changes nothing.
Always on
implementation-lifecycle- The rules every build session runs under: decide and keep going instead of asking, the confidence thresholds, and no loose ends at the close.
engineering-principles- No silent fallbacks, every acceptance criterion proved by a test that would catch it breaking, no forcing a failing test green, and how your own engineering standards plug in.
wall-clock-awareness- Cuts the time spent waiting on tests, builds and CI, without weakening what they prove.
Try it on your next piece of work.
Install the skills for your agent, then run /prd-writing-standards and describe what you want.
claude plugin marketplace add EnsoDynamics/enso-method
claude plugin install enso-method@enso-method
codex plugin marketplace add EnsoDynamics/enso-method
codex plugin add enso-method@enso-method
npx skills add EnsoDynamics/enso-method -g
The Enso Method is continually improved. Update regularly to keep your skills current.
Claude Code auto-update: run /plugin → Marketplaces → enso-method → Enable auto-update.
Already installed? Update manually
claude plugin marketplace update enso-method
claude plugin update enso-method@enso-method
codex plugin marketplace upgrade enso-method
npx skills update -g
Restart Claude Code after a manual update to load the latest skills.
Start a new Codex chat after updating to load the latest skills.
Restart your agent if it does not pick up the updated skills.
Marketplace not found? Run the install commands above.
Previously installed with the skills CLI? Remove those copies before installing the plugin to avoid duplicate skills.