Writing / / 3 min read

Humans are the bottleneck in the future of software.

Pratham Bhatnagar

That sounds negative, but it is the most important thing to understand about where software is going.

Editorial image, not a client photograph

This is how peak productivity looks for most of us

Four agents, one codebaseRecreated, not a real session
agent 1
task: forms and modals, mobile-friendly
read  src/forms/index.tsx
edit  src/forms/field.tsx
- w-full
+ min-w-full
navigating... 18s
agent 2
task: tables, responsive
read  src/tables/table.tsx
Make this edit to table.tsx?
1. Yes
2. Yes, and do not ask again
3. No, and tell the agent what to do differently
agent 3
task: charts grid
read  src/charts/grid.tsx
- grid-cols-1
+ sm:grid-cols-2
Make this edit to grid.tsx?
1. Yes   2. Yes, always   3. No
agent 4
task: dashboard layout padding
read  src/app/layout.tsx
  58 lines
padding is px-4 py-4
update for mobile: pt-16
auto-accept edits on

Should we build this?

AI agents are making implementation cheap.

At @DeepworkAI, we have been running a crazy amount of agents, spending billions of tokens, and building at a speed that would have sounded ridiculous even three months ago.

The problem is no longer, "Can we build this?"

Most of the time, we can.
The harder question is:
Should we build this?
And does everyone on the team understand why?

A bad assumption does not stay in a planning doc anymore.
It gets synthesized into a PR in a few minutes.

And when everyone can ship faster, misalignment becomes much more expensive.

Alignment used to happen by accident

In the old development cycle, alignment happened almost by accident.

Because building took longer, teams had more time to question the idea, add context, and catch bad assumptions before the work was finished.

It was slower, but it created space to think.

The old development cycleIllustration
chat threadsdocsissues
plan
build
PRs
review

But today, the development cycle looks more like this

The development cycle todayIllustration
chat threads, issues
plan
build
PRs
review

Two people do not just discuss the same problem anymore.
They can both ask agents to solve it and create duplicate work before anyone notices.

AI makes software faster, but it also makes coordination harder.

Most of the tools we use today were built for a slower world.
They were designed around a process where implementation took time, so teams had natural moments to align along the way.

The context is in people's heads

The distance between an idea and working code is getting shorter every day.

But the distance between people understanding what should be built has not disappeared.

It matters more.

Because the most important context is usually not in the codebase.
It is in people's heads.

The real context is the decision which was made six months ago.
The thing nobody wrote down because everyone "just knew it."
Agents do not magically know that.

So when we give every developer more agents, more speed, we do not automatically get better software.

Instead you get more noise.
More PRs nobody has context for.
Features nobody asked for.
More conflicts
More alignment debt pushed into code review.

Software is a team sport

This is why we need to rethink the tools we use to build software.
The future is not just one developer with twenty Claude instances.

There is limited value in scaling individual output

Software is a team sport.
Code is cheap, alignment is notIllustration
AGENT FLEET</></></></></>…LOTS OF CODEAGENT FLEET</></></></></>…LOTS OF CODEAGENT FLEET</></></></></>…LOTS OF CODESHAREDCONTEXT</></></></></></>!</></></></></>!
Code is cheap. Alignment is expensive.

The future is teams working with agents in a shared context.

Humans still need to decide what matters.
Humans still need to align on direction.
Humans still need to bring the context that is not inside the code.

Agents make implementation cheap. But they make misalignment super expensive.

From vibe coding to agentic engineering

That is the shift from vibe coding to agentic engineering.
The next generation of software tools will not be judged only by how much code they help generate.

They will be judged by how well they help teams decide what code should
exist in the first place.

To solve this alignment problem, our agents came up with an internal tool.
We now call it openKT. (openkt.ai)

We are currently piloting with a few teams, to test it out.

I think it is a shared context layer for teams and agents. A place where the human knowledge that usually stays trapped in people's heads can become part of how software gets built.

Because the next bottleneck is not generating code.

It is getting humans and agents aligned before the wrong code gets generated.

Curious if other founders and engineering teams are feeling this too:
Are agents making your team faster, or are they also making alignment harder?

Originally published on X by Pratham Bhatnagar, May 11, 2026.

Talk to us

Working on this problem?

If you build or run a store, or build agents that shop, write to us.

Write to us