Over the last year I’ve watched two kinds of teams adopt AI agents:
-
Those moving faster: Engineers land many small improvements, get them reviewed quickly, and deploy them to production shortly after.
-
Those that stay the same: The team has the same AI tools, but from the outside it looks like they are going at the same speed they always have. They also claim they are too busy to pick up new work, and quick wins often go to die on their backlog 💀.
The team moving faster likely has leverage: a few pieces of work that make everything they do afterwards cheaper. The team staying the same doesn’t, so the extra output from the agents has nowhere useful to go.
Will Larson described it in 2018 in Staying on the path to high performing teams, where some teams compound while others tread water or fall behind. Agents haven’t changed that. They’ve just made the gap grow faster, which makes the difference between teams easier to see from afar.
Taking Dev#
Say product wants to see a small tweak to a customer flow before a marketing announcement. On a team with one shared dev environment, the engineer posts “taking dev” in Slack and deploys their branch. A teammate who also needs to show product a change now has to wait, which delays the demo and any feedback from product. The team is tripping over itself because of a gap in its foundations.
AI agents make this worse. An agent can write the tweak in minutes, but that change still has to wait behind everyone else’s. More output just means more contention for the development environment.
With PR environments, every pull request gets its own copy of the app, running on seeded fake data or safely connected to the rest of staging, and any number of copies can run side by side. An engineer opens a PR, drops the preview link in the product channel, and spends their time on the tweak itself. Every change the agents write gets its own environment too, so the extra output can be shipped and validated faster.
What a shared dev team lacks is a primitive. Primitives package up hard decisions and engineering effort, and every solution built on top of one gets those decisions for free. PR environments, feature flagging and safely testing in staging or production are all examples.
You don’t see the leverage from a single ticket. Nobody spends weeks building PR environments to demo one customer flow tweak. But every future ask makes the team pay for the gap over and over again. It only becomes obvious once you see the pattern across many asks (more on spotting that below).
The problem is that work with the most leverage doens’t look like normal work. Someone has to write a proposal and get it prioritised over feature work. They have to align with the infrastructure team on where the environments run and who pays for the extra compute. They should ask other teams whether anyone has already solved this. None of it can be demoed to a customer. So it goes unaddressed, and the team keeps on tripping over itself in the shared dev environment.
Same Decisions, Made Four Times#
Sometimes teams do build a primitive, just not together.
A team mentions they’re building a dashboard to see deployment status across environments. You’ve heard similar things from other teams: cloud costs, DORA metrics, PRs waiting on review.
Each team can build its dashboard quickly, but first has to work out its own CI, deployment pipeline, infrastructure, authentication and secrets to access the data sources. It all works for the team, but none of it adds up, and the next team starts from zero again.
Platform engineers have a view across teams, so they can notice when several teams are filling the same gap. The highest-value thing a platform team can do when they spot this is to build the primitive once, for all of them.
An internal developer portal is a common choice here. Built on something like Backstage, it lets the platform team make the hard decisions once, for everyone:
- Deployment, CI and auth: one place to run it, one pipeline, and SSO already in front of it.
- Data gathering: the portal connects to every Kubernetes cluster and collects CI and deployment data in one place, so a new view queries data that’s already there.
- Agent access: actions registered with Backstage’s MCP actions backend let any team’s agents look up anything in the catalog without a custom integration.
Teams then build plugins on top of it, often with an agent doing most of the work, and only have to focus on their actual problem.
Keep a Shitlist#
Platform teams see the same gap show up across many teams. Inside a single team you don’t get that view for free, but you can build a small version of it to find your own levers with the humble shitlist. 💩
For a few weeks, everyone on the team writes down every piece of toil, annoyance or risk they run into. If it made you frustrated, it goes on the list:
- “Waited half a day for dev again.”
- “Manually rotated the same cert again.”
- “Demo to product slipped because someone had dev.”
- “Someone’s deploy wiped my test data.”
Next, get the team on a call and group the items into categories. In the list above, three frustrations point to one missing primitive: PR environments. A dozen separate annoyances often turn out to be three missing primitives. The biggest cluster is where you need to focus your efforts. For that one, ask:
- What decision have we been avoiding that would make this whole category go away?
- What primitive could we build so the next instance is a ten-minute task?

This is also how you get past “you don’t see the leverage from a single ticket”. One website tweak can’t justify building PR environments, but a month of frustrations about dev can. The list is the evidence you use to get priority and support. From there, do the alignment work one conversation at a time (I’ve written about how I do that with Nemawashi), so by the time the proposal lands the decision is mostly made. Once it’s agreed, the team builds the primitive instead of working through the tickets one by one.
Conclusion#
It’s easy to assume a team falling behind lacks skills with AI, but perhaps it’s leverage they lack. The only way to get that leverage is to notice a gap exists, make the hard decisions, and build a primitive to fill it. AI makes this more urgent, because agents multiply whatever a team already has, gaps and all.
As a Staff+ engineer or tech lead, part of your job is to find those unmade decisions, make them once and build the primitives others can build on.