how we work · the cycle

The Cycle

Every initiative passes through these six phases. Some are linear and per-cycle; some are persistent. Together they are how the chain works.

The corpus's spine. Six phases that name what each act of building is for. Read end to end to internalise the chain; read by phase to find what you need today.

✦ Why We Build

The bet. Vision becomes goals, goals become initiatives, value declared, the portfolio curated, the financial chain held honest.

The bet sits above any single cycle. Why We Build holds the artefacts that make every later cycle answerable to something — vision, goals, initiatives, value, the portfolio, and the relationship.

◐ Before We Build

Witnessing. Going to see — not asking, not assuming. The brief that names a person, a moment, and a prediction.

Discovery is observation, not interview. The brief is the artefact that holds the prediction. Without it, the rest of the chain is hope.

◑ What We Shape

The decision. Epics for activities, stories for moments, ADRs for the constrained technical choices, the smallest end-to-end slice that changes the situation.

Scope is the act of declaring, in writing, what changes in the world this cycle and what does not. A scope without a "not" statement is not a scope; it is a backlog.

● As We Build

The making. Domain language survives the trip from brief to code. The pipeline catches a different chain level at each stage. The release gate is a state, not a meeting.

Execution is where most teams operate by default. The corpus's discipline here is not to invent more tooling but to keep the machinery aligned with the chain.

◔ After We Build

The answer. The forty-seven minutes Gal spent grading either fell to ten or they didn't. The model updates or the cycle ran blind.

After every cycle, the team faces the only question that matters: was this actually the thing we thought we were building? After We Build is what the team does in the period when reality is answering.

◕ Did We Serve?

The continuous question. The relationship between cycles. Did the work meet the people we built it for, and did the team building it stay alive while doing so?

Did We Serve is not a phase that opens and closes — it is the continuous backdrop. Support runs without break. SLAs are honoured. The team grows or doesn't. The portfolio is curated or accumulates. Cadence either holds or decays.

---

How the cycle is structured

Four phases run per cycle, in sequence:

Before We Build  →  What We Shape  →  As We Build  →  After We Build
   (witness)        (scope)            (make)         (reflect)

Two phases are persistent — they hold across cycles, both above and below:

Why We Build      ← the bet that funds the cycles
Did We Serve?     ← the continuous service the cycles produce

The cycle closes — and reopens — at the model update. Reflection in After We Build feeds the next cycle's Before We Build. Service in Did We Serve either confirms the bet in Why We Build or surfaces the case for changing it.

How to read

• Sequentially — phase by phase, opening through last part. Internalise the chain.
• By topic — pick a part by name from the sidebar. Read just that.
• By role — start at Roles and follow the curated route.
• By question — search (top-right). Local index, no external service.
• As an agent — fetch /llms-canon.txt for the canon alone.