The new shape of Teams

In software, the shape of things keeps changing. Over the last decade or so traditional roles like Business Analyst (BA) and Testers (QA) have morphed and been redefined — overlapping and collapsing into broader Developer and Product roles. Tighter iterations/loops and leaner teams resulted, with squads that shrank in size but grew in impact. If you get the right skills and expertise in a supportive culture that understands the nature of Product Development — people who could understand the problem, talk to customers, write code, test it, and ship — it doesn’t take 10-15 of them. It might take five. Or even four.

Now, it’s happening again.

The modern development team is getting smaller still. Three or four people, if they’ve got the right skills and experience, can deliver more than three or four squads could a decade ago.

This isn’t magic. It’s what happens when the lines between roles blur into a kind of productive ambiguity — when people stop asking, “Whose job is this?” and instead dial in the experiments needed to quickly discover what works.

The collapse of specialist roles

The old idea of roles in software — BA, QA, Dev, Architect — assumed sharp boundaries. Handoffs. Coordination layers. Specialisation. But in high-performance teams today, the concept of “role” has been replaced by shape. T-shaped people, yes, but increasingly more like π-shaped or comb-shaped: people with multiple deep spikes, and the curiosity and judgment to move across domains without drama.

Architecture isn’t gone — it’s just no longer the domain of someone with a different email signature. Good teams are full of engineers who can maintain the big picture view, reason about trade-offs, and draw boundaries and interactions in ways that will still make sense months and years down the road.

Same with testing. Same with documentation. The people you need write systems that explain themselves, verify themselves, and are built with an assumption that change will be needed, so make change cheap, fast, safe — and as automated as possible.

It’s all code now

This is more than just a cultural shift. It’s also deeply technical.

We’ve been gradually encoding the entire product development lifecycle. Infra as code. QA as code. Docs and diagrams as code. Monitoring, provisioning, rollout strategies—all codified, versioned, testable, auditable. Repos are no longer just for app logic; they’re the brainstem of the entire product, soup to nuts.

And so, the definition of “full-stack” has quietly expanded under our feet. It’s not just React and Node and a bit of SQL. It’s YAML, Terraform, test automation frameworks, documentation pipelines, observability tooling, and increasingly, the ability to stitch together and extend open source libraries that span from front-end widgets to LLM backends.

And of course, AI is now accelerating all of this…

Agentic AI and the 10x Team

A good agent can now draft your tests, scaffold your infrastructure, generate API stubs, refactor code, write boilerplate docs, and even catch regressions—all in the time it used to take someone to make coffee. This isn’t the old dream of “no-code” automation. This is MORE code, done faster, with greater leverage. The bottleneck has shifted from “how do we get this done” to “what exactly should we be building?”

That’s where judgment comes in. The tools have changed, but the principles haven’t. Fast feedback loops. Continuous delivery. Clear architecture. Small components with tight cohesion and loose coupling. AI doesn’t replace any of this—it just makes the difference between good and bad fundamentals even more obvious.

Which brings us to the real constraint: people.

Good people are the multiplier

Small teams only work if they’re made up of people who can think clearly, care about outcomes, and wield their tools with precision. The delta between an average engineer and a great one hasn’t shrunk — it’s grown. Because the leverage has grown. The floor has been raised by AI, but the ceiling has lifted too. And the great ones are building product systems that are not just faster to ship, but easier to evolve.

This is why hourly-rate thinking is dead. If your procurement mindset is still anchored on “how many hours does this buy me?”, you’ve already lost. Penny pinching over 10-20% differences in cost end up costing you the difference between 0.5x and 10x outcomes. You’re NOT buying hours. You’re buying trajectory. You’re buying momentum. You’re buying the most important strategic capability that exists for most organisations these days.

The shapeshifting future

The future of product development isn’t giant teams with layers of roles. It’s smaller teams with broader shoulders. Builders who see the whole system and can act across it. Who use AI not as a crutch but as a compounder. Who obsess over fast feedback, clean architecture, and clear ownership. DevOps alone isn’t enough. You need ProductDevOps. ProDevOps, if you like, to speed up the hunt for value.

The shape of these teams is changing. But the direction is clear. Smaller, tighter, faster. We’re not scaling up—we’re scaling down, and getting more leverage than ever.

The best product teams are already experimenting with this. The rest will follow, eventually — or be left behind.