AI Coding Tools for Side Projects, Compared

AI coding tools went from novelty to default tooling fast, but they’re not interchangeable. Each optimizes for a different point in your workflow, and mixing them up wastes more time than people expect.

Inline autocomplete is basically solved

GitHub Copilot and similar tools live in your editor and predict the next few lines as you type. Lowest friction of the three categories, no separate workflow, you keep typing and accept with a tab press. They’re genuinely good at boilerplate: CRUD handlers, test scaffolding, config files you’ve written a hundred times.

Where they fall short is anything needing whole-codebase understanding. They predict locally, based on surrounding code, not globally. Ask one to rename a concept across a dozen files and you’ll get inconsistent, half-finished results. That’s not a knock on the tool, it’s just not the problem this category solves, and it never will be with this architecture.

Agentic assistants are where the actual leverage is

Claude Code, Cursor’s agent mode, and similar tools go further: given a task description, they read multiple files, make a multi-file change, run your tests, and iterate on the results. Closer to delegating a task than accepting a suggestion.

This matters more for side projects than for teams, because the bottleneck for a solo developer is usually breadth, touching frontend, backend, migration, and docs for one feature, not typing speed. A feature touching five files used to mean five manual context switches. Now it’s one instruction.

The catch: you have to review the diff carefully. These tools will confidently make a change that’s syntactically correct and semantically wrong if the task was underspecified, and a large diff is easy to skim past without catching the one subtly wrong line. Treat the output like a PR from a fast, literal-minded collaborator, not a finished feature. I’ve shipped a bug this way exactly because I skimmed a diff I should have read line by line.

Context also isn’t infinite. Point one at a specific file or a well-described bug and it does great work; point it at “fix the app” with no other detail and it’ll guess, sometimes well, sometimes by rewriting something that wasn’t broken. The instruction quality matters more with these tools than with autocomplete, since a vague prompt doesn’t just get you a mediocre suggestion, it gets you a confident multi-file change built on a wrong assumption.

The editor matters more than the label on the AI feature

Cursor is a genuinely great editor, but I’ve ended up skipping its built-in agent mode in favor of running Claude Code alongside it for anything agentic. I’ve also mostly moved off VS Code at this point: its AI story leans hard on Copilot by default, and I’ve hit real friction trying to run other extensions, Gemini’s specifically, inside it. Codex has impressed me since it launched, and it’s worth trying. For day-to-day work spanning research, planning, and actual code, though, Claude Desktop is still what I come back to most, mainly because it’s the one place that handles all of those different task types reasonably well instead of being great at just one of them.

Cost is a smaller factor than people assume

Copilot runs a flat monthly fee. Agentic tools are usually usage-based, priced on tokens processed, which scales with how much of your codebase gets pulled into context for a given task. For a genuine side project, both land in the range of “a coffee or two a month” unless you’re running enormous multi-file refactors constantly, which most side projects, by definition, don’t need often enough to matter. Worth watching the usage dashboard for the first month to calibrate, but it’s rarely the deciding factor between tools the way the workflow fit is.

Chat without repo access still earns its keep

General chat interfaces without direct file access are still useful for the parts of side-project work that aren’t really coding: explaining an error, comparing two libraries before committing to one, drafting a README, thinking through an architecture decision before writing anything. Cheaper to reach for than an agentic tool when nothing actually needs to change in your repo yet, and there’s zero risk of an unreviewed change landing while you’re just thinking out loud.

What this actually changes

The honest version: the cost of building something has dropped enough that the limiting factor is increasingly your own decision-making, what to build, whether the scope is right, rather than how fast you can type the code. A weekend feature now takes an evening. That sounds purely good, but it also means “I don’t have time to build this” applies to fewer ideas than it used to, including plenty that weren’t worth building in the first place. These tools compress typing. They don’t replace deciding what’s worth building at all.

My actual setup: Cursor as the editor with autocomplete running always, Claude Code for anything touching more than one file, and Claude Desktop on the side for research and planning before I write anything. Most weeks that’s all three, often switching between them within the same sitting depending on what the next ten minutes actually need.