Learn AI Resource

Posted on Jul 28

Stop Reviewing Code Like It's 2020: An AI-First Workflow That Actually Works

#ai #productivity #codereview #developer

Your PR review process is probably slow. Someone reads 400 lines of code, gets distracted by the formatting, misses the actual logic bug, and then two weeks later production breaks because nobody caught it.

Here's the reality: AI is better at spotting certain issues than you are. Not all issues. But some. And if you're not using it to handle the tedious parts, you're throwing away 20% of your time.

The Old Way vs. The Actually Useful Way

Dumping your entire codebase into ChatGPT and asking "is this good?" doesn't work. That's cargo cult programming.

What does work:

Automated format & lint checks (your CI should handle this)
AI for security pattern matching (using focused prompts)
AI for test coverage gaps (it's surprisingly good at this)
Humans for business logic and architecture (keep this)

The split matters. Don't ask AI to judge whether your architecture is elegant. Do ask it to find the off-by-one error in your loop or spot the unhandled exception.

Practical Setup That Takes 30 Minutes

Step 1: Use Claude or GPT for Pattern-Based Reviews

Create a simple script that sends isolated functions to an LLM:

# Extract a function from your PR
git diff HEAD~1 | grep -A 20 "^+" > /tmp/changes.txt

# Send to Claude via API
curl https://api.anthropic.com/v1/messages \\
  -H "x-api-key: \$ANTHROPIC_API_KEY" \\
  -H "content-type: application/json" \\
  -d @- << EOF
{
  "model": "claude-opus-4-1",
  "max_tokens": 500,
  "system": "You are a code reviewer. Find: (1) security issues, (2) memory leaks, (3) off-by-one errors, (4) missing null checks. Return ONLY the issues found, not praise.",
  "messages": [{"role": "user", "content": "Review this code change:\n\n\$(cat /tmp/changes.txt)"}]
}
EOF

This takes 3 seconds. It catches about 60% of real bugs that make it past your eyes.

Step 2: Test Coverage Analysis

AI is weirdly good at spotting what should be tested but isn't:

# Run coverage report, send to Claude
coverage report --format=json | curl https://api.anthropic.com/v1/messages \\
  -H "x-api-key: \$ANTHROPIC_API_KEY" \\
  -d '{"model": "claude-opus-4-1", "max_tokens": 300, "messages": [{"role": "user", "content": "Given this test coverage report, what critical paths are missing test cases?\n\n\$(cat /tmp/coverage.json)"}]}'

You get a ranked list of "you probably need to test this" suggestions. Often right.

Step 3: The Human Part (The Actually Important Part)

Once the AI handles security patterns and test gaps, your human review becomes sharper:

Does this solve the actual problem?
Will this scale?
Did we miss a cheaper approach?
Is the API design intuitive for callers?

These are judgment calls. They're what you're paid for.

Real Example: Catching the Subtle Ones

I ran this workflow on a real PR last week. The change was a refactor of our caching layer:

What the author caught: "I moved the TTL calculation to a helper function."

What the AI caught: "The helper function doesn't validate that ttl > 0\. If a config value is negative, this silently caches forever."

What I caught: "Agree with AI, and we should bump up the integration test coverage here because this is a common config mistake."

All three caught different things. The AI would've missed the business judgment; humans would've missed the silent-forever-cache bug; the linter wouldn't care because there's no syntax error.

The Tools I Actually Use

Cursor or GitHub Copilot for in-editor suggestions (saves time, usually accurate)
Claude via API for structured code reviews (best at finding real logic bugs)
Shellcheck and pylint for the stuff you don't need AI for (it's free automation)

For the newsletter link, if you're staying on top of AI and productivity trends, grab the weekly dose at https://learnairesource.com/newsletter — it's the good stuff without the hype.

The Honest Part

AI code review isn't magic. It won't replace code review. It will replace the boring parts of code review — the parts where you skim looking for null\ checks and buffer overflows.

And honestly? Your brain is better used thinking about system design than hunting for typos.

Use the tool for what it's good at. Keep humans in charge of what matters.

DEV Community