12 posts tagged #engineeringmanagement.
A small team is fast because the whole problem lives in two or three heads. That's also why it's fragile...when one of those people leaves, a big chunk of how things work leaves with them. Here's what actually walks out the door, and how to manage it before it happens.
The case for moving fast usually comes with a number, and the case for slowing down usually comes with a story. Here's how to turn your experience into a number the business can actually weigh...and how to tell when the numbers say you should move faster after all.
AI made coding faster, and the common advice now is to cut process everywhere so all that extra code can flow through. But some of those steps were catching risky changes before they reached users. Here are the three questions I ask to tell the process worth cutting from the process worth keeping.
When review depth follows risk, the high risk work falls on the same two or three seniors every week. Here are three ways to spread that load without lowering the bar.
When an agent helped write a pull request, the first question most reviewers ask is who wrote it. I think the better first question is what it touches. Here's how I'd set review depth by risk, where authorship still fits, and why some changes may need very little review at all.
When your team stops trusting its AI code review, the obvious fix is to add a second AI. I don't think that buys you much...two models trained on the same internet share the same blind spots. What actually helped me was checking the evidence outside the diff. I tried it on a real queue of 58 open PRs, and here's what it caught.
On a lot of teams, code that a pair of devs wrote usually gets a lighter code review. Nobody wrote that rule down and nobody voted on it, but pairing earned it. Here's what the research actually says about that discount, why it's never one flat size, and what happens when dev + agent starts getting filed under the same category.
A one-line warning in my deploy log took my site down for thirty minutes. It didn't stop anything, the command exited zero, and it looked like every other line scrolling past. Software risk stays invisible until traffic hits it, and that invisibility is why the work that prevents incidents is the first thing a deadline cuts.
Deleting a year-dead feature flag turned a forgotten feature back on and broke production...here's why flag cleanup is a runtime change, not tidying, and how the context you need decays while the flag sits there looking harmless.
Big PRs don't come from lazy engineers. They come from a skill almost nobody gets taught: how to cut a piece of work down into small, reviewable chunks. Here's why that's still the highest-leverage habit in engineering... and why AI just made it matter more, not less.
Most merge standards are wiki decoration. What makes a team actually follow them isn't the list...it's enforcement, consistency, and the why.
Most code-review checklists ask "does this work?" The harder question is "what happens when it doesn't?" Five things I check on every PR that the standard checklists miss... plus the comment grammar that makes reviews actually move.