You already use Claude Code in your terminal. So why would you pay $20/month for something else — and if you should, which one?

The Three Tiers

Andrej Karpathy coined “vibe coding” in early 2025 — describe what you want in English, let AI generate and iterate on the code. Simple idea, but it fractured the tooling landscape into three fundamentally different categories. They’re not quality rankings. They’re architectural choices that determine what kind of work each tool is actually good at.

CLI-Native Agents: The Terminal Is the Interface

Key tools: Claude Code, Aider, GitHub Copilot CLI

Here’s what a Tuesday morning looks like with Claude Code. You open your terminal in a project you’ve been building for two weeks. You type:

“Add rate limiting to the /api/upload endpoint. Use a sliding window, 100 requests per minute per API key. Add tests.”

Claude Code reads your project structure, finds your existing middleware pattern, writes the rate limiter to match your conventions, adds it to the route, creates test files, and runs them. You git diff, scan the changes, and commit. The whole exchange takes four minutes.

Now compare: you could have written that yourself. You know how rate limiting works. You’ve done it before. But here’s the thing — the agent just saved you twenty minutes of boilerplate while matching your existing patterns automatically. You didn’t open a browser, didn’t leave your terminal, didn’t context-switch. The code reads like you wrote it because the agent learned your style from the rest of the repo.

Why this tier exists: Maximum control, minimum overhead. No GUI layer between you and the code. You manage your own git workflow, pick your own editor, keep your own opinions about project structure. The agent respects all of it.

Who this is for: People who already have a setup they like and want the AI to be a powerful assistant within it, not a replacement for it.

Cost: Claude Code uses your Anthropic API subscription or Claude Pro/Max plan. Aider is open-source and works with any provider’s API keys.

Limitations: No visual diff review — you’re reading terminal output or running git diff. No inline completions while you type. The feedback loop is conversational, not real-time. For a lot of work, that’s fine. For some work, it’s genuinely slower.

AI-Enhanced IDEs: Seeing What the AI Sees

Key tools: Cursor ($20/mo), Windsurf ($15/mo)

These are VS Code forks with AI wired into everything — inline completions, multi-file orchestration, and visual tools for reviewing what the AI wants to change before it changes it.

Let me make the case with a specific scenario. You’ve inherited a Django project with 200+ files. You need to rename a model field that’s referenced in serializers, views, templates, tests, and two management commands. In Claude Code, you’d ask for the rename, get a diff, and review it in the terminal — scrolling through changes to files you’ve never opened, hoping you catch the one reference that matters. In Cursor’s Composer, you describe the same rename, and the IDE shows you every proposed change as a visual side-by-side diff, file by file. You click through them, reject the one that looks wrong, accept the rest. You see the blast radius.

That visual feedback loop is the whole value proposition. It’s not about the AI being smarter — it’s the same models under the hood. It’s about the review experience.

What they actually feel like in practice:

Cursor’s “Tab” feature is not autocomplete. It’s a diff predictor. It watches your editing pattern and proposes the next change you’re likely to make, including lines you haven’t touched yet. You’re renaming a variable in one function, and Tab offers to rename it in the next three functions too. You hit Tab, Tab, Tab. It feels like the editor is reading your mind. When it’s right — which is often — it’s genuinely magical. When it’s wrong, you just keep typing and it adjusts.

Windsurf’s “Cascade” keeps a persistent understanding of your codebase across sessions. It remembers file relationships you haven’t explicitly told it about. Its “Fast Context” feature retrieves relevant code from large repositories 10x faster than competitors. If your codebase is over 50K lines, you feel this immediately — the AI’s suggestions are more accurate because it actually found the relevant context instead of guessing.

The honest case against paying:

Here’s where it gets uncomfortable. A rigorous study by METR (July 2025) found that experienced developers using AI IDEs like Cursor were 19% slower on real tasks — while believing they were 20% faster. Read that again. A nearly 40-percentage-point gap between perception and reality.

The explanation matters: these tools encourage a “generate and review” workflow. For code you already know how to write, that loop — generate, read, evaluate, accept or reject, fix the parts it got wrong — is slower than just typing. The overhead of reviewing AI output exceeds the time saved generating it. The tools help most when you’re outside your comfort zone, working in unfamiliar territory where “think and type” isn’t an option because you don’t yet know what to type.

An important update: METR published a February 2026 follow-up noting they’re redesigning the experiment. The reason? 30-50% of developers now refuse to complete tasks without AI tools, creating selection bias that makes a clean control group nearly impossible. The original finding isn’t retracted — but the study’s own authors acknowledge conditions have changed enough that replication is needed. The “experienced developers were slower” claim now has an asterisk, though the core insight about perception vs. reality likely holds.

This means the value of a $20/month IDE subscription depends heavily on what percentage of your work is familiar vs. exploratory. If you’re mostly building things you’ve built before, the subscription might make you feel faster while actually slowing you down. If you’re regularly diving into new codebases, new frameworks, new languages — that’s where the visual feedback loop and persistent context genuinely earn their keep.

Cost reality: Cursor restructured pricing in mid-2025 with tier changes that frustrated users. Windsurf was acquired by OpenAI for $3B in May 2025 — continued investment is likely, but so are questions about future pricing and lock-in.

Prompt-to-App Builders: From Idea to URL in 30 Minutes

Key tools: Bolt.new, Replit Agent, Lovable, Base44

You type “Build me a project management app with user auth, a kanban board, and Stripe integration.” In 20-30 minutes, you have a working application with a live URL. You iterate by describing changes in English.

The speed is real. The quality ceiling is also real.

These platforms consistently produce ~60-70% solutions. The code works but has opinions you didn’t choose — Bolt defaults to React + Tailwind + Supabase for everything, code quality hovers around 6/10, and migration off the platform ranges from painful to impractical.

Who this is for: Validating ideas before investing real development time. Client demos. Personal tools where “good enough” is the spec. Learning what’s possible before committing to building it properly.

The smart workflow: Prototype in a Tier 3 builder, validate the concept with real users, then rebuild in Claude Code or Cursor for production. The tools complement each other more than they compete.

Platform comparison:

The market is expanding fast — Mocha (zero-config database/hosting/auth) and Wix Harmony (launched January 2026, hybrid vibe coding + visual editing) are notable new entrants. Base44 was acquired by Wix in 2025.

When to Leave Your Current Setup

If you’re using Claude Code in the terminal, here’s when something else earns its place:

Stay with Claude Code when:

• You understand the architecture you’re working in
• Your projects are small-to-medium (under ~50K lines)
• You value control over convenience
• You’re building for yourself, not demoing for clients
• Reviewing changes via git diff doesn’t slow you down

Add Cursor or Windsurf when:

• You’re regularly working in codebases you didn’t write
• You’re doing refactors that touch 10+ files and want to see the blast radius
• You want inline completions while typing, not just on-demand generation
• You’re spending most of your time in unfamiliar territory — that’s where the METR data says these tools actually help

Use Bolt/Replit/Lovable when:

• You want to test an idea in 30 minutes, not 3 hours
• You need a clickable prototype for someone else to evaluate
• The project is genuinely throwaway
• You’re exploring what’s possible in technology you don’t know yet

The key insight: These tools layer, they don’t replace. Many developers use Claude Code for serious work, Cursor for exploration, and Bolt for quick prototypes — switching based on what the task demands, not brand loyalty.

What the Research Actually Means for You

The METR finding is worth sitting with a bit longer. Experienced developers, measurably slower, while convinced they were faster. It’s not that the tools are useless — it’s that the value isn’t where most people assume.

AI coding tools don’t make you type faster. They make you explore faster. New language, new framework, inherited codebase, unfamiliar pattern — that’s where the generate-and-review loop beats staring at documentation. When you already know what to type, that same loop is overhead.

The practical move: use AI tools for exploration and unfamiliar territory. Use your own expertise for the parts you know cold. The best workflow switches between modes based on what the task actually needs, not what feels most futuristic.

Further Reading

These are optional — the material above covers what you need. Use these if you want to go deeper on a specific platform.

Previous: Module 01 — Prompting That Actually Works | Next: Module 03 — Spec-Driven Development