Posts tagged AI Coding Agents — AI × software engineering, made practical.
You'll learn to measure your handoff radius, the largest agent-written task you can explain cold within 10 minutes, and to track it each quarter for each area of the codebase so you can tell whether your judgment is growing or going stale.
You'll learn how to write reversal criteria (a metric with a threshold, a decision date and a named evidence owner) so skeptical engineers can test a change like an AI coding agent rollout instead of resisting it.
You'll learn how to run and prepare for an interview round where candidates review an agent-generated pull request with planted bugs, and what a strong review looks like.
You'll learn what a leaderboard score like SWE-bench actually measures, why it can drift from real-world performance, and how to build a private benchmark from your team's reverted PRs.
You'll learn why constraints the agent can check against its own diff stop it from leaving collateral damage, and how to turn vague rules into ones that can be checked.
You'll learn how to turn down requests based on what a feature costs to own rather than what it costs to build, using three questions, a few scripts that keep the relationship intact, a written decision record, and a critic step you run before your agents write any code.
You will learn to set a price from the customer's next-best alternative rather than your build effort, using a simple floor, ceiling and value model.
You'll learn why juniors who review agent-written code without ever struggling through it themselves fail to build real engineering judgment, and how to reintroduce that struggle on purpose.
A routine three-file rename passed every test and every review, then threw a NameError in production three days later — because somewhere around turn 34, the agent stopped trusting the code and started trusting its own summary of the code.
Three weeks of accidental buffer time used to catch bad product decisions before they shipped — agentic coding deleted that buffer, and most teams haven't noticed the safety net is gone.
A four-line PR description that any human teammate would've read in two seconds sent one of our agents grepping the wrong service's code — here's the four-section rewrite that stops it from happening again.
A dashboard win turned into an incident postmortem the day we noticed a 400-line payments PR got approved in the time it takes to read its title.
There's one exact moment a coding agent's plan goes wrong — miss it and you're not fixing a mistake anymore, you're auditing a whole structure built on top of it.
An agent diagnosed a slow dashboard query, shipped a confident CREATE INDEX, and made nothing faster except the growth of our busiest table's write bill — here's the one command that would've caught it before it merged.
A single verb — 'remove' — sat quietly in a ticket for weeks until an agent picked its own meaning, and by the time anyone noticed, the fix wasn't a wording tweak but a whole new way of writing specs.
The most reassuring thing a new hire can say in week one is also the clearest sign your onboarding plan is broken — here's the one-page fix that catches what checklists, code review, and even AI agents miss.
A dashboard that looked like a win — 4x more PRs — was actually hiding a queueing problem with a name, an equation, and a fix that has nothing to do with telling people to review faster.
A coding agent hit 95% test coverage on a payment-retry PR by writing every test against a payment gateway it made up — and the number was completely honest the whole time.
A rising acceptance-rate chart looked like proof our AI coding agent was working, until an hour sitting next to one engineer showed the number couldn't tell 'this helped' apart from 'this got reverted two days later.'
An agent wrote a flawless commit message for a fix that broke production six weeks later, and when I asked why the fix existed, nobody — not the engineer, not me, not the agent — could say, because the pipeline that writes these messages was never built to hold an answer.
We timed a senior engineer against a coding agent, proved it made him slower, showed him the numbers — and his usage didn't budge, which is exactly the clue that cracked the real reason people reach for these tools.
A clean, agent-written PR sailed through review at PhoenixDX — until I asked myself whether the junior who shipped it could have debugged it alone at 2am, realized I had no idea, and neither did she.
A real Tuesday — including an eleven-minute incident where an agent executed a flawed plan perfectly across 600 tenants — shows the senior engineer's job shifting from writing code to designing the harness that decides whether an agent's conclusions are safe to act on.