AI Isn’t Replacing Developers. It’s Shrinking the Team.

Around 2012 I was on a call trying to diagnose a server issue for a large enterprise client. The call had people joining from all over the world. Contractors, consultants, infrastructure teams, vendor support. Every time someone joined the bridge the list of names on the screen kept growing.

At some point I remember thinking how strange it was that so many people were there. This wasn’t a planning meeting or a review session. The goal was simply to figure out why the system was failing.

But that’s how big enterprise troubleshooting works. When something breaks badly enough, everyone who might possibly be connected to the system gets pulled onto the same call.

In reality only two people ended up doing any meaningful work on that call. Me and a Dell engineer.

The funny part is that I wasn’t even working on infrastructure. I was the front end developer on the project. I was there mostly because the issue surfaced through the application layer and someone thought it might help to have a developer on the line.

After about an hour of digging through logs and talking through the symptoms, it became clear that the issue wasn’t software at all. It was a hardware failure. Once we isolated the failing component, the Dell engineer confirmed it and we had the answer.

The rest of the call mostly consisted of people listening while two of us worked through the problem.

That wasn’t the last time I saw that dynamic. Over the years I’ve been on hundreds, maybe thousands, of calls that worked the same way. Large groups assembled to solve a problem while only a small percentage of the people on the call were actually involved in the solution.

At some point you start to notice something uncomfortable about that pattern.

A lot of modern software development isn’t really about writing code.

It’s about coordination.

After more than thirty years building things on the web, I can say pretty confidently that the code itself has rarely been the hardest part of the job. The harder part has always been the layers of communication around it. Understanding the problem, gathering information from different teams, translating decisions between departments, and coordinating the people responsible for different parts of the system.

Those layers exist for good reasons. Large systems require specialized knowledge and distributed teams. But they also create an enormous amount of overhead.

Meetings, documentation, escalation calls, review cycles, status updates. Entire roles and processes exist just to move information between groups of people.

Which brings us to AI.

Right now most of the conversation around AI focuses on coding. People ask whether AI will replace developers or whether software engineers should be worried about automated code generation.

I think that framing misses the bigger change that’s happening.

AI isn’t just helping people write code. It’s starting to participate in the thinking layer of companies. The kinds of work that previously required analysts, researchers, consultants, or multiple planning meetings can now begin with one person exploring a problem alongside an AI system.

You can research a topic, summarize the relevant information, explore architectural approaches, draft a plan, and begin building something that works without needing to assemble an entire group of specialists just to get started.

That doesn’t mean those roles disappear. Complex systems will always require expertise across many domains.

What it does mean is that the distance between an idea and a working implementation is getting smaller.

For decades organizations have grown larger because building complex systems required large amounts of coordination. Information moved slowly between people, so companies created layers to manage it. Research teams gathered data, product teams translated it into requirements, engineering teams built the solution, and operations teams managed what happened after release.

Every step involved handoffs and conversations between groups that each understood a different part of the system.

AI compresses many of those steps.

A single developer can now explore a problem, test ideas, prototype solutions, and document the results faster than was possible even a few years ago. The work that once required multiple roles working together can often begin with a single operator moving through those stages quickly.

That doesn’t eliminate teams. It changes how much coordination is required before meaningful work can begin.

I’ve been seeing this firsthand while building some of my own systems alongside my consulting work. AI doesn’t just help with writing code. It helps with researching ideas, exploring design options, drafting documentation, and thinking through the structure of a system.

The result isn’t that AI replaced a developer.

The result is that fewer layers are required to move from thinking about a problem to building something that solves it.

That leads to a different question than the one most people are asking right now.

Instead of asking whether AI will replace developers, it might be more useful to ask how many people a great developer actually needs around them anymore.

For a long time the answer kept growing. Product managers, designers, analysts, QA teams, documentation teams, marketing teams, and operations teams all played important roles in the process. Each group solved real problems, but each layer also added coordination.

AI doesn’t eliminate expertise, but it does reduce the amount of coordination required to turn ideas into working systems.

And coordination is a huge part of how companies operate today.

Large organizations will continue to exist. Some systems are simply too big and too critical to build without large teams. But the center of gravity is shifting. More things can be built by smaller groups. More experimentation can happen without massive budgets. More builders can move from idea to working product without waiting for an entire organization to line up behind them.

The future probably won’t be defined by AI replacing humans.

It will be defined by humans with AI needing fewer layers between thinking and building.

And if that’s true, the people who learn how to operate effectively in that environment will have an enormous advantage.

Not because they suddenly became ten times smarter, but because the tools around them allow them to move through problems faster than traditional organizational structures were designed to support.

Which brings me back to that call in 2012.

Dozens of people listening while two people worked through the problem.

For a long time that was just how things worked.

It’s starting to look like that might not be necessary anymore.

The new dev team might not be AI.

The new dev team might simply be one experienced engineer working with an army of agents.