跳到正文
DEV Community· dqj·· 1 小時前AI 評分35

兩個時鐘:以 12 週 PI 配合 60 分鐘管線

Two Clocks: A 12-Week PI Around a 60-Minute Pipeline

AI 導讀

文章主張,12 週 PI 與 60 分鐘微型管線並不衝突:PI 負責方向對齊和里程碑,管線則在單一 cell 內產出及驗證有限範圍的改動。微型管線分為合約編譯、平行生成、獨立判定和持久化規則四個階段,讓 PI 不再承擔細緻的執行協調。

正文

Part 2 ended with a unit of delivery that can produce three candidate implementations in an hour. This part is about the organization that plans in quarters — and why the two are not in conflict.


Part 1 diagnosed a specific failure: the individual end generates fast, the organization integrates slowly, and work in progress piles up at the seam. The diagnosis named the seam but did not redesign it. Part 2 rebuilt the unit on one side of that seam — one engineer, three surrounding roles, authority where the judgment sits. This part rebuilds the other side: the clock the organization runs on.

The instinct after reading Parts 1 and 2 is to conclude that the twelve-week PI is the problem. A cell that can synthesize, test, and decide in an hour makes a quarterly planning cycle look like bureaucratic dead weight. That conclusion is tempting and wrong. It confuses two questions that were never the same question, and it would delete the one mechanism that keeps a hundred fast cells pointed in a common direction.

The PI and the sixty-minute pipeline are two clocks. They run at different rates because they answer different questions. The mistake is not having both. The mistake is asking either to do the other's job.

Two questions, two clocks

The outer clock asks: are we building the right thing? It runs on eight-to-twelve-week Program Increments. It is the ART's timebox for portfolio alignment, business milestone validation, and enterprise-level integration. Its unit is a train of many teams moving together.

The inner clock asks: are we building it right, and can we prove it? It runs on a roughly sixty-minute loop inside a single cell. Its unit is one engineer with a platform and a contract.

These are not a slow version and a fast version of the same activity. They are different activities. The outer clock chooses direction and allocates intent. The inner clock produces and verifies a bounded change. A system needs both. An organization that runs only the inner clock gets fast, well-built things that no one wanted. An organization that runs only the outer clock gets the review queue Part 1 described — correct priorities, nothing shipped.

The pathologies of the last decade come from making one clock answer both questions. SAFe put fine-grained task coordination inside the PI, and the PI, built for alignment, buckled under coordination. The cell puts direction-setting inside the sprint, and the sprint, built for execution, buckled under ambition. The two-speed architecture is the admission that a clock is a control mechanism tuned to one timescale, and a control mechanism tuned to two timescales controls neither.

What the twelve-week clock is actually buying

Concede this before touching it: the PI is not ceremony for its own sake. For a large enterprise it is the only mechanism that synchronizes dozens of teams around shared milestones, forces dependencies into the open, and creates a stable cadence that a business can plan against. Its eight-to-twelve weeks are not slowness. They are the granularity at which portfolio decisions are actually reversible — you cannot re-point a hundred teams weekly without producing the churn that "agile at scale" was supposed to eliminate.

The error is asking that clock to manage throughput. The PI was never good at it, and attaching AI to it did not make it better. When a model makes synthesis nearly free, asking a quarterly planning event to coordinate individual implementation steps is like routing each heartbeat through a calendar app. The result is the velocity hallucination: story points inflate locally, the ART board fills with red dependency lines, and nothing crosses the integration gate faster.

Narrow the claim. The PI should keep its eight-to-twelve weeks, its alignment, and its milestones. What it gives up is the fine-grained coordination it was never structured to perform. Once the inner clock absorbs execution, the outer clock can go back to being an alignment instrument — which is what it was good at all along.

The inner clock: four stages in one hour

The micro-pipeline is the replacement for the two-week iteration inside the team. It is not a compressed sprint; a sprint compressed to an hour is still a sprint, with the same ceremonies scaled down to the point of absurdity. It is a different loop with four stages.

Contract compilation. Before synthesis begins, the input and output schema and the irreversible constraints are made explicit. This is where the Supervisor's boundary from Part 2 becomes machine-readable. The contract is not documentation; it is the thing that will be checked. A change that cannot be stated as a contract is not a candidate for the micro-pipeline — it is still a judgment call for the outer clock.

Parallel synthesis. The platform explores several implementation paths and their test suites concurrently. This is the capability that made the bottleneck move in the first place, now pointed at a bounded problem. Where a team once serialized one approach through a sprint, a cell tries three within the hour. The engineer's job is not to write the candidate but to hold the space in which candidates are generated and be ready to decide between them.

Independent judge. A sandbox, deterministic tests, and the engineer's contextual judgment jointly decide whether the change is real. The word that matters is independent: the judge is structurally separate from the generator. Part 2 argued the engineer cannot be left alone with a model that lies fluently. The same logic applies here — if the system that proposes a change also certifies it, you have not built a gate, you have built a rubber stamp.

Durable rules. Every failure and every fix is precipitated into a system-level rule: a test, a schema constraint, an automated check. This is the AI Helper's work made concrete, and it is the stage that compounds. The pipeline is not merely fast; it is ratcheted. The class of error that cost an hour this week becomes impossible next week. Run it for a quarter and the loop does not just repeat — it gets harder to fail.

Sixty minutes is not a productivity target. It is a feedback boundary: the maximum latency between an intent becoming a contract and a verified change existing. Tune it, but do not worship it. A loop that takes ninety minutes and produces a durable rule is worth more than a sixty-minute loop that produces an unreviewable diff.

The red line that breaks PI planning

The most fragile artifact in a traditional PI Planning event is the dependency red line on the ART planning board. It marks a place where one team must wait for another — a handshake across an organizational boundary, scheduled by humans, renegotiated when either side slips. These lines are fragile because they encode waiting as a social agreement, and social agreements are the first thing to fail under load.

ANTcell does not abolish the underlying coupling. Coupling is real; two systems that share a schema must agree. What it changes is the substrate of the agreement. The AI Capability Platform supplies standardized model APIs, agent sandboxes, and a retrieval layer over the organization's own context. Architects push API contracts downward. A dependency that used to be a cross-team meeting becomes a contract check that runs when a change is compiled.

The red lines do not vanish; they become assertions. This is the concrete answer to the coordination problem Part 1 left open. Cross-team waiting is replaced by platform verification, and verification is cheap in a way that human scheduling never is. A contract violation is found in a minute by a system that never sleeps, rather than in a sync meeting two weeks later.

Concede the dependency: this only works with the platform from Part 2 underneath it. Without standardized contracts and a real context layer, you have not degraded waiting into verification — you have merely moved the waiting to a place with no owner. The platform is not an accessory to the two-speed architecture. It is the material the inner clock is cut from.

Why the clocks nest instead of collide

The two clocks are not competing for the same time. They are nested: the sixty-minute loop runs continuously inside the twelve-week envelope, like a heartbeat inside a season.

The seam between them is the contract. The outer clock sets intent, boundaries, and milestones; the inner clock explores within those boundaries and returns verified change. The Supervisor owns the "what" at the outer timescale; the engineer owns the "how" at the inner one. Neither has to attend the other's meetings. The contract carries the intent down, and the verified result carries evidence back up.

This is why the architecture is stable. Each clock is allowed to be good at one thing. The PI does not need to know which of three candidates won an hour; it needs to know that the increment's milestones were met. The cell does not need to attend portfolio sync; it needs a boundary clear enough to compile against. When the interface between them is a schema instead of a status meeting, both clocks run at their natural rate.

Where the fast clock must stop

The claim is narrower than "the PI is obsolete."

The sixty-minute loop is for work that is bounded and contractible. Decisions that are irreversible, cross-organizational, physical, or regulatory still belong to the outer clock — you cannot compile your way out of a compliance review or a hardware recall. The inner clock accelerates execution inside a direction; it does not choose the direction, and a cell that quietly starts choosing direction has become a very fast local optimizer pointed wherever it likes.

Two failure modes follow. Run the inner clock without the outer and you ship well-built irrelevance at speed. Keep the outer clock's ceremonies inside the inner one — the daily standup, the two-week estimation poker Part 1 called out — and you have a sixty-minute pipeline interrupted every fifteen minutes by a meeting designed for a nine-person team. The architecture fails from either side: too little alignment or too much ceremony.

And the outer clock's red lines exist for a reason. Some coupling is genuine, and collapsing it into an assertion only works if the assertion is correct. An organization that writes contracts faster than it understands its own system will automate its misunderstandings at machine speed. The durable-rule stage is what catches this over time — but only if the rules are allowed to accumulate, which means only if the platform and the roles from Part 2 are actually in place.

What this sets up

None of this can be installed by reorganizing the calendar. A two-speed architecture needs a platform mature enough to verify contracts, roles mature enough to hold boundaries without reaching inside them, and engineers mature enough to exercise judgment when the platform hands them three candidates. That sequencing is the subject of Part 4: the four-level path from Ad Hoc to Integrated, and why skipping a level fails in a predictable way rather than a surprising one.

The short version is that the fast clock is the last thing you get, not the first. Organizations that buy the sixty-minute pipeline before they have the contracts to compile are not accelerating. They are generating WIP — which is where this series began.

The takeaway

The twelve-week PI and the sixty-minute pipeline are not a conflict to be resolved. They are a control system with two timescales: one that decides whether the work is worth doing, one that decides whether it was done right. The first belongs to the ART; the second belongs to the cell; the contract between them is the seam that lets each run at its own rate.

Do not ask the PI to manage throughput. Do not ask the cell to choose direction. Replace cross-team waiting with platform verification, precipitate every failure into a rule, and let the outer clock keep the order it was always good at buying.

One slow clock for direction. One fast clock for proof. A contract between them. That is the two-speed architecture — and it works precisely because neither clock is asked to be the other.


Part 3 of 4 in AI-Native, Deconstructed: From SAFe Incrementalism to the ANTcell Rewrite.

來源:DEV Community · dev.to