We Let AI Review Every Pull Request for Three Months. Here's What It Actually Caught.
AI code review tools are everywhere now. After rolling one out on a real project, I learned more about our team than about the tool itself.
Lab notes
30 notes
#developer experience.
What I Actually Learned Using AI as a Pair Programming Partner
Practical insights from months of using AI-assisted coding in real client projects — what works, what doesn't, and how it changed my workflow.
AI Tooling Won't Fix Your Broken Engineering Culture
The latest DORA report confirms what I've seen on consulting engagements — AI tools amplify existing conditions. If your processes are solid, AI accelerates you. If they're not, you just create technical debt faster.
I Replaced ESLint and Prettier with Biome on a Client Project. Here's the Honest Report.
A tool comparison from a consulting engagement — what Biome actually delivered, where it fell short, and the decision I'd make again (and the one I wouldn't).
The CI Pipeline Nobody Was Allowed to Touch
A 47-minute build pipeline had become sacred infrastructure. When we finally opened it up, we found cargo-culted steps, redundant checks, and a team afraid of their own tooling.
We Tracked Developer Time for Two Weeks. The Results Were Uncomfortable.
A consulting engagement where we measured where engineering hours actually went — and discovered the biggest productivity killer wasn't what anyone expected.
The E2E Test Suite That Cried Wolf
How a 45-minute end-to-end test suite trained an entire team to ignore test failures — and what we did about it.
We Had 400 Alerts a Week and Maybe 12 of Them Mattered
A client's on-call rotation was burning people out — not because of real incidents, but because of noise. Here's how we cut alerts by 87% without missing anything that actually required a human.
More PRs, Slower Delivery: The AI Agent Throughput Trap
A client's team tripled their PR output with coding agents. Six weeks later, their cycle time had doubled and nobody could explain why.
Nobody Quits Over On-Call. Except They Do.
On-call never shows up in exit interviews. But across half a dozen consulting engagements, I've watched it quietly hollow out engineering teams. The pattern is always the same, and it's always fixable.
We Built an Internal Developer Platform and Nobody Used It
A consulting story about a platform engineering initiative that checked every box on paper but collected dust in practice — and the uncomfortable reasons why.
Reviewing AI Code Is the New Bottleneck
Last quarter I tracked my time across three consulting engagements. I spent 11 hours a week reviewing AI-generated code and under 8 writing my own. The ratio surprised me, and it changed how I think about developer productivity.
The Sixty-Seven Environment Variables Nobody Documented
A client's deployment kept failing in staging but not locally. The root cause wasn't code — it was sixty-seven environment variables spread across five files with no documentation and no single source of truth.
The Staging Environment Nobody Trusted (So Everyone Tested in Production)
A client's staging environment had drifted so far from production that developers stopped using it. Tests passed in staging and failed in prod. Tests failed in staging and passed in prod. Eventually the team just stopped looking.
Stop Calling Everything Technical Debt
A client showed me their "tech debt backlog" with 214 items. Missing tests, outdated dependencies, bad naming, a database nobody understood, and an actual architectural shortcut from 2019. Lumping all of that into one bucket is why none of it gets fixed.
How Structured Logging Turned Our 2AM Pages Into 15-Minute Fixes
A debugging deep dive into replacing wall-of-text logs with structured logging and trace IDs — and how it cut our mean time to resolution from hours to minutes.
The Branch That Lived for Four Months
A client's "big rewrite" feature branch had 847 commits, was 14,000 lines behind main, and three engineers were trapped on it. The merge took a week. It didn't have to be this way.
The Codebase That Slowly Stopped Agreeing With Itself
A client's AI-assisted codebase passed every lint check and had solid test coverage. But under the surface, modules had drifted into contradictory patterns — three retry strategies, four error-handling philosophies, and a data validation layer that depended on which AI session wrote the code.
The Dockerfile Nobody Had Touched in Two Years
A client's Docker build took 18 minutes. Developers had stopped building locally and were pushing to CI for every change. The fix took an afternoon, but the real cost was the two years of compounded slowness nobody measured.
The GraphQL Migration We Quietly Abandoned
A client was six months into migrating from REST to GraphQL. Half their endpoints were converted, developer experience was arguably worse, and the frontend team was maintaining two data layers. Sometimes the right engineering decision is to stop.
The Shared Package Five Teams Were Afraid to Touch
A client's internal utility package started as a convenience. Two years later, it had 47 dependents, undocumented side effects, and a change to one date formatter broke invoice generation for three services.
The Slack Bot That Became Load-Bearing Infrastructure
A team built a quick Slack bot for deploy notifications. Eighteen months later, it ran deploys, managed on-call rotation, provisioned environments, and tracked incidents. It had no tests, no docs, and ran on a single EC2 instance nobody monitored.
The Team That Had More AI Agents Than Engineers
A client's platform had 23 AI agents built by a team of 8. Nobody could tell me what half of them did. Agent sprawl is the new microservices sprawl, and the cleanup looks depressingly similar.
It Took a Senior Engineer Two Days to Run Our App Locally
A client had fourteen microservices, a 280-line Docker Compose file, and an wiki page last updated eight months ago. Their newest hire spent two days just trying to get the app running on her laptop.
We Deleted 30% of the Codebase and Nothing Broke
A client's team was drowning in a 200K-line TypeScript monolith. When we finally measured what was actually running in production, we found that almost a third of it was dead code nobody had touched in over a year.
We Finished the Feature in a Week. It Shipped Three Months Later.
A client's team built the core feature in five days. Then came the edge cases, the migration script, the security review, the load test that failed, and the staging bug that took longer to fix than the feature itself.
We Merged Six Microservices Back Into a Monolith
A 20-person team was running 14 microservices with three full-time engineers just keeping the infrastructure alive. We consolidated six of them into a modular monolith and cut their deploy time by 70%.
We Tripled Code Output. Delivery Speed Didn't Budge.
A client's engineering team adopted AI coding tools across the board. Individual velocity soared. But their DORA metrics flatlined — and the reasons had nothing to do with the tools themselves.
What I Look for in the First Hour of a New Codebase
After parachuting into dozens of client projects, I've developed a mental checklist for the first sixty minutes. Most of what matters isn't in the code itself.
Your AI Coding Tool Just Got Acquired. Now What?
The SpaceX-Cursor deal forced a lot of teams to rethink their AI tooling strategy overnight. But the real problem isn't the acquisition — it's that most teams never had a strategy to begin with.