Whimsical 3D illustration of a smiling developer i

Beyond the Keyboard: Building a Team That Solves Problems with Agents

A common situation

Picture a small software team: somewhere between five and fifteen developers, a couple of product managers, and an AI bill that works out to well under a hundred dollars per engineer per month, mostly on chat-assistant seats. The developers are good. Many have a decade or more of experience. They use AI, but carefully: they ask a question now and then, generate a boilerplate function, and paste in a stack trace. Meanwhile the product managers can’t write specifications fast enough to keep the engineers busy.

This team doesn’t have a tooling problem. It has a role problem, and the low AI usage is a symptom of it.

The uncomfortable question

Here’s a challenge I think more engineering leaders should ask openly. Suppose an experienced developer can’t find enough tasks in their week for an AI agent to help with. That includes coding, but also tests, refactoring, documentation, investigation, migrations, specs, code review and prototyping. Only two explanations are possible. Either they’re coding better than today’s frontier models across nearly everything they do, or they haven’t really tried.

The first explanation is getting harder to defend. Anthropic has reportedly said in its IPO filing that Claude now writes more than 90% of the company’s code. Source That code is the frontier AI systems themselves, among the most demanding software being built anywhere. Headline percentages like this deserve some skepticism, because “written by AI” can mean many things. Analysts at Redwood Research, for example, have looked closely at what such claims actually measure. Source Even with heavy discounting, though, the direction is clear. If the teams building frontier models trust agents with most of their code, it’s hard to argue that a typical CRUD app, internal tool or SaaS backend is too special for them.

Microsoft is heading the same way. Satya Nadella recently described the team behind Microsoft’s Cowork agent: 11 developers who “build a software factory that builds the product. They don’t build the product.” He believes every employee will eventually become a manager of agents. Source

It’s not about tokens, but tokens tell you something

Let me be clear: this isn’t a case for tokenmaxxing. We’ve already watched that go wrong. Inside Meta, an engineer built a leaderboard ranking employees by token consumption, and it became a cautionary tale about measuring activity instead of value. Source LeadDev’s analysis of the episode concluded that the search for AI metrics that matter has to go beyond raw consumption. Source

Still, usage can’t be ignored entirely. Consumption works like a smoke detector. It won’t tell you what’s burning, but a total absence of it is worth investigating. Some public reference points:

  • Claude Code enterprise data. Anthropic’s documentation puts the average cost at around $13 per developer per active day, or $150–250 per developer per month. Source
  • LinearB. Its research puts the 90th percentile of spend at $481 per developer per month, or about $35 per coding day. That’s under 4% of a developer’s fully loaded cost. Source
  • Larridin’s 2026 benchmarks. Teams using agentic tools spend $200 to $2,000+ per engineer per month on tokens, on top of seat licences. Source
  • The extreme end. Tomasz Tunguz reports that the top 1% of companies spend about $89,000 per engineer per year on AI. Nobody should copy that, but it shows how far the range now stretches. Source

Compare those figures with a team spending well under a hundred dollars per engineer each month on flat-rate seats. That number doesn’t prove anyone is underperforming. It does strongly suggest the team is still using AI as a smarter search box rather than as a collaborator that does real work.

So how do you use numbers sensibly? Treat usage as a conversation starter, never a ranking. Look at trends over months, not a weekly snapshot. Look at the shape of usage, too: is a developer using agents only for autocomplete, or across testing, investigation and specs? If a senior engineer’s agent activity is close to zero on most working days, ask them about it with curiosity: “Walk me through where you tried it and where it failed.” Don’t pass judgement. Sometimes the answer will teach you something real about your codebase. Often it will show that the tools were never given a fair, sustained trial.

Why experienced people hold back

Resistance from senior engineers is rarely laziness. It usually comes from three understandable places.

Identity. Someone who has spent fifteen years mastering a craft is being asked to step back from the part of the job they find most satisfying and most valued: writing elegant code by hand. That feels like a loss, and leaders should name it openly.

Earned skepticism. Early AI tools did produce plausible nonsense. Stack Overflow argues that developers are right to be skeptical, because high standards on quality and security are part of the job. Source There was hard evidence too. METR’s controlled 2025 study found experienced developers were 19% slower with AI, while believing they were faster. Source But the evidence has changed. METR’s early-2026 update says developers are now likely sped up. Its follow-up study ran into trouble partly because so many developers refused to work without AI, even when paid to. Source A skeptic’s judgement may simply rest on a version of the tools that no longer exists.

Job security. If agents write the code, people reasonably wonder where that leaves them. Nadella acknowledged that the way the AI revolution has been discussed “created enormous anxiety in people.” Source Anxious people protect what they have. They don’t experiment.

You can’t push past any of these with a mandate. You have to give people a better role to grow into.

Team formation: from ticket-takers to problem owners

The core shift is this. When code is cheap, the scarce resources become judgement, problem definition and verification. Most small teams are still organised around the old scarcity: PMs write tickets and developers turn them into code. That’s exactly why the PMs become a bottleneck. Forbes Technology Council contributors have described PMs as the new constraint once code starts writing itself. Source

The fix is to redraw the lines. Here’s how I’d reorganise a small team.

PMs own the “why”, not the ticket. The product managers set outcomes, customer problems, success metrics and priorities. Their output is a short problem brief, not a forty-field ticket. A couple of PMs can’t spec everything a team of agent-assisted engineers could build, and they shouldn’t try.

Developers become product engineers. Each engineer, or pair of engineers, owns a problem area end to end. They take a brief, interview the customer or support team, and use agents to draft the detailed spec and acceptance criteria. They prototype in hours rather than weeks, then bring something working back to the PM for a reaction. Reacting to a prototype is much faster than writing a spec from scratch, and that’s where the PM bottleneck starts to disappear. A good spec is also exactly what a coding agent needs, so the developer’s spec-writing directly feeds their own productivity.

Verification becomes a first-class job. When agents produce most of the code, the most valuable human skill is knowing whether it’s right. Your most skeptical senior engineer is often the best person to own this: test strategy, review standards, security guardrails, and the evaluation harnesses that make agent output trustworthy. Their skepticism stops being friction and becomes the team’s quality system. Google’s DORA research found that AI “amplifies what’s already there,” so strong engineering practices matter more than ever, not less. Source

Someone builds the factory. Nadella’s “software factory” doesn’t build itself. At least one engineer should own the team’s agent infrastructure: shared prompt and rules files, repository context documents, test-generation pipelines, review agents, and CI integration. Every improvement here benefits the whole team, which makes it among the highest-leverage work available.

These are roles, not job titles, and people will move between them. What matters is that every engineer can see a version of their job that is bigger and more interesting than the one AI is absorbing. “Write less code” is a threat. “Own a customer problem, and command a team of agents to solve it” is a promotion.

How to entice people, not force them

Start with volunteers and real work. Pick the one or two most curious engineers, give them proper agentic tools, and point them at real backlog items. These shouldn’t be demos. They should be the migration nobody wants or the test suite nobody wrote. One practitioner’s rollout guide recommends exactly this, building on “evidence and volunteers, not a mandate and a leaderboard.” Source

Show sessions, not slides. A weekly half-hour where someone shares their screen and walks through a real agent session, including the failures and dead ends, persuades better than any presentation. Seeing a respected colleague hand a tedious refactor to an agent and review it over lunch changes minds.

Set a light but clear expectation. Shopify’s Tobi Lütke made “reflexive AI usage” a baseline expectation across the company. Source A small team can use a gentler version: try an agent first on every task, and if it falls short, share why at standup. Failures shared this way become team knowledge, not personal embarrassment.

Change what gets rewarded. If reviews and promotions still quietly reward hand-written code volume and heroic debugging, nothing else you say will matter. Reward problems solved, spec quality, test coverage built, reusable agent workflows shared, and time saved for colleagues.

Fund it properly. A flat-rate chat seat sends the message that AI is a perk. A real budget for agentic tools, used visibly and without guilt, sends the message that this is how we work now. By the benchmarks above, even generous spend is a small fraction of an engineer’s cost.

Make the deal explicit. Say it plainly: the goal is a bigger product built by the same team, not a smaller team building the same product. If that’s true, say it often. If it isn’t, your people will find out, and no adoption programme will survive that.

What to measure instead

Track outcomes at team level:

  • Speed: lead time from idea to production, and how long work waits on specs.
  • Quality: change failure rate and escaped defects.
  • Scope: customer problems solved per quarter.

Alongside those, keep an eye on agent usage as a health signal: whether it’s broad across task types, whether it’s growing, and whether it’s spread across the team rather than concentrated in one enthusiast. Take a baseline before you change anything, then compare after a quarter. Expect a dip at first, because learning new workflows takes time. Judge the trend.

Closing thought

The developers who have spent ten or twenty years learning their craft aren’t obsolete. They hold exactly what agent-driven development lacks: judgement about edge cases, architectural taste, a sense for what will break at 3 a.m., and a nose for what customers actually need. The job of leadership is to move that expertise up the stack, from typing code to defining problems, directing agents and guaranteeing quality.

So challenge the assumption that senior engineers can’t find more for AI to do. Then give them a team structure where finding more is the job.