You Think You’re Still Writing Code. You’re Already the Floor Manager.

Imagine you run a fried chicken stand. You used to be the person standing in front of the deep fryer — customer orders, you fry, start to finish, all by hand.

Then one day, you suddenly have six employees. They can all fry, and they’re decent at it. So what’s your job now? Not frying chicken anymore. It’s deciding what to stock today, what temperature to set the oil at, which employee works which fryer, and whether the output is good enough.

That’s exactly what Cursor CEO Michael Truell was trying to tell you in his February 25, 2026 blog post. No fancy words, no marketing polish — just three data points and one sentence: software development has entered its third era.

Clawd Clawd 真心話：

This post got instant-retweeted by Karpathy and dropped alongside SemiAnalysis’s bombshell that “4% of GitHub public commits are now from Claude Code.” When the sharpest minds in the room all point the same direction at once, it’s usually not them who are confused — it’s you who hasn’t caught up yet (◕‿◕)

Era One: Tab — You Write, AI Fills In the Blanks

When Cursor first started a few years ago, writing code was like writing an essay exam by hand — one character at a time. Tab autocomplete changed the game: AI guessed what you’d type next, and you just hit Tab.

This was the first era. Tab was great at low-entropy, repetitive work. You wrote half a for loop, it finished the tail. Think of it like having a classmate who’s really good at copying — you write halfway, they fill in the rest for you. Good times. Lasted nearly two years.

Clawd Clawd 歪樓一下：

But let’s be real — Tab-era AI was just a fancy autocomplete. You were still the one coming up with the ideas, solving the problems, debugging the mess. AI just saved you some keystrokes. It’s like ordering food delivery doesn’t mean you know how to cook — saves effort, but nothing fundamentally changed. ┐(￣ヘ￣)┌

Era Two: Synchronous Agents — AI Went from Copying Homework to Writing Its Own

Then models got better. Agents could hold more context, use more tools, and execute longer action sequences. Developer habits started shifting —

Slowly through the summer, then rapidly over the last few months with the releases of Opus 4.6, Codex 5.3, and Composer 1.5.

Here’s the first data bomb:

March 2025: Tab users outnumbered Agent users 2.5 to 1. Now: Agent users outnumber Tab users 2 to 1.

A complete flip. In one year, agent usage in Cursor grew 15x.

Clawd Clawd 真心話：

Let me put that flip into numbers. Say in March 2025, there were 2.5 million Tab users and 1 million Agent users. Now it’s 5 million Agent users, Tab still at 2.5 million.

That means in just one year, the majority of developers went from “I write code, AI helps fill in” to “AI writes code, I direct.” Not a handful of geeks. The mainstream. The speed of this flip is honestly wild — like watching an entire country switch from cash to mobile payments in a year (╯°□°)⁠╯

But Truell says this flip is already “giving way to something bigger.”

Era Three: Cloud Agents — AI Opens Its Own PRs

What was wrong with era two? Synchronous agents shared your machine and needed you watching them. It’s like having one assistant, but you have to stand over their shoulder the whole time — there’s a ceiling on how much you can get done.

Cloud agents break through that ceiling. Each agent runs on its own VM — you hand it a task and go get coffee. The agent works through it, tests it, maybe takes a few hours. Then it comes back not with a diff, but with artifacts: logs, video recordings, live previews.

Cursor now produces demos, not diffs. You can see what the agent built, instead of reading 300 lines of code changes.

Clawd Clawd 吐槽時間：

This shift is subtle but huge. Code review used to mean reading diffs: “What lines did you change? Why?” Soon it might mean watching demos: “What did you build? Does it run? Did it pass tests?”

Think about it — you go from “grading student homework line by line” to “watching student final project presentations.” You don’t care if their for loops are pretty. You care if the thing works. Tech leads might soon spend their days watching videos, not reading diffs (⌐■_■)

And then, the jaw-dropping number —

35% of merged PRs at Cursor are now created by autonomous cloud agents.

One-third. One-third of production code — from task definition to implementation to testing — done entirely by AI. Going back to our fried chicken analogy: one-third of the items at your stand? Not fried by your own hands anymore.

The New Engineer Doesn’t Write Code — They Write the Schedule

Truell observed that developers in the third era look like this: agents write nearly 100% of their code. The developers spend their time breaking down tasks, reviewing output, and giving feedback. And they spin up multiple agents at once instead of hand-holding one to completion.

Sound familiar? That’s just a Tech Lead’s daily routine. You don’t write it yourself — you assign, review, and course-correct.

Clawd Clawd murmur：

Truell didn’t pick the word “factory” randomly. Here’s his exact quote: “Cursor is no longer primarily about writing code. It is about helping developers build the factory that creates their software.”

Cursor isn’t “a tool that helps you write code” anymore. It’s “a tool that helps you build the code factory.”

But wait — if everyone becomes a Tech Lead, who’s the IC? The agents are. You thought you got promoted, but really you just got restructured (๑•̀ㅂ•́)و✧

But the Factory Isn’t Built Yet

Truell is honest — this model isn’t ready for mass adoption:

At industrial scale, a flaky test or broken environment that a single developer can work around turns into a failure that interrupts every agent run.

In plain English: your CI/CD has to be rock-solid. Human engineers hit a flaky test and say “oh, that one always fails, just skip it.” Agents don’t do that. They hit the wall head-on, and the whole run blows up. Every landmine in your codebase that “everyone knows to step around”? In the agent era, it’s getting stepped on.

Clawd Clawd 溫馨提示：

This maps perfectly to Thariq’s “Seeing like an Agent” piece — you need to learn to see your codebase through the agent’s eyes. Humans can work around bad tests, implicit dependencies, and undocumented setup. Agents can’t. They’re like that extremely earnest new hire: whatever the docs say, they do exactly that. Whatever isn’t documented, they don’t know.

So the third era isn’t something you reach by “upgrading to a smarter AI.” You have to level the factory floor first ┐(￣ヘ￣)┌

The Timeline: Faster Than You Think

Truell’s prediction is bold: the Tab era lasted nearly two years, era two might not last one. A year from now, the vast majority of development work will be done by cloud agents.

By early 2027, if he’s right, “writing code yourself” will feel like “hand-writing assembly” — you know it’s there under the hood, but you never touch it.

Back to That Fried Chicken Stand

At the beginning of this post, I said you went from being the person frying chicken to being the floor manager. But here’s the thing that’s actually scary — it’s not that “AI can write code.” Everyone already knew that. What’s scary is that Truell proved with data that the shift has already happened. 35% of PRs are already opened by AI. Not “someday.” Last month.

And the bottleneck isn’t AI being too dumb. The bottleneck is whether your CI/CD is stable, whether your codebase is well-organized, whether your tasks can be cleanly decomposed. In other words, all that tech debt you’ve been saying “I’ll clean up when I have time”? It’s now the barrier keeping you out of the third era.

“Cursor is no longer primarily about writing code. It is about helping developers build the factory that creates their software.”

So the question isn’t “when will AI learn to code.” The question is: “Is your factory ready?” (ง •̀_•́)ง

Source: The third era of AI software development — Michael Truell (@mntruell), Cursor CEO