Which AI tool should you use? A guide sorted by the job, not the brand

Most "best AI tools" lists are sorted by brand: ChatGPT, then Claude, then Gemini, then Copilot, each with a paragraph of features and a star rating. That's the wrong way round for anyone trying to get work done. You don't sit down wanting to "use Gemini". You sit down wanting to fix a bug, understand an error, or get a rough UI on screen before a call. The job comes first, and the tool follows from it.

So this post is sorted by job. For each one I'll say what kind of tool fits, which ones I actually use for it, and where I've seen people (me included) pick the wrong one. At the end there's a simple method for comparing tools on your own code, which matters more than anything a list like this can tell you.

One disclaimer up front. I use Claude and Claude Code, ChatGPT and Codex, and Cursor and Copilot regularly. I've only tried the others, so where I mention them I'll say so instead of pretending to have an opinion.

The short answer

If you only remember one row, make it the third one. Most of the frustration I hear about AI tools comes from asking a chat app to do an agent's job.

Why sort by job instead of by brand

Two reasons.

First, the brands overlap. ChatGPT has an agent (Codex). Claude has an agent (Claude Code). Cursor and Copilot both have chat panels and agent modes as well as completion. Comparing "ChatGPT vs Claude" tells you very little, because each name covers three or four different products that are good at different things.

Second, the categories change slowly and the features change fast. Any table of model versions and prices is out of date within a few months. The difference between autocomplete, a chat window and an agent that runs your tests has held up for a couple of years now, and I expect it to keep holding.

Job 1: typing faster inside a file

This is inline completion: grey "ghost text" that appears as you type and that you accept with Tab. No prompt and no conversation. The tool watches what you're writing and guesses what comes next.

Use it when you already know what you're writing and want to write it faster. Boilerplate, the fifth similar test case, a mapping function whose shape is obvious from the line above.

What I use: Cursor's Tab when I'm in Cursor, Copilot when I'm in plain VS Code. Cursor's version is the more ambitious one. It predicts your next edit, not just the next few characters, and jumps to the line it thinks you'll change next. I went into this in detail in Claude Code vs Cursor, but the short version is that if fast in-editor completion is most of what you want, this category is the one to pay for.

Where it goes wrong: completion is confident and has no idea whether it's right. It will happily write a plausible function call with the arguments in the wrong order. Read what you accept, especially in code you don't know well, because that's exactly where you're least able to spot a wrong guess.

Job 2: thinking out loud

This is a chat app: Claude.ai, ChatGPT, Gemini. You paste something in or describe a problem, and you talk it through.

Use it when the output you want is understanding, not a change to your repo:

• An error message you don't recognise, along with the code around it.
• "Should this be a server action or an API route?" style design questions.
• Learning a library or a concept, with follow-up questions in your own words.
• Writing that isn't code: a PR description, a reply to a client, a rough outline.

What I use: both Claude.ai and ChatGPT, and for this job the choice between them is mostly habit. Both are good at explaining things, and if you only pay for one, you won't be badly served by either.

What makes a bigger difference than which app you use is keeping related work in one place. Both have a "project" feature where you can attach files and standing instructions, so you don't re-explain your stack every time.

Where it goes wrong: using chat for a change that spans several files. You paste in one file, get an edit back, paste it into your editor, realise it broke an import somewhere else, paste that file in too, and twenty minutes later you're the one doing all the coordinating while the AI only sees whatever you remembered to give it. That's the moment to switch to an agent.

Job 3: changes bigger than one file

This is a coding agent: Claude Code, OpenAI's Codex, Cursor's Agent mode, Copilot's agent mode. The difference from chat is that an agent can read your repo itself, edit several files, run commands like your test suite, look at the result and try again. You review what it did instead of carrying code back and forth.

Use it when the task needs more than one file or needs checking against reality:

• "Rename this prop everywhere and fix the types."
• "This test fails on CI but not locally, find out why."
• "Add a field to this form, the API, and the database schema."
• Reading an unfamiliar codebase and explaining how a feature is wired.

What I use: Claude Code is my default for this, for reasons I covered in the Claude Code guide: plan mode, a CLAUDE.md file that holds project rules, and the fact that it runs in the terminal so it works with any editor. I've used Codex as well, and the basic loop is the same: describe the task, let it work, review the diff. If you already pay for ChatGPT, Codex is the obvious one to try first, and the same goes for Claude Code if you pay for Claude. Those plans include the agent, so trying it costs nothing extra.

Where it goes wrong: two ways, in opposite directions.

• Too small a task. Asking an agent to change one string is slower than changing it yourself. It'll search the repo, read files and maybe run something before making a one-character edit.
• Too vague a task. "Improve the dashboard" gives an agent permission to touch everything. Agents work best with a clear goal and a clear way to know when it's done ("the test in orders.test.ts passes"). Without that, you get a big diff that's hard to review.

Job 4: answers you need to trust

Sometimes you don't want an opinion, you want a fact with a source: what a library's current API looks like, whether a browser supports a feature, what a law or a pricing page actually says.

A chat app answering from memory is the wrong tool for this, because its training data has a cut-off date and it can't tell you when it's guessing. You want something that searches the web and shows you where each claim came from. ChatGPT and Claude both do this when search is turned on. Perplexity is built around it. I haven't used Perplexity enough to compare it fairly, so I won't.

What I do: ask with search on, then open the two or three links it cites and check the claim in the source. That last step isn't optional. Search-backed answers are much better than answers from memory, but I've still seen them summarise a page wrongly or cite an old version of the docs. The citation is there so you can check it, not so you can skip checking.

Where it goes wrong: treating "it gave me a link" as "it's correct". Read the link.

Job 5: a UI from nothing

App builders like v0, Lovable and Bolt take a description and give you a working front end, often with hosting included. I'll be upfront: I haven't used these seriously, so I can't rank them against each other.

What I can say is where they fit, based on what they produce. They're good for a clickable prototype you'll show someone and then throw away, or for a non-developer who needs a simple internal page. They're risky as the start of a product you'll keep. You inherit code you didn't write and don't know well, often with decisions baked in (styling, state, data fetching) that you'd have made differently.

If you're a developer, a coding agent in an empty repo with a clear brief gets you something similar, in a structure you chose.

Where people pick the wrong tool

The same mistakes come up again and again:

1. Chat for multi-file work. Covered above. If you're copying code between a browser tab and your editor more than twice for one task, use an agent.
2. An agent for a one-line fix. Just make the edit.
3. Memory for facts. Anything version-specific, price-specific or date-specific needs search and a source.
4. A prototype as a foundation. Fine to show, worth rebuilding before you depend on it.
5. Overlapping subscriptions. Paying for three chat apps that all do Job 2 equally well, while not having an agent at all.

How to compare AI tools yourself

Every comparison online, this one included, was done on someone else's code with someone else's habits. The only comparison that tells you which tool suits you is one you run on your own work. It doesn't need to be elaborate. Here's the method I use.

1. Pick three real tasks from your backlog. Not toy problems. Something like:

• a small bug fix you already understand,
• a change that touches three or more files,
• a question about a part of the codebase you don't know well.

Real tasks matter because every tool looks good on "write a function that reverses a string".

2. Give every tool the same starting point. Same commit, same prompt, word for word. Git worktrees make this easy. Each tool gets its own folder on its own branch, all from the same commit, without stepping on each other:

git worktree add ../try-claude-code -b try/claude-code main
git worktree add ../try-codex -b try/codex main
git worktree add ../try-cursor -b try/cursor main

Open each folder in its tool, paste the identical prompt, and let it run. When you're done, git diff main in each folder shows exactly what each tool changed, and git worktree remove ../try-codex cleans up.

3. Score what matters, not what's impressive. I use a small table like this per task:

"Minutes I spent fixing its output" is the number I trust most. A tool that's 80% right and easy to correct often beats one that's 95% right but makes a sprawling change you have to untangle.

4. Run each task twice. These tools don't give the same output every time. One great run or one bad run tells you very little. If two runs disagree a lot, that tells you something too.

5. Write the date down. Tools update every few weeks. A comparison from six months ago is a historical document. Keep your notes with the date and the tool version, and rerun the same three tasks when something big ships. That's the main advantage of using real tasks: you can repeat them.

If you're paying for one thing

If budget means one subscription, I'd pick a chat plan that includes a coding agent: Claude's paid plans include Claude Code, and ChatGPT's paid plans include Codex. That covers Jobs 2, 3 and most of 4 for one price. Add an editor with good completion only if you find yourself typing a lot of code by hand. Leave app builders until you have a specific prototype in mind.

Then run the three-task comparison above before committing to anything annual. An afternoon on your own code is worth more than any ranking, including mine.

Frequently asked questions