A confession

I tab-completed my way through an entire React component last Tuesday without reading a single line of what I'd accepted. Just tab, tab, tab, tab, like a seal performing for fish. The component worked. I deployed it. I still don't fully understand what it does.

This is what AI coding assistants have done to me. And I suspect, if you're honest, they've done something similar to you.

The tools in question

Let me quickly run through the main players:

GitHub Copilot is the original and still the most widely used. It sits in your editor and suggests code completions as you type. It's like having a very fast, very eager junior developer looking over your shoulder and finishing your sentences.

Cursor is a full code editor built around AI. It doesn't just complete lines, it rewrites whole files, understands your codebase, and has a chat feature that can explain and modify code across your project. It's Copilot on steroids.

Tabnine is the privacy-focused alternative. It can run locally without sending your code to anyone's servers, which matters if you work on proprietary codebases.

Codeium is the free alternative that's surprisingly good. If you can't justify paying for Copilot, Codeium does about 80% of what Copilot does for precisely zero pounds.

Windsurf (formerly Codeium's editor, now its own thing) is trying to be the Cursor competitor. It's newer and rougher around the edges, but the multi-file editing is promising.

The good: what these tools actually help with

Let me be fair before I'm critical. AI coding assistants are genuinely useful for:

Boilerplate. Writing the fifteenth Express middleware of the week? The fiftieth React component with the same basic structure? AI can write this stuff in seconds and it's usually correct. This saves real time and reduces the soul-crushing tedium that makes programmers consider career changes.

Unfamiliar APIs. When you're working with a library you've never used before, Copilot and Cursor are excellent at suggesting the correct method calls, parameter patterns, and setup code. It's like having the documentation embedded in your editor, which is useful because nobody reads documentation.

Regex and string manipulation. I don't know a single developer who can write a complex regex from memory without getting it wrong at least twice. AI writes them correctly on the first try about 70% of the time, which is much better than my personal average.

Tests. Writing unit tests is boring. AI is good at boring things. Match made in heaven. The tests it generates are often naive, but they catch obvious regressions, and naive tests are infinitely better than no tests, which is what most of us write when left to our own devices.

The bad: what they're doing to our brains

Here's where I stop being diplomatic.

We're losing the ability to think through problems. When I started programming, hitting a wall meant staring at the screen, maybe drawing a diagram, going for a walk, and eventually having a moment of clarity where the solution clicked into place. That process was often miserable, but it was also how I actually learned.

Now, I hit a wall, type a question into Cursor's chat, and get an answer in eight seconds. I never go for the walk. I never have the moment of clarity. I just apply the suggested fix and move on. The problem gets solved but I don't learn anything.

We're accepting code we don't understand. This is the big one. Tab-completing an AI suggestion without reading it is the coding equivalent of signing a contract without reading the fine print. Sure, it'll probably be fine. But when it isn't fine, you'll have no idea what went wrong or why.

I've deployed AI-generated code that I later realised had subtle bugs that my past self would have caught during writing. Not because the AI is bad, but because I'd skipped the step where I actually thought about what the code was doing.

We're over-engineering everything. AI coding tools have a tendency to suggest the "proper" solution, which often means the most abstracted, most pattern-heavy, most enterprise-grade approach. Ask Copilot to fetch some data and it'll suggest a full repository pattern with interfaces and dependency injection. Sometimes you just need a fetch call, mate.

Junior developers are not learning fundamentals. This worries me more than anything else. If you've never written a sorting algorithm by hand, you don't really understand what sort() is doing. If you've never manually parsed a string, you can't debug a regex. AI tools skip the educational suffering that builds real understanding.

I've mentored junior devs who can build impressive-looking projects with AI assistance but can't explain how a JavaScript Promise works. The tools have created a generation of developers who can construct buildings but don't understand how bricks are made.

The tension

So here's the honest uncomfortable bit: I know all of this, and I'm not going to stop.

Because going back to writing code without AI assistance would be like going back to a flip phone. Yes, it was simpler. Yes, you were more present. But you're not actually going to do it, are you?

The speed improvement is too significant to ignore. What used to take me an hour takes fifteen minutes. Features that would have been a full day's work ship by lunchtime. My output has roughly tripled, and even if the quality has dipped slightly, the net productivity is still massively positive.

What I'm trying to do about it

I don't have a neat solution. But here's what I've been trying: - Read before tabbing. Spend three seconds reading each suggestion before accepting it. Three seconds. It doesn't sound like much but it catches a surprising number of problems. - Write critical logic by hand. Authentication, payment processing, data validation. Anything where a subtle bug has serious consequences. Write it yourself. Let the AI handle the boring stuff. - Spend one hour per week without AI. Painful but useful. Pick a small feature and write it from scratch. Remind your brain that it can still do this. - Use AI for tests, then read the tests. The tests tell you what the AI thinks your code does. If the tests don't match your intention, either the tests or your code are wrong. Either way, you've learned something.

Which tool to pick

If you want the best all-round experience and you're willing to pay: Cursor. It's the most capable and the multi-file editing is something Copilot still can't match.

If you want simplicity and wide editor support: GitHub Copilot. It works in VS Code, JetBrains, Neovim, and basically everywhere else.

If you want free: Codeium. Genuinely good and genuinely free.

If you care about privacy: Tabnine. Local mode means your code never leaves your machine.

If you want to try the newest thing: Windsurf. Rough edges but interesting ideas.

Just... try to remember how to code without them. You might need that skill someday. Maybe even soon.