Skip to content
BSWEN
Blog

Best Practices for Reviewing AI-Generated Code: Catch Subtle Mistakes Before They Compound

Cowrie
Cowrie
Dev @ Bswen

The AI agent just generated a 200-line diff. I stare at it, my thumb hovering over the “Accept” button. Should I just accept it? It looks reasonable…

Stop. This is the moment where vibe coding succeeds or fails.

I used to think the skill was in prompting—crafting the perfect instruction that makes the AI do exactly what I want. I was wrong. The real skill is reviewing what the AI produces, catching the subtle mistakes, and knowing which parts to keep versus rewrite.

Most advanced vibecoders I know spend more time reviewing than prompting.

Practice 1: Read Diffs, Don’t Accept Blindly

When I started with AI coding agents, I treated them like magic wands. Generate, accept, generate, accept. Then I spent three hours debugging a “simple” refactor that the agent had subtly broken.

Now I read every diff. Every single line.

Example: A subtle mistake in a refactored function
- function validateUser(user) {
-   if (!user.email) return false
-   if (!user.name) return false
-   return true
- }
+ const validateUser = (user) => {
+   if (!user.email) return false
+   if (!user.name) return false
+   return true
+ }

Looks innocent, right? But what if this function was being used as a constructor with new? What if there were tests checking the function’s prototype? The agent doesn’t know the full context—I do.

The pattern I’ve learned:

  • Green lines (additions): Check logic, check for introduced bugs
  • Red lines (deletions): Verify nothing important was lost
  • Context: Understand why the change was made

Practice 2: Run Tests and Typechecks in the Loop

I got burned too many times by accepting code that “looked right.” Now I make the agent run my test suite after every change.

The loop I use
Lint → fix and retry
Type error → fix and retry
Test red → fix and retry

If your agent can run your test suite after every change, it catches its own mistakes before they compound. I’ve seen agents introduce a bug, then build three more features on top of that bug. The longer I wait to run tests, the harder it is to untangle.

But when I run tests immediately, the agent sees the failure and fixes it while the context is fresh. No context switching, no mental overhead.

The setup is worth it:

  1. Configure your agent to run tests automatically
  2. Make sure type checking is part of your CI
  3. Keep the test feedback loop tight

Practice 3: Use Adversarial Review

Here’s a trick I learned from code review practices: use a fresh reviewer.

When an agent generates code, it’s “warm”—it has all the context, it knows what it intended. It’s hard for it to spot its own mistakes.

But a fresh reviewer agent? It sees the code with new eyes.

I use two patterns:

Pattern A: Reviewer agent
1. Generator agent: Creates the diff
2. Reviewer agent: Reviews the diff with fresh context
3. Generator agent: Addresses feedback
Pattern B: Same agent, fresh context
1. Generate code
2. Start new session with same agent
3. Ask it to review its own previous output

The adversarial mindset catches things the generator misses. “Why is this variable named data when the function returns a user object?” “This error handling swallows the error—is that intentional?”

Practice 4: Fix the Prompt, Not the Line

This was the hardest habit to break.

I see a bug in the generated code. My instinct? Open the file, fix the line, move on.

Wrong. That’s not vibe coding. That’s traditional coding with extra steps.

Advanced vibe coding is the art of fixing the prompt, not the line. If the code is wrong, my instructions or context were the problem. I refine the spec and let the agent regenerate.

Here’s how my workflow changed:

Before (wrong approach)
1. Agent generates code
2. I spot a bug
3. I manually fix the bug
4. I commit
After (correct approach)
1. Agent generates code
2. I spot a bug
3. I identify why the agent made the mistake
4. I refine the prompt/context
5. Agent regenerates
6. I verify the fix
7. I commit

Why does this matter? Because the agent learns (within the session). If I fix the code manually, the agent doesn’t get feedback. But if I fix the prompt and regenerate, the agent understands what went wrong and is less likely to make the same mistake later in the session.

Plus, if I need similar code in the future, my refined prompt becomes a template I can reuse.

Practice 5: Build Pattern Recognition

After months of reviewing AI-generated code, I’ve started to recognize patterns of subtle mistakes.

Confidence in wrong assumptions

The agent will confidently use a variable that doesn’t exist, or call a function with the wrong signature. It doesn’t hesitate. It doesn’t add a “TODO: verify this exists” comment. It just assumes.

Example: Confident assumption
// Agent assumes this function exists
const user = await fetchCurrentUser(request)
// But it doesn't - the actual function is getCurrentUser()

I now scan specifically for:

  • Function names (do they match the codebase?)
  • Variable references (were they declared?)
  • Import statements (are they real packages?)

Missing edge cases

Agents love the happy path. They’ll implement the core logic perfectly, then forget about:

  • Empty arrays
  • Null/undefined values
  • Error states
  • Race conditions
Example: Missing edge case
// Agent's code
const items = collection.filter(item => item.active)
const first = items[0].name // What if items is empty?


// Better approach
const items = collection.filter(item => item.active)
const first = items[0]?.name ?? 'default'

Wrong variable names that “look right”

The agent will use user when it should use currentUser, or data when it should use responseData. The names are semantically close, but wrong.

Example: Deceptive naming
// In a function handling both users and admins
function getPermissions(user) {
  return user.permissions // Wait, which user? The parameter or the outer scope?
}

Common Anti-Patterns

I’ve identified the mistakes I used to make (and sometimes still make):

  1. Accepting without reading - The “it looks fine” trap
  2. Fixing code manually - Losing the vibe coding benefit
  3. Skipping tests - Letting bugs compound
  4. Not using reviewer agents - Missing the adversarial perspective
  5. Same reviewer every time - The agent gets too familiar with its own patterns

The Mental Model Shift

Traditional coding: Write code carefully, test thoroughly, commit.

Vibe coding: Generate code quickly, review carefully, refine prompts, regenerate, test, commit.

The skill isn’t in writing the code anymore. It’s in:

  • Reading diffs critically
  • Understanding what went wrong
  • Communicating that back to the agent
  • Building a library of refined prompts

In This Post, I…

I shared five practices for reviewing AI-generated code effectively:

  1. Read every diff carefully before accepting
  2. Run tests and typechecks in a tight feedback loop
  3. Use fresh reviewer agents for adversarial review
  4. Fix prompts, not code—refine and regenerate
  5. Build pattern recognition for common AI mistakes

The goal isn’t to catch every bug—that’s impossible. The goal is to develop a review workflow that catches the most important bugs while keeping the velocity benefits of AI coding.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: