Claude Code is the New Cursor (and the Cycle Never Ends)

This isn't a post about Claude Code. It's a post about the loop that makes Claude Code inevitable.

I've seen this exact movie three times now: Copilot → Cursor → Claude Code. New tool drops. Twitter declares the profession dead. Everyone repeats the same lines. The tool is usually good. The cycle is always identical.

When Tech Twitter discovers something new, I ignore it on purpose. Wait until the early adopters calm down. Usually I'm skeptical of whatever everyone is yelling about, not because I think I'm smarter, but because the hype phase is useless for actually evaluating anything.

But sometimes you can't ignore it anymore.

This time the object of worship is Claude Code, Anthropic's agentic coding CLI. And yes: it's actually good. I use it every day. It deserves a lot of the attention.

But what interests me isn't the tool. It's the pattern underneath.

Because about a year ago (which is basically eternity in AI time) we did the exact same thing with Cursor.

Cursor, Cursor, Cursor#

You couldn't scroll five minutes without someone announcing that Cursor "10x'd their workflow" and "ended software engineering forever." Every demo video. Every Twitter thread. The same breathless energy.

Then the pricing shifted. Usage limits got real. The economics of wrapping frontier model APIs showed their teeth. And suddenly a lot of people rediscovered the ancient art of... having opinions about subscriptions.

I don't want to be the guy saying "everything is an AI wrapper", although, I mean, it kind of is. These tools are building on top of APIs from Anthropic, OpenAI, Google. So they're always going to cost a little more than the base model, for whatever additional functionality they claim to offer.

And now here we are again. Claude Code is the new Cursor. Same chorus. Different mascot.

I even still have Windsurf on my machine somewhere. I almost never open it.

The Tool is Good. The Pattern is Predictable.#

Let's be honest: Claude Code is genuinely impressive. Every developer I know who's actually tried it thinks it's great.

I installed it thinking I'd test it for 15 minutes. Two hours later it had refactored a module, renamed half my functions, and confidently broken a build I didn't even know existed. Which is exactly why it's useful, and exactly why you need to stay awake.

It's not just autocomplete and not just chat. It's an agent that explores, edits, runs commands, keeps going without constant hand-holding. After a week you start feeling silly opening a giant IDE for small surgical tasks.

But here's the thing nobody tells you during the honeymoon phase:

Every generation of these tools is impressive... until it isn't.

Claude Code isn't perfect. OpenAI's Codex CLI is also very good. Sometimes they're each stupid in their own special ways. I use one to clean up the other. Sometimes they both get stuck in the same rut, like a Roomba chewing the same carpet corner for 40 minutes while you watch in disbelief.

The failure mode is always the same: local minima.

They'll confidently refactor a module while missing the architectural mismatch one level up. Chase symptoms instead of causes. Propose a fix that works in isolation but makes no sense for the actual system.

And here's a weird thing I've noticed. If you paste the same codebase into the web interface (ChatGPT, Gemini, Claude's web UI), those models will often catch issues that the agentic CLI totally missed. Something about that context encourages higher-level thinking. The CLI is optimizing for action. The chat interface is optimizing for conversation. Different failure modes.

So now my workflow looks like this:

• Agent CLI: Mechanical work. Refactors, wiring, tedious migrations.
• IDE: Browsing. Spatial understanding. Nothing beats seeing the shape of a codebase.
• Web UI: Architecture critique. "What's the hidden coupling here?" "Where's the footgun?"

This is the real pattern emerging: execution is getting cheap. Taste is getting expensive.

npm install -g @anthropic-ai/claude-code
claude

# From terminal
claude plugin install code-simplifier

# Or from within a Claude Code session
/plugin marketplace update claude-plugins-official
/plugin install code-simplifier

Why Wrappers Always Become Painful#

There's a dirty economic truth behind most AI developer tools:

If you're building on frontier model APIs, you're downstream of someone else's cost structure.

You can ship an amazing experience. But at some point, the bill arrives. And when it does, one of three things happens:

1. You raise prices
2. You add usage caps
3. You degrade quality silently (cheaper models, routing tricks)

Cursor went through some version of this. People call it a rug pull. I'd call it something less dramatic: gravity.

You can't sell unlimited magic forever if your suppliers charge you per spell.

This is why the new wave of tools is drifting toward something else: the CLI.

The Terminal Renaissance#

A year ago, I didn't "get" the appeal of living inside a CLI coding agent.

I'm an IDE person. I like my nice panels. My file tree. My little comforting tabs. My illusions of control.

But now I get it.

The CLI agent isn't trying to be your full environment. It's trying to be your execution layer. A thin interface between intent and diffs.

It's closer to the Linux philosophy: composable tools, minimal UI ceremony, directness over polish.

And it's not just Anthropic and OpenAI. Google has Gemini CLI, and it's explicitly open-source. That matters.

Open-source tools don't just compete on features. They compete on ownership and survivability:

• If the vendor changes pricing, you can fork
• If the product disappears, your workflow doesn't
• If you're serious, you can build a local ecosystem around it

This is why the "Linux phenomenon" keeps winning over time. Not in polish, but in inevitability.

DHH made a similar observation recently. The proprietary IDE-as-product model starts looking fragile when the execution layer becomes a commodity you can swap out.

I still open VS Code constantly, but mostly for browsing, reviewing, deep reading. Not because the agent can't edit files. It can. It's because the IDE is for humans. The agent is for throughput.

Different jobs.

Vibe Coding: Power Tool, Not Religion#

"Vibe coding" has become one of those terms people say with either worship or disgust. I don't know which camp is more annoying.

Here's the thing: vibe coding is real. It's also dangerous.

It's like giving someone a chainsaw that can talk.

If you're already a developer, it's a leverage multiplier. Removes drudgery. Accelerates iteration. Lets you explore more branches than you ever could manually.

If you're not a developer, you can now produce insecure systems, duct-taped architectures, unmaintainable slop that looks finished. And you won't even know it's slop until something breaks in production.

Even if you are a developer, you need to stay awake. Because the models hallucinate competence in subtle ways. They'll invent conventions your repo never had. Fix the symptom you didn't care about. Create "clean" abstractions that add complexity while claiming to reduce it.

Yes, you can ship faster than ever.

You can also ship a faster catastrophe.

If you can't code at all, you'll probably build much worse systems than you think you're building. More insecure. More fragile. If you can code, you'll notice how much garbage AI still generates if you don't actively handle it. But this is only the current state; if the trajectory continues, who knows what happens in the future.

The Uncomfortable Question#

This is the part I don't think we've emotionally processed yet.

I learned coding the "old" way. Google. Stack Overflow. Documentation. Failure loops. It was probably inefficient. But it did something important: it forced me to build internal models.

Learning something deeply requires friction. You bump into your limits, struggle, debug, update your understanding. Not masochism, just the natural resistance at the edge of your comfort zone.

Now we've made it incredibly tempting to remove that friction completely.

Ask the agent. Copy. Paste. Ship.

Here's what I've landed on: use agents to compress work, not to replace comprehension.

If you're only prompting AI, the only thing you get better at is prompting AI. That might be valuable. But it's not the same as understanding systems.

Same as I wouldn't be able to build an engine for a car. Maybe in the future, people won't be able to understand how code works. That's not necessarily dystopia; it's just specialization. But it does change who can do what.

The real risk is a generation of builders who can produce output without understanding the machinery underneath. Which is fine until you need to:

• Debug something subtle
• Secure something exposed
• Reason about long-term maintainability
• Operate without the tool

My rule now: if I can't explain the change in plain English, it doesn't ship. Not because I'm a purist, but because I've been burned by code I didn't understand.

The Signal and the Noise#

The field is moving absurdly fast. In six months, the main tool might be something completely different. Maybe this "agentic CLI" moment becomes background noise. Maybe we're all using some interface that doesn't even exist yet.

But the hype cycle is predictable. It always looks the same:

1. New shiny thing drops
2. Early adopters become evangelists
3. Everyone repeats what the evangelists said
4. Someone makes a YouTube video repeating what Twitter said
5. People repeat what Sam Altman said, what Andrej Karpathy said, essentially doing free marketing for these companies
6. The product gets commoditized or priced up
7. A new wave shows up
8. We all pretend it's the first time

The cycle isn't malicious. It's economic. Attention rewards certainty, and demos beat nuance.

The interesting signals are rarely in the loudest voices. They're in the quieter ones: the people building real systems, reporting actual failure modes, showing how it breaks instead of just how it demos.

If you only listen to the echo chamber, you'll always be late and confused.

The Bubble Question#

Here's something I keep wondering: how many people worldwide are actually using Claude Code?

On Twitter it looks like the most mainstream thing ever. Outside that bubble, most people haven't heard of it. The loudness of a tool is not the same thing as its adoption. Twitter is a megaphone, not a census.

Anthropic knows this; they recently released Claude Co-Work, built on top of Claude Code but aimed at non-coders. Because for someone who isn't comfortable in a terminal, a CLI is intimidating no matter how nice the aesthetics are.

When I instruct a coding model, I have a clear mental model of what should happen. What the codebase looks like structurally, at least at an architecture level. That's probably necessary to get real value out of these tools.

Which raises the question of how mainstream "agentic coding" can actually become, and whether the hype is measuring enthusiasm or actual penetration.

My Current Take (January 2026)#

I'll update this section when pricing shifts, new agents appear, or the failure modes change. The tool names will rotate. The pattern probably won't.

Claude Code deserves its moment. It's one of the best tools in this category right now. The models powering it, Opus 4.5 and Sonnet 4, are genuinely good for coding. OpenAI's Codex CLI running on GPT-5 is also excellent. Gemini CLI being open-source is a big deal. Gemini as a model is actually quite nice to work with, and I expect Google to catch up even more.

But the deeper story isn't "which tool wins."

It's that we're watching software engineering shift from writing code to steering systems that write code.

Everyone's making the typical arguments about taste, systems thinking, architecture becoming more important. And yes, I don't disagree. But a lot of jobs are probably getting replaced regardless. The more finely scoped your work is, the better the models become at it.

The people who win won't be the ones who memorize the newest prompt format.

They'll be the ones who can look at a codebase and say:

"This is the real problem."

"This is the constraint that matters."

"This fix will create future debt."

"This system needs a different shape."

Tools will keep rotating. Claude Code will be next year's Cursor.

But that compass, the ability to look at a system and see what matters, stays.

Execution is cheap now. Judgment is the scarce resource.

Related#

• Building AI Agents with the Claude Agent SDK: When to use Claude Code vs. building your own agent. Different tools, different jobs.
• Claude Code Documentation: Anthropic's official docs, best practices, and setup guide.