The intent flow

Every intent goes through four gates before its work reaches you for review: brainstorm, design, plan and execute. At each gate your agent does the groundwork and you make the decisions. Nothing moves to the next gate until you agree.

When execute finishes, the intent is in_review. You review the branch, merge it, and close the intent as done.

How your agent asks

The gates share one way of talking to you:

• One question at a time. Your agent never hands you a questionnaire.
• A recommendation with every question. When the options can be listed, it offers them as a multiple choice, leads with the one it recommends and says why, and always leaves room for "something else".
• Only questions that matter. Before asking, your agent checks the code, the docs and the intent itself. It does not ask what it can find out, or what would not change the result.
• Your questions first. If you ask something, your agent answers it before asking its own.
• Decisions are logged as they land. Each decision goes on the intent's work log with its reason the moment you agree on it, so an interrupted session loses nothing.

Your agent also never jumps to the next gate by itself. At the end of each gate it asks whether you want to review more or move on.

Brainstorm

The first gate turns an idea into an outcome you agree with. The intent is new.

Your agent acts as a thinking partner, not a form. It first checks whether the idea is already built or half built, and whether another intent covers it. Then it asks what should change, for whom, and what success looks like.

You decide: the outcome list. Your agent proposes one to seven lines, and you accept, comment or rewrite until the whole list is right. You also agree what is out of scope and how success will be checked.

Ideas about how to build it or in what order come up along the way. Your agent does not block on them: it files them as notes for the design and plan gates, marked as yours, and steers back to the outcome.

❯ Let's brainstorm self-serve sign-up.

Your agent: Here is the outcome list I propose:

1. Self-serve sign-up — A new user can create an
   account and reach the dashboard without talking
   to sales. [user]
2. No lost sign-ups — A user who closes the browser
   mid sign-up can finish later from the email link.
   [user]

Out of scope: paid plans, SSO.
Success check: a new user signs up alone in under
5 minutes.

Accept, or tell me what to change.

❯ Accept.

Your agent: Written to IN-s1gn4p, now in design.
Review the outcome again, or start designing?

Design

The second gate turns the agreed outcome into a solution. The intent is design.

Your agent reads the outcome, your notes from the brainstorm and the code it will change. It ties every question to an outcome line, so you always know which promise a decision shapes. It then proposes two or three approaches with their trade-offs and recommends one.

You decide: the approach, and the questions that shape it: technical choices, the user experience when there is a screen, edge cases. Your agent presents the design section by section and asks whether each looks right.

The approved design names the files and parts of the code it touches, the decisions you took and why, the options you rejected and why, and how the result will be tested. Rejected options stay on record, so nobody brings them back later without knowing they were already weighed.

❯ Design the sign-up intent.

Your agent: For outcome 2 (no lost sign-ups): how
should a user get back to a half-finished sign-up?

  a) A magic link in the confirmation email
     (recommended: no password to set before the
     account exists)
  b) A saved draft tied to the browser
  c) Something else, tell me

Plan

The third gate turns the design into tasks your agents can build. The intent is plan.

Your agent splits the design into flat tasks, each placed in the area where its code lives, and checks that every part of the design is covered by at least one task. Each task gets its own tests and instructions complete enough that an agent with no prior context can pick it up. One more task tests the whole intent against its outcome list, and a last one updates the documentation once everything is green.

You decide: whether the plan is right: the tasks, their order and dependencies, and what each one tests. Your agent creates nothing before you approve. After approval it creates the tasks, shows you what landed, and moves the intent to build.

❯ Plan it.

Your agent: 5 tasks across 2 areas:

  TS-a1  Sign-up form and account creation   web-app
  TS-b2  Magic link for unfinished sign-ups  web-app
  TS-c3  Welcome email template               mailer
  TS-d4  Intent test: both outcomes, end to end
  TS-e5  Update the docs once all tests pass

TS-b2 depends on TS-a1, TS-d4 on the first three.
Create them and start building?

Execute

The fourth gate builds the plan. The intent is build.

Your agent works through the tasks, in parallel where they do not depend on each other. Before touching anything it runs the existing tests to record a baseline, so any new failure is caught as one the build caused. Each task is built, tested and committed to a branch for the intent. When all tasks are done, it runs the intent test, runs the full test suite again against the baseline, and fixes whatever broke.

You decide: nothing during the build, unless something threatens the intent itself. Your agent makes the small calls within the design and logs them. A task that gets stuck is marked blocked with the reason while the rest continues. It stops to ask you only when the design turns out to be wrong or the intent test cannot pass.

❯ Execute the sign-up intent.

Your agent: Baseline recorded: 412 tests, all green.
Building on branch intent/s1gn4p-self-serve-signup.

...

All 5 tasks in review. Intent test green,
full suite green against the baseline.
Outcome 1: delivered. Outcome 2: delivered.
IN-s1gn4p is ready for your review.

Review and merge

When the build ends, the intent is in_review. Your agent reports what shipped, what it decided on the way, what is blocked and why, and how the tests compare with the baseline. It checks each outcome line against what was built.

Merging stays with you. Your agent never merges the branch and never closes the intent itself. You review the branch, merge it when you are satisfied, and tell your agent to close the intent as done.

❯ Merged. Close the sign-up intent.

Your agent: IN-s1gn4p is done.

Next

• Intents: the outcome list and the intent statuses.
• How agents work: tasks, the work log and documents.