This is my continuation post of Broken promise of Agile and Agile Manifesto In Age Of Ai Agentic Software development world
What happens to sprint planning, standups, retros, and bug reports when the team building your software isn't human.
Jeff Bezos had a simple heuristic for team size: if two pizzas can't feed the team, the team is too big. It was never really about pizza. It was about communication overhead — the invisible tax that grows quadratically as you add people. Small teams move fast because coordination is cheap.
Now imagine replacing those six engineers with six AI agents. No standups. No slack threads at midnight. No pushback during planning. They just run week day / weekend / 24*7 .
Sounds like a superpower. It isn't — or rather, it isn't straightforwardly one. The coordination problems don't disappear. They move , they concentrate and they become invisible in ways that human teams never were.
Fundamental Difference
When you manage six engineers, you get a huge amount of coordination intelligence for free.
Btw what is coordination intelligence ?
Coordination intelligence is the ability to self-organize around incomplete information without being told to — noticing collisions, resolving ambiguity, pushing back before work goes wrong. In human teams it emerges for free from social context: reputation, embarrassment, shared history
Engineers notice when two people are working on the same thing. They push back on bad estimates. They carry context from last month's decision. They feel embarrassed when they ship something broken. That embarrassment is load-bearing infrastructure.
Agents have none of this. An agent will accept any scope you give it, work confidently in the wrong direction for hours, produce six internally-consistent but mutually-incompatible outputs — and report back with no signal that anything went wrong.
Six agents don't reduce management overhead. They concentrate it into a single engineer's head.
What Happens to Each Ceremony
Sprint Planning
Planning with engineers is a negotiation. Engineers push back. That pushback is annoying — it's also your earliest warning system. Agents don't negotiate. They accept any scope. Without pushback you'll consistently over-assign, and agents won't tell you — they'll just produce something confidently wrong at scale.
Sprint planning stops being about capacity negotiation. It becomes context package design.
Lets expand Context package
Context package design is the discipline of deciding exactly what an agent needs to know, what it must not know, and where its work begins and ends — so it can complete a task correctly without asking questions, without drifting into adjacent scope, and without conflicting with what other agents are building in parallel.
For each task: what does this agent need to know? What must it explicitly not know? Where does it hand off, and to whom? The role shifts from breaking down stories to writing intelligence mission briefs.
Daily Standup
Standups exist to catch invisible blockers early through human signal — tone, hesitation, the "I'll figure it out" when someone won't. Agents don't have tone. The standup equivalent becomes a health-check dashboard: are agents producing output? Did any contradict each other? Is any stuck in a tool-call loop? Status collection becomes anomaly detection.
Sprint Review
In a normal review, the engineer who built the feature explains its edge cases. Knowledge transfers. Pride is a quality signal. With agents, the output exists but nobody fully understands it. An agent can produce 600 lines of passing code and the engineer who prompted it cannot explain every architectural decision.
| Ceremony | Human purpose | With agents, becomes | |
|---|---|---|---|
| Sprint Planning | Capacity negotiation + pushback | Context package design — precise briefs, explicit scope boundaries | mutates |
| Daily Standup | Catching invisible blockers via tone + signal | Anomaly detection dashboard — traces, diffs, loop detection | mutates |
| Sprint Review | Demo + informal knowledge transfer | Comprehension gate — a human must own and explain the output | intensifies |
| Retrospective | Processing human failures via memory | Prompt autopsy — full trace replay, brief quality analysis | mutates |
| Bug Triage | Assign → investigate → fix with moral ownership | Re-ownership ritual before fix — someone must read the whole module | intensifies |
| Code Review | Peer knowledge transfer + quality gate | Review wall — agents outpace human review capacity almost immediately | breaks |
Human tech debt traces back to a decision. Agent tech debt has no author intent — only output.
Bug Reports
Bug reported → assigned to whom? The agent that wrote the buggy code no longer exists. The bug might live in the interaction between two agents' outputs — nobody's fault in isolation. If you assign the fix to another agent without human comprehension in between, you risk entering a patch spiral.
Code Review
Agents generate PRs faster than a single human can review them. The review wall hits almost immediately. What Options you have ?
New Pattern Emerging
Every Agile ceremony was designed to solve a human coordination problem. When you replace engineers with agents, those problems don't disappear — they move up the stack to the one or two humans managing the agents. Those humans now carry the full cognitive load that was previously distributed across a team of six.
Agile solved for human limits: attention, memory, communication bandwidth. Agents don't have those limits. But they have different ones — context window coherence, statelessness, silent failure, no social accountability. We don't yet have a name for the ceremonies that solve for those.
The teams who figure out the new paradigm first will ship faster — not because they have more agents, but because they've rebuilt the coordination layer from scratch for the law of physics that actually govern them.
No comments:
Post a Comment