You Don't Need Claude Code

Every day, without fail, I see posts from developers optimizing their Claude Code token usage. Tips for reducing context size, tools to monitor spend, vibe-coded dashboards to track prompt costs. And woven through all of it is a quiet assumption that goes almost entirely unchallenged: that Claude Code is the only serious option for vibe coding today.

I’ve been using GitHub Copilot as my sole AI assistant since I left Cursor, and I’ve been genuinely happy. Which prompts the question: why do so many developers seem to treat Claude Code as the only viable tool in the space?

How I Got Here

Cursor was my first AI coding assistant, back in the Claude 3.5 Sonnet era. In those days GitHub Copilot was genuinely underwhelming, and the Cursor + Sonnet combination was remarkable. I built a lot of good software with it, and I was happy.

Then Cursor changed their pricing strategy — moving away from something sensible into the kind of obscure, tiered model that requires a spreadsheet to understand. I’m not interested in spending mental energy thinking about which request tier I’m on. I moved to GitHub Copilot and never looked back.

The Billing Model That Actually Makes Sense

GitHub Copilot Pro starts at $10 per month. That’s your base. If you exceed your included premium request allowance, additional requests are billed at $0.04 each — so there’s no hard wall, no waiting for a reset, no anxiety about running out mid-task. You use what you use and pay for it.

My monthly bill has never exceeded $100. I use Copilot daily, from morning until I go to sleep, for both professional and personal coding work, writing, and everything in between. I never think about token optimization. I never think about context budgets. The billing just happens in the background, proportional to what I actually used.

Compare that to Claude Code, where a Claude Pro subscription ($17–20/month) includes Claude Code access but with usage limits that reset monthly. If you’re a heavy user, you will hit them. The next tier up is Claude Max, which starts at $100/month for 5x more usage — and Anthropic’s own cost data puts average enterprise developer costs at $150–250 per developer per month. That is a significant number, and it explains exactly why there is an entire cottage industry of Claude Code token optimizers.

Being forced to wait for your usage limit to reset is, to me, genuinely unacceptable for serious vibe coding. Sometimes I need to build a lot and fast. Sometimes I’m asleep during the reset window, which makes the whole thing feel almost comical. My payment model of choice for any tool is pay-as-you-go, and Copilot’s model — $10 base, then metered — is the closest thing to that in this space.

Multiple Models, One Bill

Another thing Copilot does well that gets less attention than it deserves: it gives you access to models from multiple providers under a single subscription. OpenAI, Anthropic, Google — you can switch between them, or let Copilot choose for you. In practice, I even notice Copilot routing lighter exploration tasks to more cost-effective models automatically (I’ve seen Claude Haiku handle low-stakes code searches before handing off to a heavier model for the actual implementation). This is sensible orchestration that happens without any manual tuning.

On Agent Teams and Subagents

Here’s where I think a lot of the Claude Code enthusiasm comes from: advanced agentic features. And I want to be precise about what I actually think of them.

When I say “subagents,” I’m not talking about the predefined background agents that Copilot already uses internally — those are table stakes. I’m talking about custom-defined subagents you author yourself, with specified tools, models, and instructions. This already exists in GitHub Copilot. You can define custom agent files that run as subagents within VS Code, control which tools they access, specify which model they use, and orchestrate coordinator-and-worker patterns. It’s documented and available today, albeit still experimental.

Claude Code goes a step further with agent teams: multiple fully independent Claude Code sessions that each maintain their own context window, share a task list, and can message each other directly. The team lead orchestrates, teammates self-coordinate. It’s a genuinely interesting architecture — and it’s also disabled by default, experimental, requires setting CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, and uses dramatically more tokens than a single session (by their own cost documentation, around 7x more when teammates run in plan mode).

Agent teams are not yet available in Copilot. But here’s my honest view: for most vibe coders, they don’t need to be. Not yet.

Why? Because all current frontier models make bad decisions without steering. Every experienced vibe coder I know continuously nudges their agent toward better tool choices, better architectural decisions, better overall strategy. Putting agents in complete autopilot mode — whether it’s a Claude Code session running overnight or a team of collaborating instances you’re not watching — will almost always produce suboptimal results. The capability is real, but the reliability isn’t there yet. The value of these features right now is highest for teams that have enough experience to monitor and correct them, which is a narrow audience.

If you are in that audience — an experimental team building something that genuinely benefits from multi-agent coordination and inter-agent communication — Claude Code’s agent teams are the more powerful option today, and the cost premium may be worth it.

If you’re not, you’re paying for complexity you won’t use.

A Note on the Copilot CLI

For people coming from a Claude Code background, Copilot also has a CLI equivalent — and it includes a /fleet command that lets you break a large task into parallel subtasks executed by subagents. You can specify which models to use for individual subtasks and reference custom agent profiles for specialized work. It’s the closest Copilot CLI analogue to Claude Code’s parallel execution patterns.

I don’t personally use it — my current workflow doesn’t call for it — but if you’re coming from Claude Code and this kind of automated task decomposition is part of your practice, it exists and it’s worth knowing about. The same caveat about premium request usage applies: each subagent interaction counts, so /fleet will use more than a single sequential session.

On Cursor

I’ll keep this short: I don’t mention Cursor in the same breath as these tools anymore. It was useful as a learning environment when Copilot lagged behind. But the core of Cursor has always been VS Code with integration layers on top, and the integration layers aren’t the hard part. With the apparent development of a new version moving away from VS Code as its foundation entirely, I think Cursor is heading toward becoming harder to justify, not easier. A wrapper fighting an identity crisis.

On Context Windows

One last point that often comes up: Claude Code’s context window is larger than Copilot’s. This is true, but I think its practical importance is overstated.

The limiting factor in long agentic sessions isn’t the context ceiling — it’s the model’s behavior as that context fills up. Every AI assistant gets progressively worse as context grows. Both Claude Code and Copilot handle this through compaction: summarizing older conversation history so the active context stays manageable. The specific ceiling size matters less than your prompting strategy and how you structure tasks. If your overall approach is bad, a larger context window doesn’t save you. It just defers the problem slightly.

The Point

Claude Code is not the only viable tool for vibe coding. For most people — technical or not — GitHub Copilot is a serious alternative, and its billing model is genuinely better: a $10 base that scales with usage instead of a hard monthly cap that punishes you for working too much.

Unless you have a specific and well-understood need for Claude Code’s most experimental agentic features, or you genuinely have no cost constraints at all, I think you’d be better off trying Copilot. The grass may not always be greener, but it’s considerably cheaper — and in my experience, it’s green enough.

If you’re a heavy Claude Code user, I’m curious: is there something beyond the agent teams that you find genuinely irreplaceable compared to what Copilot offers today? I’d love to hear it in the comments.