I have a problem. When a new AI coding tool launches, I cannot resist trying it. January through July 2026 was an absurd stretch for new releases, and I tried basically all of them. Some with free tiers, some with my own money, and one that cost me $400 in a single week because I forgot to set a spending limit.
Here is the honest timeline of what I tried, what I thought about each one, what I dropped, and the stack I actually use today. No affiliate links, no sponsored opinions, just seven months of real usage.
January: GitHub Copilot ($10/mo)
I started the year with Copilot because that is what my team used. It was fine. The tab completions were decent, the code suggestions were relevant maybe 60% of the time, and it never got in the way. It was like a slightly psychic autocomplete.
What I liked: zero configuration, worked everywhere, rarely suggested anything harmful. What annoyed me: the suggestions were safe to the point of being boring. It would complete your pattern but never surprise you with a better approach. It felt like it was trained to be inoffensive rather than helpful.
Monthly cost: $10. Value feeling: “This is fine.”
February: Cursor Pro ($20/mo at the time)
A colleague showed me Cursor and within a day I was sold. The chat panel, the ability to select code and ask questions about it, the inline diffs, the multi-file edit capability. It felt like what Copilot should have been.
I immediately noticed I was moving faster. Not just in autocomplete, but in understanding unfamiliar code. I could highlight a function, ask “what does this do and why?”, and get a useful answer without leaving my editor.
I cancelled Copilot the same week. No point paying for both when Cursor did everything Copilot did plus more.
Monthly cost: $20 (later raised to $32). Value feeling: “This is genuinely better.”
I wrote a detailed comparison of what this actually costs long-term in my Cursor vs Claude Code monthly cost breakdown.
March: Added Aider for Terminal Work (Free + API costs)
I kept Cursor as my IDE but started using Aider for specific tasks: refactoring from the terminal, batch file changes, and working on projects where I did not want to open a full IDE.
Aider’s strength is that it works with any model through any API. I connected it to DeepSeek’s API (absurdly cheap) and used it for tasks where Cursor felt like overkill: updating config files, renaming things across a project, generating boilerplate.
Monthly cost: Cursor $20 + DeepSeek API ~$5 = $25. Value feeling: “Nice complement.”
The flexibility of model routing was a revelation. Why pay premium prices for simple tasks?
April: Tried Windsurf (Free tier, then $15/mo)
Windsurf launched with a lot of hype. “Cursor but better.” I gave it two full weeks.
Honest take: it was nice. The Cascade feature (where it plans multi-step changes before executing them) was clever. The UI was polished. But after two weeks I could not identify a single thing it did significantly better than Cursor for my workflow.
The small differences: Windsurf’s suggestions felt slightly more conservative (fewer hallucinations but also fewer “wow” moments). The project understanding was comparable. The price was slightly lower.
I went back to Cursor because the switching cost was not worth the marginal difference. If I were starting fresh and had never used Cursor, Windsurf would be fine. But “fine” is not enough to justify migrating all your muscle memory.
Monthly cost experiment: $15 for two weeks. Value feeling: “Nice but not better enough.”
May: Tried Claude Code (Mind Blown, $100/mo Max plan)
This is where things shifted. I installed Claude Code to test Opus 5 on a real project, and within an hour I was having a different kind of experience than any IDE-based tool had given me.
The difference: Claude Code thinks before it acts. It reads your project structure, understands relationships between files, and makes coordinated changes across your codebase. When I asked it to refactor an authentication module, it did not just change one file and break imports. It traced the dependency chain, updated tests, fixed type definitions, and created a migration. In one prompt.
I had never seen an AI tool handle a multi-file task that cleanly. Cursor could do multi-file edits, but you had to guide it step by step. Claude Code felt like delegating to a senior developer.
The downside: it is terminal-only, it is expensive ($100/mo for Max), and it has no autocomplete functionality. It is a completely different category of tool. I detailed the setup process because it is not obvious out of the box.
Monthly cost: Cursor $32 + Claude Code $100 = $132. Value feeling: “This is a different league for complex work.”
June: Tried Codex CLI (Impressive but Limited)
OpenAI’s Codex CLI was interesting. It is similar in concept to Claude Code: terminal-based, agent-style, reads your project. The sandboxing is aggressive though. It creates an isolated environment for each task, which is great for safety but frustrating when you need it to interact with your actual development environment.
I used it for two weeks. The output quality was decent but not as good as Claude Code with Opus 5 for complex tasks. Where it shone: simple, contained tasks where the sandboxing was an advantage. “Write a function that does X” worked well. “Refactor this module across 10 files” did not.
Monthly cost: API pricing, roughly $20 for my usage. Value feeling: “Interesting tech, not ready for my workflow.”
July: Tried Gemini CLI (Free, Quality Inconsistent)
Google’s Gemini CLI is free and that is its biggest selling point. I used it for a week. The responses were fast, the context window was huge, and for straightforward tasks it was perfectly capable.
The problem: consistency. The same prompt would give me a great answer one time and a mediocre answer the next. For code review, it would sometimes catch real issues and sometimes hallucinate problems that did not exist. I could not develop trust in it.
For a zero-dollar AI coding stack, it is genuinely useful. But I would not rely on it as my primary tool when I need predictable quality.
Monthly cost: $0. Value feeling: “Great for a free tool, not reliable enough for primary use.”
What I Dropped and Why
- GitHub Copilot: Replaced entirely by Cursor, then later by Continue.dev + local models. It does nothing that other tools do not do better.
- Windsurf: Redundant with Cursor. Not different enough to justify switching.
- Codex CLI: Too sandboxed for my workflow. Good idea, not practical yet for multi-file real-world tasks.
- Cursor: Eventually replaced by Claude Code for complex work and Continue.dev for simple edits. This one hurt because I genuinely liked Cursor.
What Stuck (My Current Stack)
Claude Code with Opus 5 ($100/mo Max plan): The primary tool for anything complex. Refactoring, debugging hard problems, implementing new features with tests, code review. This handles maybe 60% of my AI-assisted work. It is expensive but nothing else matches it for multi-file reasoning.
Continue.dev with Ollama ($0/mo): For quick inline completions, simple edits, and the tab-completion experience I missed from Cursor. Running Qwen 3.6 locally through Ollama gives me decent autocomplete without paying for a cloud service. I followed my own Continue.dev guide to set this up.
DeepSeek V4 Flash via API (~$5/mo): For quick questions, debugging simple errors, and generating boilerplate. I use this through OpenRouter so I have one API key for everything. It is dirt cheap and good enough for 80% of simple tasks. More details in my DeepSeek guide.
Aider (~$10/mo API costs): Still useful for specific terminal workflows and when I want to use a different model for a particular task. Its flexibility with model backends keeps it relevant.
Total monthly cost: roughly $135. Up from $10 in January. But the capability difference is enormous.
The Cost Evolution
| Month | Stack | Monthly Cost |
|---|---|---|
| January | Copilot | $10 |
| February | Cursor | $20 |
| March | Cursor + Aider/DeepSeek | $25 |
| April | Cursor + Windsurf trial | $32 |
| May | Cursor + Claude Code | $132 |
| June | Claude Code + Codex experiments | $120 |
| July | Claude Code + Continue.dev + DeepSeek + Aider | $135 |
The jump from $32 to $132 in May was scary. But the productivity increase was real enough that it paid for itself within the first week. I broke down the math more carefully in my fifty-dollar AI coding stack article for developers who want strong capabilities without the $100+ price tag.
What I Learned
No single tool does everything well. The tool landscape is not converging toward one winner. Different tools are good at fundamentally different interaction patterns: autocomplete, chat, agent-style execution. You need at least two.
Cost correlates with capability but not linearly. The jump from $0 to $50/month in AI tools gives you 80% of the value. The jump from $50 to $150 gives you the remaining 20%, but that 20% is the hardest stuff.
Local models are viable for simple tasks. I described this more in my local-first AI developer stack article. You do not need to send every keystroke to the cloud.
Your workflow matters more than the tool. I watched developers get more value from Copilot alone than I got from my $135/month stack, because they had better prompting habits and clearer task decomposition. The tool is maybe 30% of the value. How you use it is the other 70%.
FAQ
Is it worth trying all these tools yourself?
Probably not all of them. If I had to give advice: try Claude Code and one IDE-based tool (Cursor or Windsurf). Those represent the two main interaction paradigms. Add local models if privacy matters. Skip the rest unless you have a specific use case.
How do you avoid subscription fatigue with so many tools?
I ruthlessly cancel anything I have not used in two weeks. Most of my stack is usage-based (API pricing) rather than subscriptions, which means I only pay for what I actually use. The only flat subscription is Claude Code Max at $100/month.
What would you recommend for someone spending $0 today?
Start with Gemini CLI (free) and Ollama with Continue.dev (free). That gives you agent-style terminal AI and inline autocomplete for $0. It is not as good as paid tools, but it is dramatically better than no AI assistance at all. I wrote a full guide to this in my zero-dollar stack article.
Did any tool actively make you worse at coding?
Not worse, but I noticed a skill atrophy effect. After months of AI generating my TypeScript types, I got slower at writing complex generic types by hand. I now deliberately do some tasks without AI to keep my skills sharp.
How often does your stack change?
Every two to three months something shifts. A new model launches, a tool adds a feature, or my work changes. I expect my stack to look different by October. The key is having clear criteria for what each tool slot needs to do, so you can evaluate new options quickly.