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.

The Enso Method, from idea to shipped phases Deciding what to build runs once per PRD: requirements, review rounds that fix the drafted PRD before you read it, a technical design and a senior review that fixes it, then a refinement loop that finds gaps, researches them and folds the answers in until nothing is left to guess. That leaves the PRD, the design and the assumptions in one folder; the assumptions go to stakeholders without holding up the build. The work is then cut into phases. Each phase is built, reviewed, hardened, committed and tidied by a refactor pass in one session, then the next phase starts in a fresh session, until the last one closes. Then two audits check the whole PRD, once each: the first checks that every acceptance criterion was built and turns anything missing into phases to build, and the second checks that the tests prove each criterion. Decide what to buildONCE PER PRD Idea or a brief Initiative initiative-breakdown too big for one PRD Requirements prd-writing-standards PRD review autonomous-prd-refinement fixed in rounds Design technical-design-writing-standards Design review review-technical-design fixed in place Refinement autonomous-design-refinement find gaps research fold in repeat until nothing is left to guess leaves behind docs/prds/customer-returns/ prd.md technical-design.md assumptions.md Stakeholders confirm or correct later; the build doesn’t wait Build and provePHASE BY PHASE ready to build Phasing phase-split each phase, one session prove Build implement-from-requirements every phase reads them Review deliverable-review auto Harden test-hardening auto Commit pre-commit-validation refactor-pass, then the next phase in a fresh session, until the last one closes · continuation-prompt Close outONCE, AFTER THE LAST PHASE after the last phase Delivery audit delivery-audit gaps become phases to build Test audit test-audit Built and proven every acceptance criterion
Deciding happens once per PRD and leaves everything in one folder. Each phase is then built, reviewed, hardened and committed in its own session. After the last phase, two audits check the whole PRD.

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

  1. Describe it

    prd-writing-standards

    Talk 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.md

    Raw material, like long meeting transcripts or a prior attempt’s documents, goes through requirements-intake first, which records what the stakeholders decided in their own words. An idea too big for one PRD is an initiative. It goes through initiative-breakdown first, which cuts it into PRDs that each end in something that ships.

  2. Review it in rounds

    autonomous-prd-refinement

    Before 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-review round. To get a business owner’s answers before the design, run stakeholder-review-package here.

  3. Design it

    technical-design-writing-standards

    The 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

  4. Review the design

    review-technical-design Runs automatically

    A 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.

  5. Refine it

    autonomous-design-refinement

    The 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.md

    A 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

  1. Plan the phases

    phase-split

    Sizes 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-…

  2. Build the phase

    implement-from-requirements

    Loads 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.

  3. Review it

    deliverable-review Runs automatically

    A 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.

  4. Harden the tests

    test-hardening Runs automatically

    Every 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.

  5. Commit it

    pre-commit-validation

    Marks 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.

  6. Tidy it

    refactor-pass Runs automatically

    Judges 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.

  7. Hand off the next phase

    continuation-prompt

    Writes 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

  1. Check it was all built

    delivery-audit

    A 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.

  2. Prove every criterion

    test-audit

    Grades 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.md

    It 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.

  1. 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.

  2. 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-check to see every open question and its proposed answer before anything is built.

  3. 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 through assumptions-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 →

  4. 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.

  5. 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

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

Restart Claude Code after a manual update to load the latest 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.