I still remember calling it autocomplete.
A tab key that finished my sentence.
Nothing more.
Then it started reading the whole file.
Then the whole folder.
We wrote rules so it knew how to behave.
Rules became skills.
Skills became agents.
Agents got sub agents, and someone gave them a name: orchestration.
Now you give a task.
It plans.
You approve the plan, and it builds the thing, tests included.
You barely touch it.
That’s where we are.
The Gap Nobody Names
Anthropic put a number on it this year.
Developers use AI in roughly 60 percent of their work.
They can fully delegate only 0 to 20 percent of it.
That gap has a name now.
The delegation gap.
Read that twice.
We use it constantly.
We trust it rarely.
The bottleneck was never typing speed.
It was clarity.
Clarity about what we actually want built.
So What Happens Next
Here is my honest guess, not a headline.
The plan becomes something we version.
Not just the code.
We will diff intent the way we diff commits today.
Agents will start catching each other’s mistakes.
Before we even open the pull request.
Review moves from reading lines to reading outcomes.
Trust stops being a switch.
It becomes a dial.
Some tasks earn full autonomy, some never will.
This spreads past code too.
Legal, ops, support.
Coding is just the first domain because it’s the easiest to verify.
Where I Pushed Back On Myself
I told a friend that code was becoming disposable.
Regenerate it whenever you want, like a fresh coat of paint.
He asked me one question.
What happens to your WordPress plugin’s changelog?
I had no answer.
A shipped plugin is not a prototype.
People install it.
People depend on version 1.0 behaving exactly as it did yesterday.
If an agent regenerates the whole plugin from a spec, you lose the diff.
You lose the changelog.
You lose the ability to say this bug started in 1.2 and got fixed in 1.3.
So no, code is not disposable.
Not for anything you ship.
Two Layers, Not One
Here’s the correction I landed on.
The spec is the layer of intent.
It carries the why, and the tests that prove correctness.
The code stays the layer of record.
It carries the what, the diff, the changelog, the compatibility promise.
One does not replace the other.
They sit on top of each other.
An agent working on your plugin still needs to patch 1.0 into 1.1.
Not regenerate a new plugin and call it the same name.
What This Means If You Build Plugins
Your job is shifting, not disappearing.
Write specs an agent cannot misread.
Build eval suites that catch a broken site before a user does.
Own the changelog discipline no agent can inherit for you.
The parts agents still struggle with are exactly your fifteen years.
Real plugin conflicts.
The quiet politics of backward compatibility across WordPress core versions.
That is not nostalgia talking.
That is where the moat still sits.
The Question I’m Sitting With
If we revisit this in November, what will have moved?
Has delegation gone past 20 percent?
Has anyone actually shipped a spec first, diff second workflow for a real plugin?
I don’t know yet.
But I know this much.
The tools keep getting smarter.
Our job is to stay the one who decides what smart is for.
Leave a Reply