AI-aided software development: working with Copilot, Cursor, and Claude Code

Modern tools fall on a spectrum from least to most autonomous:

1. Inline completion (GitHub Copilot, Cursor Tab) — suggests the next few lines as you type. You stay in control of every keystroke.
2. Chat panels (Cursor Chat, ChatGPT, Claude.ai) — you ask, the model answers, you copy-paste.
3. In-editor agents (Cursor Composer, Cline, Windsurf) — the model edits multiple files in your editor; you review and accept.
4. Terminal/coding agents (Claude Code, Aider, Codex CLI) — the model can also run commands, install deps, run tests, and iterate.

More autonomy means more leverage but more review burden. The right tier depends on the task, not preference.

A pragmatic stack for most engineers: inline + coding agent. Inline handles "write this obvious function" muscle. Coding agent handles "investigate this failing test and fix it" thinking. The middle tiers are useful but optional.

These tasks consistently get a real productivity boost from AI:

• Boilerplate that's tedious but unambiguous (CRUD endpoints, JSON parsing, type definitions).
• Test writing — "write tests for this function" is usually better than the tests humans write by hand.
• Translation between languages, dialects, frameworks (Python → TypeScript, REST → GraphQL).
• Spelunking in unfamiliar codebases — "where is X defined? what calls Y?"
• Refactors with a clear mechanical pattern (rename, extract function, split a file).
• Documentation for code that already exists.

The common thread: tasks where the desired behaviour is clear and the code is grunt work.

Equally predictable failure modes:

• Inventing APIs: confidently calling methods that don't exist on libraries it has seen.
• Subtle off-by-one and edge cases: code that looks correct, passes a happy-path test, breaks on empty arrays or unicode.
• Aggressive refactors: rewrites that work but throw away accidental complexity that was load-bearing.
• Security regressions: turning safe defaults into unsafe ones without flagging it.
• Stale knowledge: APIs/syntax from before the model's training cutoff.
• Over-confidence on architecture: happily proposes a microservices rewrite for a 200-LOC script.

These aren't fixed by switching models. They're consequences of generation without verification — which is why workflow matters more than tool choice.

Habits that separate the 2x developers from the "my AI gives me bugs" crowd:

1. Write the test first (or ask the AI to). Then ask the AI to make it pass. The test is the contract.
2. Constrain the scope. "Modify this one function" beats "refactor this module".
3. Read the diff. Every line. AI tools make this fast precisely because you're meant to review, not skim.
4. Plan before implementing on anything non-trivial. "Outline the steps you'd take" → review → then "OK, do step 1".
5. Keep a tight feedback loop: tests run, types check, lint clean before you accept the next change.
6. Roll back early. If a generation introduces five changes and you only wanted two, reject the whole thing and try again with a tighter prompt.

Plan, generate, verify, repeat — not just generate.

AI dev tools succeed or fail mostly on how much relevant context the model has. You can influence this:

• Open the right files in your editor. Most tools include open tabs in the prompt.
• Maintain a CLAUDE.md / README.md. Project-level conventions ("we use Tailwind", "prefer async/await over .then") save the model from making up house style.
• Be specific about constraints. "Use the existing useToast hook" beats letting the model invent its own.
• Show, don't tell. "Like OrderCard.tsx but for Invoices" gives the model a concrete template.
• Trim irrelevant context. Pasting a 5000-line file in chat dilutes attention. Quote the function and the type signature; that's usually enough.

More relevant context → better output. More irrelevant context → worse output. They're not the same thing.

If you ship AI-generated code without reading it, you've outsourced typing but not thinking. The bugs you didn't notice are still yours.

Practical disciplines:

• Read every diff before commit. Yes, every one.
• Run the tests locally; don't rely on CI to catch issues you should have caught.
• For anything touching auth, payments, or data deletion, demand a second pair of eyes — yours and a colleague's.
• Treat AI-generated code as "junior contributor" output. Reviewable, sometimes excellent, occasionally embarrassingly wrong.

The productivity gain isn't "the AI does it for you" — it's "the AI does the typing, you do the thinking faster". Skip the thinking part and you just ship faster bugs.