The AI Productivity Illusion

1. I Got Faster. I Also Got More Tired.

I used to have trouble finishing my ChatGPT Plus quota in a week.

Now I can burn through it in three days.

That looks like a productivity win.

In some ways it is.

But the strange part is this: work hasn’t gotten easier. I’m more exhausted than I used to be.

I’m a developer who moved into iOS from another technical background. I use AI heavily every day.

When I first switched, almost everything was unfamiliar. Half a day could disappear digging through documentation for an API, tweaking a layout, or chasing a crash I’d never seen before.

I wasn’t fast, but the pace felt human.

I’d write some code, look something up, get a glass of water, come back, and let the problem sit for a while.

Then AI changed the rhythm.

Unfamiliar syntax? Ask AI.
Need a first pass at a UI? Have AI generate one and refine it.
Documentation, test notes, copy, small refactors—AI can help with all of it.

The gains are real. I’m not interested in pretending otherwise.

But the slower workflow had something the new one doesn’t: breathing room.

Now I can spend an entire day in a loop of prompting, reading, correcting, reviewing, testing, and prompting again.

More gets produced.

There’s just less space to think.

That made me wonder whether we’re measuring AI productivity the right way.

2. Are We Measuring Productivity—or Just Output Speed?

There’s an idea that’s become almost conventional wisdom:

AI dramatically increases productivity.

I used to accept that without much hesitation. I use AI every day and clearly get more done with it.

But the more closely I looked at my actual workflow, the more I started asking a different question:

Is AI improving end-to-end productivity, or is it mostly accelerating one stage of the process?

By productivity I don’t just mean how quickly code appears on a screen.

I mean the whole path from a request to a result: understanding the problem, building the solution, validating it, shipping it, and seeing whether it actually works.

Code generation is much faster.

But are projects shipping five times faster because code is generated five times faster?

Usually not.

That’s where one of the biggest AI illusions begins:

We confuse generation speed with productivity.

3. AI Added Another Communication Layer

Before AI, a typical feature request might look like this:

Request → understand it → write code → test → get feedback → fix → ship.

Not exactly simple, but the communication path is direct.

With AI it often looks more like this:

Request → understand it → translate it into a prompt → interpret the AI’s response → verify that it understood the task → generate code → review the code → test → get feedback → fix → ship.

AI doesn’t sit between a coworker and the codebase and magically turn vague requests into finished software.

Someone still has to translate.

Suppose a coworker says:

“There’s something wrong with the ads on this page.”

That’s not really a coding task yet.

Does the ad fail to load?
Is it showing at the wrong time?
Is the close button broken?
Is the layout wrong?
Is the SDK misconfigured?
Is it a network problem, remote config problem, caching problem, or backend setting?

Before AI can help, I still have to narrow the problem down, gather the relevant code and logs, explain the expected behavior, and describe what actually happened.

Then, after AI proposes a solution, I have to verify it.

Did it touch the right code?
Did it change behavior somewhere else?
Did it violate an existing architecture decision?
Did it create a new release risk?

AI helps with part of the process.

It doesn’t remove the work of turning ambiguity into something executable, or turning generated output into something trustworthy.

Before AI, I mostly communicated with people.

Now I communicate with people, communicate with AI, and translate between the two.

AI didn’t eliminate communication. It added another layer.

4. Faster Generation Isn’t Faster Delivery

This distinction matters because producing code is not the same as delivering software.

A real feature moves through requirements, clarification, implementation, review, testing, integration, feedback, release, and production risk.

AI is excellent at speeding up implementation. Sometimes dramatically.

But it doesn’t automatically clarify requirements.
It doesn’t eliminate integration testing.
It doesn’t make users or coworkers approve the result.
And it doesn’t make production failures less real.

In some cases AI actually creates more downstream work because it produces more code, faster.

More output means more surface area to review.

AI made “write it” much faster.

It did not make “make sure it’s right and safe to ship” equally fast.

5. Generation Got Cheap. Correctness Didn’t.

This is probably the biggest shift I’ve felt personally.

AI has made generation incredibly cheap.

Correctness is still expensive.

When I write code myself, I’m slower, but I usually know why each piece exists. The implementation grows out of my own understanding of the problem.

With AI I may suddenly get changes across several files, a new abstraction, extra error handling, and a few “improvements” I never asked for.

Now I have to work backward through the result.

Did it misunderstand the requirement?
Did it break existing behavior?
Did it ignore the architecture?
Did it introduce a subtle bug?
Is this code maintainable?
Would I trust this change in production?

The larger the generated change, the more expensive those questions become.

The work hasn’t disappeared.

It has shifted.

Instead of spending all my time creating code from scratch, I spend more time reviewing, filtering, testing, and taking responsibility for code that appeared almost instantly.

AI made generation cheap. It didn’t make correctness cheap.

6. The Industry Is Already Moving Toward Verification

This isn’t just a personal feeling.

A lot of current AI engineering practice is moving toward the same problem: how do you make powerful coding agents reliable?

Ideas like Harness Engineering shift attention away from simply asking whether an AI can write code.

The focus becomes the environment around the agent: clear intent, constraints, feedback loops, tests, review processes, and systems that prevent a fast model from making uncontrolled changes.

That shift is telling.

The question is no longer just “Can AI write the code?”

Increasingly it’s “Can we trust the process that turns AI-generated code into production software?”

The gap between generation and delivery is becoming an engineering discipline of its own.

7. Output Is Not Productivity

This problem goes far beyond software.

AI can write marketing copy quickly. That doesn’t mean the product will sell.
It can generate design variations instantly. That doesn’t mean the team will make better design decisions.
It can produce ten strategies in a minute. That doesn’t mean any of them have been validated.
It can write a PRD in seconds. That doesn’t mean the requirements are clear.

Generating more things is not the same as producing more value.

To me, productivity means something closer to this:

How much useful work was correctly understood, validated, delivered, and turned into a real result?

By that definition, raw generation is only one piece of productivity.

An important piece, certainly.

But not the whole thing.

8. Human Work Didn’t Disappear. It Changed Shape.

For years people imagined AI reducing the amount of work humans would need to do.

My experience has been different.

The work is still there.

It just moved.

Developers used to spend more of their time directly producing the implementation.

Now more of the job is becoming orchestration: turning requirements into instructions, maintaining context, reviewing output, spotting mistakes, managing risk, and deciding what is safe to ship.

Human labor moved from the keyboard into judgment.

The old fatigue came from typing, debugging, reading documentation, and manually tweaking things.

The new fatigue comes from attention.

You’re constantly evaluating.

Is this answer right?
Did the model miss something?
Why did it change that file?
Should I accept this diff?
Did this fix one problem and create another?

That kind of work is less visible than writing code, but it’s still work. Often very demanding work.

AI didn’t remove human labor. It shifted it from production toward judgment, orchestration, and verification.

9. Why the Productivity Illusion Is So Convincing

AI’s gains are easy to see.

Ask for code and code appears.
Ask for an article and an article appears.
Ask for an image and an image appears.

The speed is almost theatrical.

The costs that remain are harder to see.

The time spent clarifying requirements.
The time spent reading generated code.
The time spent testing.
The time spent fixing a misunderstanding.
The larger test surface created by larger amounts of generated code.
The production risk that still belongs to the human who ships it.

And then there are the costs that don’t show up in a dashboard at all: attention fatigue, context switching, the mental load of reviewing machine output all day, and the unsettling feeling that you’ve produced a huge amount of work without being completely sure how much of it you can trust.

Everyone can see how fast AI generates.

Very few people see the human effort required to turn that output into something reliable.

10. AI Productivity Inflation

There’s another effect I’ve started noticing.

Before AI, if a feature took two or three days, that might have felt completely normal.

Now there’s an implicit question hanging over more and more work:

“If you have AI, shouldn’t this be faster?”

Nobody even has to say it.

Sometimes the pressure comes from ourselves.

You end the day without finishing something and wonder: Am I using AI badly? Are my prompts not good enough? Are other developers moving faster than I am?

The tools got faster, so our expectations accelerated too.

But human attention, judgment, memory, and recovery didn’t suddenly become five times more powerful.

I think of this as AI productivity inflation.

AI increases the amount we can generate, and then that increased output becomes the new baseline.

More code can be produced, so more code is expected.
More work can be started, so more work has to be reviewed.

The productivity gain creates a new productivity expectation.

Eventually part of the benefit gets consumed by the expectation it created.

The machine got faster.

So we started expecting humans to operate at machine speed.

That’s not sustainable.

11. Good AI Workflows Need Rails

The answer isn’t to stop using AI.

I certainly don’t intend to.

The better answer, in my experience, is to stop treating unlimited generation as the goal.

Good AI workflows need rails.

Let the AI understand the project before it starts editing.
Ask for a plan before asking for implementation.
Review the plan.
Keep changes small.
Inspect diffs.
Run tests continuously.
Let humans control the final merge and release decision.

That may sound slower than telling an agent “Here’s the problem. Go fix everything.”

But uncontrolled speed often creates expensive cleanup.

A slower-looking process can be faster overall if it reduces rework and makes failures easier to catch.

The stronger AI becomes, the more valuable good constraints become.

That’s not distrust.

It’s engineering.

12. Redefining a Productive Day

AI has also forced me to rethink what I consider a productive day.

Finishing a feature matters.
Fixing bugs matters.
Shipping matters.

But so do things that don’t create visible output.

Clarifying a vague requirement is productive.
Proving that an approach won’t work is productive.
Deleting incorrect AI-generated code is productive.
Finding the root cause of a bug is productive.
Catching a release risk is productive.
Building a reliable test path is productive.

These things don’t generate impressive screenshots or massive diffs.

But they move a project closer to something that can actually survive contact with reality.

In the AI era, code is becoming abundant.

Judgment isn’t.
Neither is verification.
Neither is responsibility.

AI can generate an implementation.

Someone still has to decide whether it’s right.
Someone still has to decide whether it should ship.
And someone still owns the consequences when it doesn’t work.

13. AI Is a Lever, Not a Whip

I believe AI is one of the most useful tools I’ve ever had as a developer.

It makes me faster.
It lets me work in areas where I have less experience.
It lowers the cost of experimenting.
It can turn hours of tedious work into minutes.

None of that is in question.

But faster generation isn’t the same as faster delivery.
More output isn’t the same as more value.
And a machine’s ability to produce work faster doesn’t mean a human can review, understand, and take responsibility for that work at the same speed.

The biggest AI illusion may not be that we think AI can do everything.

It may be that we’ve started treating generation speed as a proxy for productivity.

AI should expand what humans can do.

It shouldn’t become a benchmark that humans are forced to chase.

AI is a lever, not a whip.

Real AI productivity isn’t about producing the most output.

It’s about reliably delivering more of the right things.