Updated October 2026: I’ve refreshed the fast-moving details. OpenAI Codex now recommends GPT-6.1 “Sol” (it was GPT-5.4 when this first went live), and I’ve softened the Aider entry to reflect that it’s model-agnostic rather than pinned to a fixed list. The one assessment that has shifted is Codex: it’s moved from “still evaluating” to a defined complement to Claude. These days Claude handles research, development, and orchestration; Codex handles UI design exploration with its image generation, UI fixes through browser annotations, and cross-model code review. The core tier ranking of the daily code-writing tools is unchanged. One more change worth knowing: Cognition rebranded Windsurf as Devin Desktop on June 2, 2026, and retired its original Cascade agent in July 2026; the Windsurf section below reflects the product I tested. I’ve also added a note on the open-source coding agents (Pi, OpenCode, Cline, Goose) I’ll be exploring next.
TLDR; Claude Code and Cursor are tier one: Claude Code for complex multi-file reasoning and refactors, Cursor for active coding sessions. Copilot, ChatGPT, and OpenAI Codex fill narrower roles in tier two. I tested nine tools on real client projects across Rails, Python, and React before settling on this ranking.
Over the past year I’ve used every major AI coding tool on client code that had to ship.
I’m a CTO working across multiple client engagements at once: Rails backends, Python data pipelines, React frontends, JavaScript APIs. On any given day I’m context-switching between four or five codebases with four or five constraints. That is why I care about which tools hold up under load.
I’ve run Claude Code, Cursor, and GitHub Copilot as my daily drivers. I’ve properly tested Windsurf, Tabnine, Amazon Q Developer, Aider, and OpenAI Codex. I’ve used ChatGPT’s data analysis for specific tasks.
My ranking, in short:
- Tier 1: Claude Code (complex reasoning and refactoring), Cursor (active coding sessions)
- Tier 2: GitHub Copilot (background autocomplete), ChatGPT (data analysis and one-off scripts), OpenAI Codex (UI design exploration and image generation, annotation-driven UI fixes, and cross-model review of Claude’s work)
- Tier 3: Windsurf, Tabnine, Aider, Amazon Q Developer, tested, moved on
- On the radar: open-source coding agents (Pi, OpenCode, Cline, Goose), exploring next
How I tested these tools
Real projects means: Rails, Python, JavaScript/React. My clients are mid-size organisations, marketing agencies, SaaS startups, professional services firms. The work mixes new features, legacy refactoring, and integrating AI into existing products. These aren’t greenfield side projects. There’s existing code I can’t break, other developers on the teams, deadlines.
I’ve been using AI coding tools long enough to have a clear view of which ones survive repeated contact with messy real-world codebases, and which ones look impressive on a clean repo but fall apart when the context gets complicated.
No affiliate links here. No vendor relationships. I pay for these subscriptions out of my own pocket, which tends to concentrate the mind.
Tier 1: my daily drivers
Claude Code, for anything that requires actual thinking
Claude Code is my primary tool. Not because it’s the flashiest, but because it’s the one I trust when a task matters.
The default surface is the terminal. You run it from the command line, point it at your project, and it works with your codebase directly: reading files, making changes, running tests. There’s now also a VS Code extension, a JetBrains plugin, and a desktop app, though none of them adds Cursor-style inline autocomplete; they add visual diff review on top of the same agent. For developers who live in the terminal, the default feels natural. For developers who don’t, the IDE surfaces soften the adjustment period.
What it does better than everything else is multi-file changes that require understanding the relationships between parts of a system.
A concrete example. I had a client whose Rails application had a poorly designed permissions system that had been patched over with conditionals scattered across about 40 files. Untangling it manually would have taken a senior developer most of a week. I gave Claude Code a clear description of what the permissions system needed to look like, let it read the codebase, and watched it work through the refactor methodically. Tracking changes across controllers, models, views, and specs. Keeping the existing tests green. Flagging the edge cases it wasn’t sure about.
A couple of hours of back-and-forth rather than three or four days of careful manual work. The output was solid enough that I could review and ship it.
That’s the use case Claude Code dominates: changes where you need to understand a lot of context, reason across multiple files, and do something coherent. It’s also excellent at understanding an unfamiliar codebase and explaining it to you. I use it regularly to get up to speed on a client’s repo before I start making changes.
Where it falls short: speed and cost. Claude Code is slower than Cursor for quick edits, and at scale the token costs add up. It’s also not the right tool when you want AI assistance while you’re actively typing; it’s an agent, not an autocomplete layer, even inside the IDE extensions. For those tasks, I reach for something else.
I’ve also noticed it occasionally over-engineers solutions, proposing a clean architectural change when a simpler fix would do. Not a dealbreaker, but you need to stay engaged and push back. Treat it as a capable junior who needs steering, not an autonomous agent you can walk away from.
If you want a deeper look at how I’ve integrated it into my workflow, see how I use Claude Code across six client projects, or the full setup in the Claude Code Playbook.
Cursor, for active coding sessions
Cursor is the other tool I use every day, and it fills a different role.
Cursor is an IDE, a fork of VS Code with AI baked in at every level. Tab autocomplete, inline suggestions, a chat panel that knows your current file, the ability to select code and ask it to rewrite or explain. It feels like coding with a fast, capable pair programmer looking over your shoulder.
Where Claude Code requires you to describe a task and step back, Cursor works alongside you while you’re actively writing code. The autocomplete is good. Not “completes the rest of the line” good. “Generates the next ten lines you were about to write” good. When I’m in flow state and building something new, Cursor reduces friction in a way that’s hard to quantify but easy to feel.
Real example: I was building a new API endpoint for a client, fairly standard Rails work. With Cursor, I wrote the route, and by the time I’d opened the controller file, it had autocompleted the method signature. I wrote the first few lines of logic and it completed the service object call I was about to write. Not magic, it got things wrong about a quarter of the time, but the hits outnumbered the misses enough that my speed was higher.
The chat panel is also useful for the kind of quick questions that would otherwise break flow. “What’s the Rails way to do X?” or “Can you rewrite this method to be more readable?” Tasks where you want an answer immediately and don’t need the deep codebase reasoning Claude Code provides.
Where Cursor falls short: it’s less capable on complex multi-step tasks that require holding a lot of context. When I’ve asked Cursor to do the kind of large-scale refactoring I described above, it tends to get partway through and lose the thread. The inline workflow also keeps you in the driver’s seat, which is great when you want it; if you’re trying to hand off a task and do something else, Claude Code is a better choice.
Cursor also has a habit of confidently generating code that looks right but has subtle bugs, especially in Rails where there are a lot of conventions and magic. You still have to review everything it writes.
Tier 2: good for specific tasks
GitHub Copilot, the background assistant
Copilot occupies a particular niche in my toolkit: it’s always there and it requires almost nothing from me.
I have it running in VS Code as a secondary autocomplete layer. Not as capable as Cursor’s suggestions, but lighter, it doesn’t change how I work, and it occasionally surfaces something useful when I haven’t actively invoked any AI tool. The autocomplete you get without trying.
Copilot was impressive when it launched, and the newer generation of tools has lapped it on raw capability. The completions are fine but often generic, it doesn’t understand your project conventions the way Claude Code or Cursor does. It also has a tendency to confidently complete code in ways that work syntactically but aren’t quite right for your specific context.
Copilot’s in-IDE agent mode has matured fast since its 2025 rollout, with a JetBrains update in March 2026, and the separate cloud Coding Agent that replaced the half-built Workspace went GA in September 2025. I’ve used agent mode on a handful of small tasks. It’s competent. It hasn’t displaced my Claude Code + Cursor workflow yet, but it’s a real product now.
I keep regular Copilot on because the cost is low, the friction is near-zero, and I don’t have to think about it. For developers who aren’t ready to change their workflow but want some AI assistance, Copilot is the right starting point. It’s also the right choice if your team is in an enterprise environment with security constraints that rule out the newer tools.
What it’s good for: boilerplate, standard library usage, common patterns. What it’s weak on: anything that requires understanding your specific codebase.
ChatGPT, for data analysis and one-off scripts
ChatGPT doesn’t fit neatly into the “AI coding tool” category. It’s a general-purpose AI that happens to be good at code. There are specific scenarios where I reach for it over everything else.
Advanced Data Analysis (the renamed Code Interpreter) is excellent for data analysis tasks. If a client sends me a spreadsheet and asks me to figure out what’s going on with their numbers, I’ll paste it into ChatGPT and ask it to analyse and visualise. Exploratory data work, “tell me what’s interesting in this dataset”, is something ChatGPT handles naturally in a way the coding-specific tools don’t.
I also use it for one-off scripts that have nothing to do with my main client projects. Need a quick Python script to batch-rename some files? A SQL query to answer a specific question? ChatGPT is fast, already open in my browser, and I don’t need to spin up a coding environment.
For a broader Claude vs ChatGPT comparison across all use cases, I’ve written about that more fully in Claude vs ChatGPT: a practitioner’s take.
OpenAI Codex, found its lane
OpenAI relaunched Codex in 2025 as a cloud-based autonomous coding agent, and through 2026 it has grown a desktop app, an embedded browser, and built-in image generation. It works against your GitHub repos: you describe a feature or fix, Codex spins up a worktree in the cloud, makes the changes, and opens a PR. As of October 2026 OpenAI recommends GPT-6.1 “Sol” for Codex (GPT-6 “Astra” is its most capable model), with parallel work-stream support and a CLI for terminal users.
When I first wrote this, Codex was filed under “still evaluating.” It has since settled into a defined set of roles, none of which is “replace Claude Code.” The split I run now: Claude for research, development, and orchestrating the work; Codex for UI design exploration, UI fixes, code reviews, and image generation.
The design exploration runs on Codex’s built-in $imagegen skill, backed by OpenAI’s image model. OpenAI documents the image generation system here. In my use, its text rendering is clean enough to produce comps, labelled diagrams, and finished image assets rather than lorem-ipsum placeholders. I shape the visual direction there, then hand the chosen design to Claude Code for the research, content, and implementation. For UI fixes, the annotation mode in Codex’s embedded browser changed how I give feedback: instead of writing “move the CTA up and make the heading heavier,” I select the element on the rendered page and write “move this up.” Each annotation round is cheaper and less ambiguous than describing a screenshot in prose.
The third role is cross-model code review. I use Codex as an independent second model to red-team Claude’s work: an adversarial pass over a design or a diff, briefed to attack assumptions rather than nod along. Because it doesn’t share Claude’s blind spots, it catches a different class of problem, on one backend engine it flagged a set of over-builds Claude and I had both waved through; on a Rails codebase it caught a denial-of-service vector and a silent wrong-results bug. I cover the mechanics in the quality gates guide.
OpenAI now ships an official plugin, codex-plugin-cc, that runs Codex from inside Claude Code and exposes review, adversarial-review and delegation commands. The repository supports the mechanics of this split, but it does not prescribe “Claude plans, Codex reviews” as the canonical workflow. That division is mine. The one live disagreement among practitioners is design taste: some designers find Claude better when a model is writing the UI code itself. My split sidesteps that argument, Codex owns the visual exploration and the annotate-and-fix loop, Claude owns the build.
So it’s still not a tier-one daily driver the way Claude Code and Cursor are, but “evaluating” is long past. It’s a deliberate complement with a defined lane.
Tier 3: tried and moved on
Windsurf (now Devin Desktop)
Update (July 2026): Cognition rebranded Windsurf as Devin Desktop on June 2, 2026 (same product, plans and settings carried over), and retired its original Cascade agent in July 2026, replacing it with a new in-house agent called Devin Local. I haven’t tested the new agent yet; the assessment below reflects the Windsurf/Cascade era I used.
Windsurf was Codeium’s AI IDE, positioned as a direct competitor to Cursor. The acquisition picture has been turbulent, OpenAI’s planned acquisition fell through, Google licensed the tech (and acqui-hired the CEO), and Cognition AI (the makers of Devin) acquired Windsurf in July 2025. Under Cognition, it shipped with their proprietary SWE models, which are fast.
I spent about three weeks using it seriously before the Cognition acquisition. It was good, and if Cursor didn’t exist I’d probably use it. Cursor exists. Windsurf was slightly less polished in the areas I use most. The autocomplete suggestions felt marginally less accurate on my Rails codebases, and the chat integration less fluid.
The rebranded Devin Desktop is worth a fresh look, I haven’t done that yet, but at the time I tested, the gap to Cursor wasn’t worth switching for. Devin’s Pro plan is $20/month; Cursor’s plans now run from $8 (Plus) to $200 (Ultra).
Tabnine
Tabnine was one of the early AI autocomplete tools and still has a strong position in enterprise settings where data privacy matters. It runs on-premises. For the work I do, that’s not a relevant constraint, and the suggestion quality hasn’t kept pace with the newer tools. I tested it for a fortnight and went back to Copilot for the same background-autocomplete role. For teams with strict data residency requirements, Tabnine is worth a look. For everyone else, there are better options.
Aider
Aider is an open-source terminal-based AI coding assistant. For a specific developer, someone comfortable in the terminal who wants full control without a subscription, it’s interesting. The architecture is similar to Claude Code in some ways: run from the command line, reads your codebase, you describe what you want. It’s effectively model-agnostic, supporting current Claude, GPT, Gemini, and DeepSeek releases (and most other LLMs via API), so the model choice is yours.
I used it before Claude Code existed. Once Claude Code launched, I moved over and haven’t looked back. The model quality matters a lot in this category, and Claude Code has the integration polish that Aider doesn’t. Aider’s strength is being free and open source. Its limitation is that the experience depends on what you plug in.
Amazon Q Developer (formerly CodeWhisperer)
Amazon renamed CodeWhisperer to Amazon Q Developer in 2024 and broadened the scope: it’s now a full AWS developer assistant rather than just an autocomplete tool. I tested the older version because two of my clients run on AWS infrastructure and I thought it might have useful cloud-specific awareness. The suggestions were mediocre on my Rails and Python work. It performs better on AWS SDK calls, which makes sense given the training data, but that’s a narrow use case. I haven’t re-tested under the Q Developer brand. Amazon closed Q Developer to new sign-ups on May 15, 2026 and ends support on April 30, 2027; Kiro is its successor. If your work is AWS-heavy, evaluate Kiro; if it isn’t, the other tools in this list are stronger general-purpose options.
On my radar: open-source coding agents
Everything in the tiers above is a commercial product. The open-source side of the field has matured fast enough through 2026 that it deserves its own note, and it’s the area I’m exploring next. I haven’t run these on client work yet (Aider aside, covered above), so read this as why they’re interesting rather than a tested verdict.
Pi is the one I’m starting with. Built by Mario Zechner, the developer behind the libGDX game framework, and now maintained under Earendil, it’s a deliberately minimal terminal harness: a small set of built-in tools (read, write, edit, bash), a tiny system prompt, and everything else added through TypeScript extensions the agent can write for itself. It runs entirely locally against whichever model provider you point it at, with no cloud backend, and has grown past 110,000 GitHub stars. The appeal for me is transparency: when the harness is small enough to read in one sitting, you can see exactly what the model is being asked to do, which is the opposite of the direction the commercial tools are trending.
OpenCode is the feature-heavy counterpoint, and by stars (past 200,000) the most popular open-source harness going. It’s the closest thing to a self-hosted Claude Code alternative: a polished terminal UI, multi-model support, and a large plugin surface. Where Pi bets that a harness should be small enough to understand, OpenCode bets that it should do everything the commercial tools do without the lock-in.
Cline is the VS Code option, notable for treating permission gates as a feature: every command needs approval unless you’ve pre-authorised it, which is friction that doubles as safety on a codebase you care about. Goose, which came out of Block, sits at the more autonomous end, planning and iterating with less hand-holding, and is built for extension through custom tools and MCP.
Why bother when Claude Code already earns its keep? Three reasons. Model flexibility: an open harness can point at any provider, including open-weight models, which matters as clients start asking about data residency. No lock-in: the workflows in this post survive a vendor pricing change only if the habits transfer. And harness design itself: I orchestrate agents for a living now, and watching how Pi’s few-hundred-word system prompt performs against the heavyweight commercial prompts is the kind of lesson that feeds back into my own sub-agent briefs. If any of these earns a place in the daily stack, this post gets another update.
How to choose
Here’s the decision I’d give to any developer asking me:
Complex changes across multiple files, refactoring, understanding an unfamiliar codebase: Claude Code. Nothing else comes close when the task requires reasoning about a lot of context at once.
Active coding session, inline suggestions, fast iteration on new features: Cursor. This is the tool that makes you feel like you’re going faster in real time.
Low-friction autocomplete without changing your workflow: GitHub Copilot. Lowest activation energy, lowest reward, still a net positive.
Data analysis, one-off scripts, quick questions: ChatGPT. For anything exploratory where you don’t want to spin up a coding environment.
UI design exploration, annotation-driven UI fixes, cross-model review, and image generation: OpenAI Codex. Not my code-writing daily driver, but the second model I red-team Claude’s work with, and where I explore visual direction and mark up UI fixes before handing the build back to Claude Code.
You’re not a developer but need to write or understand code: ChatGPT or Claude in browser. The terminal-first tools require technical comfort that non-developers often don’t have.
One thing I’d say to anyone starting out: don’t try to use all of them at once. Pick one, use it seriously for a month, understand its limits, then decide if you need something else. The learning curve isn’t in the tool. It’s in developing the judgment to know when to use it and when to write the code yourself.
If you’re working out how to integrate AI tools into your development practice, or you want a technical leader who can make these decisions for your team, that’s what I do. Happy to have a conversation about what makes sense for your situation.
Common questions
What is the best AI coding tool in 2026?
For my daily work it is Claude Code, with Cursor close behind for in-editor edits and Copilot useful for inline completion. There is no single winner: the right tool depends on whether you want an autonomous agent, an AI-native editor or fast autocomplete. I rank them by what I actually reach for on client projects, not by feature lists.
Is Cursor or Claude Code better?
They solve different problems. Cursor is an AI-native editor built for fast, in-file edits with tight human control. Claude Code is an agent that plans and executes multi-step work across a repo, terminal-first with IDE and desktop surfaces on top. I use Claude Code for larger changes and Cursor when I want to stay hands-on in the editor.
How should you choose an AI coding tool?
Start from the work, not the hype. Decide whether you need autonomous multi-step execution, in-editor assistance or inline completion, then trial two tools on real tasks for a week. The best tool is the one that fits your workflow and codebase, which is why I test them on actual client work before ranking them.