Insights
Engineering Strategy Nov 2026

The Shape of an Engineering Team in 2026: Fewer People, More Ownership

The question clients ask us most is how many engineers they need now. It's the wrong question. Headcount went down, but what each engineer owns went up - and the constraints that now limit a team aren't the ones org charts were designed around.

The Problem

The question we get most often from clients planning next year is some version of "how many engineers do we need now?". Usually there's a number attached from a board deck or a vendor pitch - half the team, a third of the team, one engineer doing the work of five.

We understand why it gets asked. Agentic coding tools really have changed how much one engineer can produce and we've written about what that did to our own workflow. But headcount is a lagging, blunt measure. The more useful question is what each person on the team now owns and what limits the team once typing code is no longer the bottleneck.

Earlier this year we argued that small senior teams have a structural advantage over large delivery organisations. This post is about the inside of those teams: how they're shaped, what the roles look like and where the model breaks.

What Got Cheaper and What Didn't

Most of the confusion comes from treating "engineering effort" as one thing. It isn't. Some parts of the work collapsed in cost. Others didn't move and a few got more expensive because there's now more output to deal with.

  got much cheaper          roughly unchanged          got more expensive
  ─────────────────         ─────────────────          ──────────────────
  first-draft code          understanding the problem  review per engineer
  boilerplate / glue        data modelling             keeping context fresh
  test scaffolding          architecture decisions     on-call surface
  unfamiliar-stack tax      talking to users           coordination of
  docs first drafts         production debugging         parallel agent work

A team designed for the old cost structure has lots of people doing the left-hand column and a few senior people handling the middle. A team designed for the new one has fewer people and spends almost all of its human time in the middle and right-hand columns.

The Unit of Ownership Changed

The biggest structural shift we've seen isn't the number of people. It's what one person is responsible for.

Teams used to be organised by layer: frontend engineers, backend engineers, a QA function, someone who did infrastructure. A feature moved across those people and each handoff was a place where context got lost and a queue formed.

When one engineer with an agent can work across all of those layers, the handoffs become the most expensive part of the process. So the unit of ownership moves from a component to an outcome. One engineer owns "invoices can be disputed" from the database migration to the UI to the alert that fires when disputes start failing - including being the person who gets paged.

That's a bigger job and it's the reason headcount can drop without quality dropping. Fewer handoffs means less lost context, fewer meetings and fewer bugs that live in the gap between two people's assumptions.

The New Constraints

Once code output stops being the limit, three other constraints show up. They're the ones we now plan teams around.

Review capacity. Every line an agent writes still needs a human to accept it. In our experience the ceiling on a team's throughput is now how much code its senior engineers can review with real attention. AI-assisted review helps with the mechanical layer and writing specs before the build moves a lot of the review earlier, where it's cheaper. But the limit is real and a team that ignores it ships faster for a quarter and then spends the next one fixing things.

Context. An engineer can only own as much as they can hold in their head well enough to make good decisions. Agents make it easy to work in a codebase you don't understand. They don't make it safe. We've found that one engineer owning two or three meaningful product areas is about the limit before decisions start getting worse.

Operational surface. More features per engineer means more things each engineer is on call for. If you halve the team and keep the product the same size, everyone's pager doubles. This is the constraint that most often gets left out of the headcount maths.

What Our Teams Look Like Now

For a typical engagement, the unit that works best for us is small:

  • One technical lead who owns architecture, reviews the most consequential changes and holds the overall picture. Spends more time reviewing and talking to people than writing code.
  • One to three engineers who each own outcomes end to end, including production. Each works with agents for most of their implementation work.
  • A named domain contact on the client side who is available for questions within the day, not the sprint. This role has become more important, not less, because the speed of building means unanswered questions block work faster.

For larger programmes we run several of these units side by side with a thin shared platform layer, rather than growing one team.

Roles That Shrank and Roles That Grew

Shrank: separate frontend and backend roles, manual QA as a distinct stage and the coordination roles whose main job was managing handoffs between specialists.

Grew: people who write evaluations and test strategy (QA didn't disappear - it moved towards evals and observability), platform and developer-experience work that makes agent-heavy workflows safe and anyone whose job is talking to users and turning what they say into precise requirements.

The forward deployed engineer is in some ways the extreme version of this: one person owning the whole path from a messy client problem to a running system.

Where Fewer People Breaks

We'd be overselling if we didn't list the failure modes, because we've hit all of them.

Bus factor. If one engineer owns an outcome end to end, they're also the only one who understands it. A two-week holiday can stall a product area. We deal with this by pairing ownership - a primary and a secondary for every area, with the secondary reviewing every change.

The senior bottleneck. If review capacity is the constraint and only seniors can review well, seniors become the queue. The fix isn't more seniors, which you can't hire fast anyway. It's investing in growing the people who'll become them.

Hidden coordination. Small teams coordinate informally, which works until it doesn't. Somewhere around five or six people working in the same codebase with agents, informal stops being enough and you need written decisions and clear ownership boundaries again.

Burnout. Owning more is more interesting and also more tiring. A team that's half the size doing the same work, on call for twice as much, isn't efficient. It's borrowing against next year.

Takeaway

The right shape for an engineering team in 2026 isn't the old team with fewer people. It's a different team: organised around outcomes rather than layers, sized by review capacity and operational surface rather than code output and built with deliberate cover for the single points of failure that small teams create.

If you start planning with a headcount number, you'll end up cutting the people who held the context. Start with what needs to be owned, who can review it properly and who gets paged at 2am. The headcount follows from that.