durable
Vision
Lets a builder say no, sequence their own bets, and prioritise without asking anyone. Reviewed slowly - annually, maybe twice a year.
The model is careful about every interface except one - the portfolio-to-builder loop, the stakeholder handoff, the builder-to-AI spec. What it barely names is the horizontal interface: builder to builder.
01 - The horizontal gap
It works out the portfolio-to-builder loop, the stakeholder handoff, the builder-to-AI spec. It even stops builders from duplicating each other mechanically, deduping at triage. What it barely names is the horizontal interface: builder to builder.
Duplication is solved; coherence of direction and peer-awareness are not. What keeps a dozen sovereign builders, each making fast local calls, from drifting into a dozen locally-sensible but globally-incoherent directions?
The reflex fix is to put everyone in a room every quarter: share roadmaps, align, commit. Increment planning. The reflex objection is correct - that fights the whole model. This is continuous-flow work with WIP limits, not synchronised increments; dependencies resolve by contract-and-proceed. A big-room event reintroduces exactly the batching the model exists to remove, and the faster builders ship, the staler that quarterly snapshot is by the time the room empties.
So make the move the working method already makes with the user story: keep the soul, drop the ceremony. Builders do need to align, and someone must write down the bigger picture - that's the soul. Synchronised batch planning is the ceremony we throw away.
02 - The coordination mechanism
A stable, written direction resolves the speed worry instead of fighting it.
In a model built to drive the communication tax to zero, a stable, written, shared "where we're going" is the coordination mechanism - it coordinates asynchronously, ahead of time, once, instead of synchronously, repeatedly, in a room.
The faster execution runs, the more you need written direction and the less you can afford to re-derive it live every quarter. A builder who has internalised where the company is going makes a hundred locally-good decisions a week that add up globally, with nobody in the room. Alignment at machine speed.
The meeting was a slow, lossy way to transmit what a written vision transmits better - and continuously.
So alignment isn't one ritual. It is three layers, at three altitudes - the same shape the model already uses for who decides what to build.
03 - Layer one · vision
There is one durable, org-level north-star, and leadership owns it. Single ownership is the point: a portfolio stays coherent for the same reason a single product does - one mind holds the conceptual integrity of the whole.
A committee-authored vision fragments along team lines. Conway's law doesn't stop at the org chart.
It lives where everything else lives - queryable, in the single source of truth, not in a slide deck that rots in a drive. The why is load-bearing: it's what every feature carries, what the agents fill gaps from. Put it somewhere a builder and their agents can reference, and direction propagates into the build.
Owning the north-star doesn't mean only leadership writes. Each builder writes the vision for their own product, beneath the umbrella - and each must ladder up to it. That's what makes "everyone writes it" real: everybody authors, each at their own altitude.
A misfit that can't ladder up is never silently absorbed; it surfaces - as a portfolio call, or as pressure on the umbrella.
When a product vision can't be made to ladder up, that's information, and it resolves the way every boundary in the model resolves - evidence moves it. Either the product is genuinely off-strategy (a portfolio call: fund it differently, merge it, kill it) or the umbrella is incomplete and ground evidence should pull it up.
Position it precisely against what already exists:
Vision (durable) → outcomes (the bets) → solutions (the build).
Lets a builder say no, sequence their own bets, and prioritise without asking anyone. Reviewed slowly - annually, maybe twice a year.
"Activation 40% → 55% by Q3," the model's existing layer, on a thin asymmetric cadence. The vision sits above them.
Execution moves fast here. Vision that churns at build speed isn't a vision; the whole value is that it holds still while solutions move underneath it.
04 - Layer two · feed
"Roughly knowing what the others are doing" needs no meeting at all. It's the specialist inversion applied to peer awareness - the trick that turns two hundred stakeholder tickets into clustered signal before a human sees them.
An agent generates a per-builder feed: what shipped across the portfolio, which new shared structures were published (now yours to reuse), which structures you depend on just changed, which override patterns are nearing rule-of-three promotion. Signal, continuous and asynchronous - not a calendar invite.
The feed isn't how duplication gets caught; that's handled mechanically at intake. Builders duplicate when it's locally cheaper than reuse, and the platform's job is to make reuse cheaper - the feed doesn't police that.
The feed is the soft, human-facing half of awareness - taste, reuse, and what's going on - not the dedup police.
05 - Layer three · guild
Some of alignment genuinely needs humans in a room - the un-encodable edge that doesn't reduce to a query or a rule. So keep a thin, roughly monthly builder guild: horizontal, peer-to-peer, distinct from the vertical portfolio cadence. Its job isn't to plan or allocate work - the vision, feed, and registry already do that. Its job is the rest:
Promote recurring overrides into shared rules - the rule-of-three decision, made deliberately, together.
Cross-pollinate taste - the hard-won lessons that don't fit in a feed item.
Pressure-test the vision against ground reality, and push evidence back up.
Each builder takes sixty seconds on "what I'm going for next." The feed is backward- and now-looking - what shipped, what changed - never what's coming. The forward look surfaces adjacency early: "you're about to build something next to me." That discovery resolves afterward - a contract, a dependency edge, a quick conversation - never as in-room batch commitment. The forward awareness increment planning was reaching for, without the synchronised plan.
Keep the rhythm thin, or the cadence itself becomes the bureaucracy tax it was meant to prevent.
Carry that guardrail straight over from the outcome cadence. Watch for the guild that grows agenda items; watch for the builder who becomes pure meetings.
06 - At a glance
Each layer sits at a different altitude and runs at a different cadence. Read alongside the outcome cadence the model already has, the picture is complete: direction is written and slow, awareness is ambient and continuous, the only live ritual is thin.
| Layer | Altitude | Who authors | Cadence |
|---|---|---|---|
| Vision | org + per-product | leadership (umbrella) + each builder (product) | slow - annual / semi-annual |
| Feed | peer awareness | an agent (auto) | continuous, async |
| Guild | peer craft + forward look | all builders | thin - ~monthly |
| Outcomes (already in the model) | portfolio ↔ builder | leadership; builder stress-tests | thin checkpoint |
07 - Not increment planning
Read "monthly guild plus forward look" as PI planning with the serial numbers filed off, and you'd be wrong - and the difference is the whole point.
Increment planning exists to synchronise commitment: batch everyone's roadmaps into one window, resolve dependencies in the room, leave with a locked plan. This model resolves dependencies continuously and never locks a synchronised plan - at this speed the plan is stale before it's signed. So the planning content has no job here.
What survives is the part that was never about planning: a shared written direction, ambient awareness, a thin human forum for taste and emerging tensions.
We kept the soul - a bigger picture someone writes, and builders who meet now and then - and dropped the ceremony - the synchronised batch plan.
The vision carries the alignment the room used to carry, the feed carries the awareness, the guild carries only the part that genuinely needs faces. None of it slows the build, because the only thing that holds still is direction - exactly the thing you want to hold still.