How many meetings does a scaled engineering org actually need?

Four deliberate pauses, and continuous flow between them. Cadence runs Signal Inspection (signals become product briefs), Scaled Planning (briefs become committed pod work), Flow (the default building state, not a meeting), and Scaled Review & Retro (shipped work becomes fresh signals, process gaps become process changes). Everything else the calendar usually holds is absorbed by agents, artifacts, and the pods' own rhythm.

What happens when priorities change mid-cycle?

Someone throws the red button. Align and Enable watch signals continuously and don't wait for the next event: Align routes a pivot through written direction and updated priorities, Enable routes standards changes through communities of practice, and either way the shift lands at the next pod-level event. The system never gets stuck on its own calendar.

What's the difference between the review and the retro?

Direction of gaze. The review looks outward — each pod showcases what shipped, user feedback surfaces alongside it, and the result is fresh product signals for the next Signal Inspection. The retro looks inward — pods name their own process gaps so they become deliberate process changes instead of habits the next pod has to rediscover. Skip the first and inspection runs on stale data; skip the second and the process can't learn.

Sigao: Ship faster, and keep the speed.

Four moments where the lanes reconnect.

Pods operate in continuous flow. The four scaled events are the deliberate pauses. Signals get inspected, briefs get scoped, work gets reviewed, and the process examines itself. They form a loop, not a sequence with a clear start.

Each event is where a specific kind of decision gets made and a specific kind of artifact gets produced. Between events, pods stay in flow while Align and Enable monitor signals. The next section, on the red button, covers the pivot mechanism that doesn’t wait for an event.

Nº 01

Signal Inspection

Metrics, insights, alignment, and prior-cycle retros get inspected together, with humans and AI at the same table. Output: product briefs that move the org along Align's stated goals.

Cadence

Continuous, with intentional pauses

Nº 02

Scaled Planning

Value-stream-aligned PO teams take the briefs through validation, mockups, and a broad spec. Pods then review incoming work, untangle dependencies, and pull commitments into their active backlog.

Cadence

Triggered when briefs are ready

Nº 03

Flow

Pods turn specs into plan + implementation in tight loops. Frequent feedback from real users and AI is what makes the loop work.

Cadence

The default state

Nº 04

Scaled Review & Retro

Review generates product signals back into the next Inspection. Retro names process gaps that become process changes.

Cadence

At the close of every cycle

Event Nº 01

Signal Inspection.

Signal Inspection is the entry point of the loop. It runs continuously in the background, since Align and Enable are always watching. Periodically the org takes an intentional pause and inspects the picture together.

What gets inspected

Key product and business metrics. Are the numbers Align cares about moving in the right direction?
Customer insights. What are users actually saying and doing? What’s coming back through productops, market research, and direct feedback?
Strategic alignment. Has the goal shifted? Is current work still pointed at the right target?
Prior-cycle retros. What did pods name as process gaps last cycle? Which of those have become process changes? Which haven’t?

Who’s in the room

Humans and AI at the same table. AI agents pre-process the signals, clustering them, summarizing, and surfacing anomalies, so the humans spend their time interpreting and deciding rather than reconstructing the picture from scratch.

What comes out

The output is product briefs. Each brief states a direction: what the org should pursue next, why, and what good looks like, anchored in the signals that justified it. Briefs feed straight into Scaled Planning.

Event Nº 02

Scaled Planning.

Scaled Planning takes briefs and turns them into committed work across pods. The goal isn’t a fully detailed spec. It’s enough shared understanding for pods to take it from there.

The work the PO teams do first

Value-stream-aligned PO teams pick up the briefs and run them through validation:

UX design thinking. Is the problem the brief frames the right problem to solve? What does it look like from the user’s side?
Value validation. Is the value real, and can it be measured? If we ship this, how will we know it worked?
Mockups + architecture. UX and architecture work alongside the POs to shape the broad spec: enough fidelity that pods can plan, not so much that pods can’t decide.

The work the pods do next

With a broad spec in hand, pods come into the planning event to:

Review incoming work. What’s being asked of this pod? Does the spec still match the pod’s read of the codebase and the user?
Untangle dependencies. If this work depends on another pod, surface it now — not three weeks in.
Pull commitments into the active backlog. Pods commit to what they’ll deliver this cycle and start the clock.

Event Nº 03

Flow.

Flow isn’t an “event” in the meeting sense. It’s the default state. We list it among the four events on purpose: most of the system’s time is spent here, building, not in scheduling meetings.

What pods do

Pods pull from their prioritized backlog, take a spec, turn it into a plan, and turn the plan into an implementation. The plan-to-implementation step happens fast on purpose. A short loop means feedback comes back early.

Why the loop is fast

Every iteration that ships gets feedback from real users and from AI evaluation. That feedback tells the pod whether the plan is correct. The longer the gap between iteration and feedback, the longer a wrong plan goes uncaught, and the more rework piles up.

Short loops pay off because every spec is written for both the human team and the AI agents. Shipping early closes the gap between what you meant and what the code actually does.

Event Nº 04

Scaled Review & Retro.

The closing event of every cycle has two halves. One looks outward at what shipped, the other inward at how the pod works. They feed different parts of the system on the next pass.

Half · 01

Review · the outward half

Each pod showcases the work it shipped this cycle, and user feedback gets surfaced alongside it. Out of that comes a fresh batch of product signals, the input to the next Signal Inspection.

Half · 02

Retro · the inward half

Pods name the deficiencies in their own process and the opportunities they spotted to improve. Those learnings get passed into Inspection so they can become deliberate process changes rather than informal habits the next pod has to rediscover.

The two halves are why the loop closes properly. Without Review, Inspection runs on stale data. Without Retro, the process can’t learn.

The red button.

Both Align and Enable continuously review the signals coming through the system, and they don’t wait for the next event to react. When something needs to shift, either lane can throw the red button and direct a pivot.

The principle

The system doesn’t wait for the calendar.

Events give structure to deliberate decisions. The red button lets Align and Enable redirect when signals demand it: between events, mid-cycle, with immediate effect on the next pod-level event.

How each lane uses it

Align

Routes pivots through traditional comms.

Leadership announcements, written direction, updated priorities. Pods see the change at their next planning or standup: direction has shifted, here’s the new priority.

Enable

Routes pivots through communities of practice.

The AI CoP, internal guilds, working groups. A change in standards, a deprecated pattern, a new evaluation requirement: the change spreads peer-to-peer rather than top-down.

Either way, the message lands in the next pod-level event and the work shifts. The red button is what stops the system from getting stuck on its own calendar.

Common questions

How many meetings does a scaled engineering org actually need?: Four deliberate pauses, and continuous flow between them. Cadence runs Signal Inspection (signals become product briefs), Scaled Planning (briefs become committed pod work), Flow (the default building state, not a meeting), and Scaled Review & Retro (shipped work becomes fresh signals, process gaps become process changes). Everything else the calendar usually holds is absorbed by agents, artifacts, and the pods' own rhythm.
What happens when priorities change mid-cycle?: Someone throws the red button. Align and Enable watch signals continuously and don't wait for the next event: Align routes a pivot through written direction and updated priorities, Enable routes standards changes through communities of practice, and either way the shift lands at the next pod-level event. The system never gets stuck on its own calendar.
What's the difference between the review and the retro?: Direction of gaze. The review looks outward — each pod showcases what shipped, user feedback surfaces alongside it, and the result is fresh product signals for the next Signal Inspection. The retro looks inward — pods name their own process gaps so they become deliberate process changes instead of habits the next pod has to rediscover. Skip the first and inspection runs on stale data; skip the second and the process can't learn.