Your Scrum Team Isn't Obsolete. It Got Smaller.

In my last article, I walked through how spec-driven development (SDD) and AI coding agents reshape the Scrum ceremonies. But there is a more disruptive question underneath those ceremony shifts: if one developer backed by agents can specify, write, test, and ship a feature in a morning, what happens to the size and shape of the Scrum team itself?

The answer is that the Scrum team is structurally descaling. As stream-aligned units contract from eight people to one to three, the internal coordination tax drops to near zero. However, this topology shift introduces new key-person and review risks that require pairing and hard outcome-steering to resolve. More importantly, team-level contraction is the first turn of a pattern that collapses the coordination needs of Agile Release Trains (ARTs) and Solution Trains, making most of your scaling framework optional.

For decades, the “two-pizza team” (7±2 people) was agile’s golden rule. We needed that size because building software required multiple specialized disciplines — front-end, back-end, database, QA, DevOps — and the coordination tax of handoffs between separate departments was too high. We put them on one cross-functional team to collapse the feedback loops.

But when a single engineer backed by agentic workflows can comfortably span those disciplines, the cross-functional team of eight collapses into a stream-aligned unit of one to three people.

This isn’t just a minor productivity boost; it is a structural descaling. The internal coordination tax of the team drops to near zero, because the alignment meetings, task handoffs, and scheduling friction that used to live inside the team simply have nowhere left to happen. The team becomes a tightly focused execution unit.

This topology shift is not free. It introduces new, acute risks that organizations must design for deliberately:

• Key-Person Risk: When a stream is run by one or two people, losing a single team member creates an immediate coverage gap. The knowledge is concentrated in fewer human brains, even if the AI has the code context.
• The Comprehension Bottleneck: When one person generates a massive volume of code with AI, who verifies the architecture? Who reviews the PRs? If review is treated as a rubber stamp, you build apparent velocity while quietly accumulating toxic technical debt.

To counter these, the discipline of Scrum and Kanban doesn’t dissolve — it shifts. Paired review, architectural guardrails, and collective ownership of the stream’s specifications become first-class engineering constraints, not afterthoughts.

The most important consequence of this team-level contraction is that it doesn’t stop at the team boundary. If one person plus agents can do what a team of seven used to do, then a single team can take on the strategic scope that used to require an Agile Release Train (ART), and an ART can take on the scope of a Solution Train.

The coordination complexity we built heavy scaling frameworks like SAFe, LeSS, or Spotify to manage is suddenly gone. Most of the dependencies we spent hours mapping on program boards were procedural — created by our own need to coordinate multiple large human groups. When the groups shrink, most of those dependencies disappear along with them.

This team-level contraction is the first turn of a descaling fractal that runs all the way up the organization, which leads to the next question: if team-level complexity has collapsed, what happens to the scaling apparatus above it?

In the next piece, we will zoom out to the portfolio: Most Of Your Scaling Apparatus Is Now Optional. Your First Principles Are Not.