← ALL POSTS

The AI Workflow That Cut Our Production Incidents by 75%

Six months ago, nearly 4 out of every 10 deployments led to some kind of production incident. Untested edge cases, regression bugs, missed validation, bad deployments — the usual suspects. Today, that number sits at roughly 1 in 10.

Here's exactly what changed.

The Problem

The incident rate wasn't from carelessness. It was from the reality of shipping fast in a growing codebase. The patterns were predictable:

  • Untested edge cases — code worked for the happy path but broke on nulls, empty arrays, or unexpected user input
  • Regression bugs — fixing one thing quietly broke something else
  • Missing validation — form inputs, API payloads, and database writes that assumed well-formed data
  • Bad deployments — config mismatches, missing environment variables, dependency conflicts caught too late

We were doing code reviews. We were writing tests. But humans miss things, especially under deadline pressure. The review bottleneck meant PRs sat for hours, and reviewers were skimming by the third PR of the day.

The Shift

I didn't replace any part of the workflow. I augmented every part of it with AI tooling. Three tools made the biggest difference:

1. CodeRabbit for Automated PR Review

This was the single highest-impact change. CodeRabbit runs on every pull request automatically and catches things human reviewers consistently miss:

  • Logic errors and off-by-one bugs
  • Missing error handling on async operations
  • Security issues like unsanitized inputs
  • Performance problems like unnecessary re-renders or N+1 queries
  • Inconsistencies with existing patterns in the codebase

The key insight: CodeRabbit doesn't get tired at 4pm on a Friday. It reviews the 15th PR of the day with the same rigor as the first. Human reviewers still do the architectural and business logic review, but the mechanical correctness check is automated.

Before CodeRabbit, roughly 30% of the bugs that reached production were things a careful reviewer should have caught. That category has nearly disappeared.

2. Claude Code for Development and Testing

Claude Code changed how I write code in the first place. Not just autocomplete — actual pair programming where the AI understands the full context of what I'm building.

How I use it:

  • Before writing code — I describe the feature and ask Claude to identify edge cases I should handle. This catches problems before they exist.
  • Writing tests — I describe the function's behavior and Claude generates test cases including the weird edge cases I wouldn't have thought of. Empty strings, concurrent requests, timezone boundaries, unicode input.
  • Pre-commit review — Before I even push, I ask Claude to review my changes for bugs, security issues, and missed edge cases. It's like having a senior engineer look over your shoulder, except it's instant and never busy.
  • Debugging — When something breaks, I paste the error and relevant code. Claude traces the issue faster than I can grep through logs.

The biggest win isn't speed — it's coverage. I'm catching classes of bugs during development that used to only surface in production.

3. Cursor for Context-Aware Editing

Cursor gives me AI assistance directly in my editor with full codebase context. When I'm modifying a function, it understands what calls that function, what types flow through it, and what tests exist for it.

This matters for regressions. The AI flags when a change might break a downstream consumer because it can see the whole dependency graph. Before, that required manually tracing call sites — something you skip when you're in a hurry.

What the Workflow Looks Like Now

Every feature follows this flow:

  1. Plan with Claude Code — Describe the feature, identify edge cases and potential failure modes before writing a line of code
  2. Build with Cursor — Write the implementation with AI-assisted editing that understands the codebase context
  3. Test with Claude Code — Generate comprehensive test cases including edge cases
  4. Self-review with Claude Code — Review my own changes before pushing, fix issues immediately
  5. Automated PR review with CodeRabbit — Catches anything I missed, runs on every PR automatically
  6. Human review — Team members focus on architecture, business logic, and design — not mechanical correctness

The human reviewers are now freed up to think about the right questions: Is this the right approach? Does this scale? Does this match the product requirements? They're not burning mental energy spotting null checks.

What Didn't Work

Not everything was a win:

  • Blindly accepting AI suggestions — Early on, I'd accept Claude's code without fully understanding it. This created bugs that were harder to debug because I didn't know what the code was supposed to do. Now I treat AI output as a draft, never as final.
  • Over-testing — Claude will happily generate 50 test cases for a simple function. I had to learn which edge cases actually matter vs. which ones are theoretical. Testing every permutation wastes time and makes the test suite brittle.
  • AI for architecture decisions — AI is great at implementation but mediocre at system design. I still make architectural decisions myself based on experience and business context. AI doesn't know your team, your users, or your deadlines.

The Results

Over 6 months, tracking weekly:

  • Production incidents: 40% → 10% of deployments
  • Time-to-detect: Issues that do reach production are caught faster because our monitoring and test coverage improved alongside the AI workflow
  • PR review time: Dropped significantly. Human reviewers spend less time on mechanical checks, more on design feedback
  • Developer confidence: Shipping feels less stressful when you know multiple AI layers have checked your work before it hits production

What You Can Start With Today

You don't need to adopt all three tools at once. If I had to pick one:

Start with automated PR review. Set up CodeRabbit (or a similar tool) on your repo. It takes 10 minutes and immediately starts catching bugs on every PR. The ROI is instant and requires zero change in your development habits.

Then gradually add AI-assisted development (Claude Code or Cursor) as you get comfortable. The key is treating AI as a layer in your quality pipeline, not a replacement for your judgment.

The goal isn't to write code faster. It's to write code that doesn't break in production.

I'm Burhan Haroon, a full-stack developer who uses AI to ship better software. If you're building a team that values quality and modern tooling, let's talk.