Five months into using AI coding tools daily, I have a nuanced take that I don't see many people articulating. AI-generated code is simultaneously better and worse than most people think. Let me explain.

The Speed Is Real

I'm genuinely faster now. Not marginally. Meaningfully faster. Boilerplate that used to take 20 minutes takes 2. Test scaffolding that I used to procrastinate on now takes seconds. CRUD operations, data transformations, utility functions. All of this comes out of ChatGPT or Copilot in moments, and it's usually correct.

For standard, well-understood patterns, AI-generated code is often quite good. It follows conventions. It includes error handling. It's reasonably well-structured. If you're writing the kind of code that has been written a million times before, AI handles it well.

The Bugs Are Also Real

Here's what nobody in the "AI is amazing" camp wants to talk about. AI-generated code introduces a new category of bugs that are uniquely hard to catch. I call them "plausible bugs."

A plausible bug is code that looks correct on casual inspection but has a subtle issue. It compiles. It runs. It even passes basic tests. But it has an edge case, a race condition, an off-by-one error, or a logic flaw that only shows up under specific conditions.

The reason these bugs are dangerous is that you didn't write the code yourself. When you write code manually, you have a mental model of what each line does. When AI writes code, you have to build that mental model by reading, which is a different and harder cognitive task. It's easy to skim AI output, see that it "looks right," and move on.

Some real examples from my projects:

  • ChatGPT wrote a date comparison function that used string comparison instead of proper date parsing. It worked for most dates but failed when comparing dates across different months with different digit counts.
  • Copilot suggested an array filter that used == instead of === in TypeScript. Worked for numbers, silently broke for strings that looked like numbers.
  • ChatGPT wrote a retry mechanism that caught all errors including ones that shouldn't be retried, like authentication failures. It would retry 401s three times before giving up.

None of these would pass a careful code review. But that's the point. When you're moving fast and the AI is generating code that "looks right," the temptation to skip careful review is strong.

My Review Strategy

After getting burned a few times, I developed a checklist I run through for any AI-generated code that's going into production.

Read every line. Not skim. Read. If I can't explain what a line does and why, I either ask ChatGPT to explain it or I rewrite it myself. No code goes into production that I don't understand.

Check the edge cases. What happens with empty input? Null? Very large values? Concurrent access? AI tends to write for the happy path. The edge cases are where the bugs live.

Verify API usage. If the code calls a library method, I check the documentation to confirm the method exists and works as the AI says it does. This has caught multiple hallucinated APIs.

Write tests for the generated code. Ironically, I use AI to generate the tests too. But I manually add edge case tests that target the specific failure modes I've learned to watch for.

Run it. This sounds obvious but I've caught issues just by running the generated code with sample data before integrating it. "Does it actually work?" is a more important question than "does it look right?"

The Right Mental Model

I've settled on thinking of AI as a very fast junior developer. It writes code quickly, follows patterns well, and handles straightforward tasks reliably. But it doesn't understand the system, doesn't think about edge cases unprompted, and will confidently produce code that has subtle issues.

You wouldn't merge a junior developer's code without review. Don't merge AI code without review either.

The developers who will get burned by AI tools are the ones who treat them as a senior engineer. The developers who will benefit most are the ones who treat them as a fast, tireless, but unreliable assistant that needs supervision.

Trust But Verify

I'm not going to stop using AI coding tools. The speed boost is too valuable. But I've adjusted my expectations. The time AI saves me on writing code, I reinvest into reviewing that code more carefully. The net result is that I ship faster and at roughly the same quality level as before.

That's the honest truth. AI doesn't magically make your code better. It makes code production faster. Quality still depends on you.