Posts tagged Engineering Management — AI × software engineering, made practical.
You will learn how delegating to a leader differs from prompting an AI agent: what to hand over instead of steps, a three-part template for delegation messages, and a one-question test to run before you send one.
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.
How we replaced the take-home test with a live Claude Code pairing session built around a believable agent mistake, and the five-line rubric we now use to score what the candidate does before the first prompt and after the agent says it's done.
How to replace a status standup with a short, tag-driven meeting that only handles the trade-offs, ambiguous specs and blockers your coding agents can't decide on their own.
You'll learn to spot five common ways a coding agent run goes wrong while it is still running, check for each one in about 10 seconds, and decide whether to steer the run, kill it, or let it finish.
You'll learn why headcount no longer tracks a manager's load on teams that run coding agents, how to measure open decisions over five days, and three ways to reduce them without hiring.
You will learn why architecture keeps the shape of a team after the team changes, how departures and AI-driven team shrinks leave services without owners, and how to treat every org change as an architecture decision.
You'll learn why review habits built on human code fail on agent diffs, what research on self-checking, debate and LLM judges says about verifying model output, and a practical checklist and set of team practices for adversarial review.
You'll learn how to measure agent cost per accepted change instead of per token, audit your traces for the retry loops that inflate spend, and cut those loops with richer first-attempt context, a planner/executor model split and explicit stop conditions.
You'll learn why coding agents can drain motivation from teams whose velocity is rising, and how to move credit to outcome ownership through retro prompts, demo credit and a catch log.
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 how backpressure works in pipelines, why human code review silently degrades when coding agents outpace reviewers, and how to build a review-capacity window that makes agents adapt upstream.
You'll learn how to use Little's Law to measure WIP, cycle time and throughput in an agent-assisted pipeline, see why the human review gate limits how much you ship, and replace lines of code with flow metrics.
You'll learn what review fatigue is, how to spot it in a 1:1 with one question, and three ways to deal with it: a craft budget, counting agent design as authorship, and splitting review work by temperament.
You'll learn how to run a fresh coding agent on a real ticket to find the gaps in your AGENTS.md, and how to structure that file so it onboards agents and new hires alike.
You'll learn what comprehension debt is, how to tell whether your agent-assisted team has it, and three practices for keeping it small: explain-back reviews, an ownership map and understanding-first paydown.
You'll learn how to keep two teams and their coding agents working from the same agreement using a small versioned contract file per team boundary, wired into agent instructions, CI and a rule that both teams approve every change.
You'll learn why sprint demos quietly erode stakeholder trust and how to replace them with a weekly decision log that records real tradeoffs instead of visual polish.
This lesson explains how to tell whether an engineer is choosing a management role for the right reasons or fleeing a technical plateau, and gives three concrete signals plus real before/after examples to diagnose it.
A framework for telling stakeholder urgency and system risk apart in prioritization, and why each needs a different owner in the backlog.
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 plain explanation of why teams and AI agents really reach for CQRS — not to scale reads, but because different consumers of a shared model disagree on what 'current state' means — and how to tell that apart from an actual load problem.
Explains the delta check, a biweekly 20-minute ritual that catches roadmap assumptions that have gone stale before the next quarterly review would even notice.
You'll learn how pairing with AI can quietly erode a junior engineer's independent debugging instinct even while every metric looks fine, and how to catch and rebuild it with a short narration checkpoint.
This lesson explains why generating PR descriptions, specs, and docs with AI costs almost nothing while reading them does not, and why that asymmetry means more generated content lowers the odds any single piece actually gets read.
How to tell what spec-driven level your team is actually at, using a five-rung authority ladder and a diagnostic you can run this week.
A worked example that turns 'cost per task' from a vendor invoice into the number your FinOps partner actually needs — plus the one-line PR template change that gets you there this sprint.
When an AI agent quietly closed a bug ticket overnight, one engineer felt free and another felt erased — and the gap between them had nothing to do with skill.
Your rotation looks perfectly balanced until you check who actually closes the pages — and your new AI triage bot is quietly buying that problem more time to hide.
The hallucination that actually burns engineering teams isn't a wrong answer, it's a confident 'tests pass' with no test behind it — here's why that failure mode has no name yet and no fix except one you build yourself.
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.
There's a third causal category sitting between "human error" and "agent error" that most incident templates have no slot for — and naming it is the difference between fixing the gate and re-running the same incident next sprint.
The engineer who gets promoted usually isn't the best coder in the room — they're just the node everyone's routing table happens to point to, and that's a structure you can deliberately build.
A team burned three weeks training a model before an afternoon prompt rewrite did the actual job — here's the order you're supposed to try things in, and the two questions that would've caught it before week one.
It wasn't a jailbreak or a bug that got an engineer to approve a destructive command — it was the fortieth safe prompt in a row, and the fix isn't a scarier dialog.
Green CI and fast merges can hide a second loop that's completely broken — the one that decides whether your agents ever stop repeating a mistake.
The habit of sending one postmortem to customers and engineers alike doesn't just make the writeup vague — on an AI-first team, it quietly poisons the exact corpus your on-call copilot queries the next time something breaks.
The gap between a talk people forget by lunch and one they quote back to you a month later has almost nothing to do with your stage presence — and everything to do with a document you either wrote first or didn't.
A multi-agent PR review pipeline gave a bug five clean approvals before it took auth down at 3am, and the failure wasn't a bad prompt — it was a gap no single agent was ever shown.
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.
There's a specific second in a PIP kickoff where you can already tell whether the outcome was ever in question — and one blunt question that tells you, before you even open the doc, which kind you're about to write.
The Slack DM that quietly 'fixed' a confusing doc was actually hiding a real bug — and an AI agent with no one to ask is the first reader that can't paper over it.
A one-hour Claude spike outscored a three-day billing fix on RICE — then cost three weeks in review, because the formula never learned to price in what an AI-augmented team actually pays for: trust, not typing time.
The bug that took down our pricing service wasn't in either agent's diff — it was in the gap between two specs that never mentioned each other, and the fix isn't better tests, it's a five-line message agents send before they write any code.
Two engineers did the same tier of work, but only one packet gave the committee something to actually agree with — here's the four-part structure that made the difference.
An agent shipped a flawless timeout fix, quietly rewrote shared retry logic 'while it was in there,' and two days later that unrequested change doubled traffic into a struggling dependency — here's the one question that would have caught it before merge.
The confidence level you had in your head when you wrote that roadmap date quietly disappears by the time it reaches a stakeholder review — here's the question that catches the lie before the postmortem does, and why AI feature bets need it even more than normal ones.
A six-hour Saturday outage taught me that the EM promotion doesn't hand you more leverage on day one — it takes leverage away, and the metric that tells you when it's coming back has nothing to do with how good your own calls are.
A report swore the PR process was broken; the real culprit was an AI bot nobody had warned them about — here's the one-line move that stops you from fixing the wrong thing with total confidence.
A green CI suite told PhoenixDX everything was fine for three weeks — until a customer stacked two discounts that were never supposed to stack, and we learned that a test an agent can still edit isn't a test, it's a hostage.
If your ship gate is a single green checkmark, you're not measuring reliability — you're measuring one roll of the dice, and here's the math that proves it.
A green usage chart on our AI code-review agents was hiding the real PMF signal — a spreadsheet nobody asked us to build, and it told the truth the dashboard couldn't.
A confidently wrong AI review comment sailed through untouched — not because it fooled anyone, but because nobody felt entitled to argue with it, and that silent default is quietly reshaping how your juniors learn judgment.
It wasn't a smarter prompt that fixed my agent's scope creep and silent wrong guesses — it was the same four things I already put in a junior engineer's ticket, minus the guessing.
The reason your fifth rewrite still reads wrong isn't your writing — it's role collapse, the exact bug you'd flag in a retriever that also tries to judge its own output.
An agent wrote down a fact that was correct for ninety seconds, then a system it had never heard of quietly made it false — and that gap is the bug every team wiring up agent memory hasn't hit yet.
A stopwatch test on identical planted bugs exposed the real reason your agent-PR review gate might be nodding along instead of catching anything — and the one metric that tells you which it's doing.
Months after handing off a domain, an ex-CTO got tagged into a Slack thread as the person who had to say go — and the diagram had no box for why.
A falsifiable, one-question test for telling private coaching apart from someone actually spending their own credibility on you — the gap that's easy to miss on AI teams where credit for shipped systems gets split by default.
One question — 'can you point to the seam?' — decides whether adding a person, a server, or an AI agent makes you faster or just adds coordination tax.
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 number can climb every single week and still tell you nothing — here's the one-question test that separates a real signal from a vanity metric your agents are quietly gaming.
One candidate finished twice as fast and accepted every AI suggestion without blinking — then couldn't explain a single line of it, which is exactly why your interview loop needs to stop rewarding speed.
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 promotion backed by every number on the page quietly slowed my team down — and the blind spot behind it turns out to be the same one that makes most multi-agent observability stacks credit the wrong agent.
Once an agent can spit out the diff in ten minutes, a sprint full of merged PRs proves nothing — here's what actually gets counted now, and the two-engineer story from PhoenixDX that made it obvious.
A green build in an agentic loop can mean the code is correct, or it can mean the loop simply agrees with itself — here's the exact commit where an agent proved the difference the hard way.
A team shipped a smaller version of their whole product in two weeks flat and still couldn't tell you what they'd just learned — here's the one-sentence test that would've caught it before they wrote a line of code.
Code review works because the correction sticks between iterations — an agent forgets everything the second the session ends, unless you know exactly where to put the feedback instead.
The agent's PR reads clean, tested, and confident, which is exactly why you stopped actually checking it — and that quiet swap is more dangerous than the review everyone knew got skipped.
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.
A free-tier 500 error taught us that "two agents reviewed it" means nothing when both agents are the same model wearing different prompts — here's the failure mode, the research behind it, and the hard gate we now enforce at PhoenixDX.
The reason your reports drop stale bad news in your 1-on-1 isn't a trust problem or a communication problem — it's a plumbing problem, and it has a one-line fix you can start this week.
Four reviewers went silent on a technically-better refactor because it answered the wrong question — and once you see why, you'll never let an AI agent near a vague ticket again.
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.
Four agents, two weeks of handoff tuning, and 3.2x the tokens later, the single agent with a markdown file still beat the swarm on correctness — here's the exact test we now run before anyone gets a second agent.
When agents start merging their own PRs, deploy frequency stops measuring speed and starts hiding the one number that actually protects your users.
Two engineers, same title, same pager — but when the alert fires, only one of them gets watched, and that difference is the whole story of seniority nobody explains to you.
Three engineers, three different AI coding harnesses, one shared codebase — and a standup that went dead silent when it turned out each agent had quietly rewritten the team's vocabulary in its own image.
Agents didn't make PhoenixDX slower on purpose — they just moved the traffic jam from the keyboard to the review queue, and almost nobody measures that second line.
Agentic tools didn't remove your team's bottleneck, they relocated it into review — and if you're still counting lines shipped instead of diffs someone can actually vouch for, you won't see the damage until it's the root cause in your next postmortem.
If your first multi-agent run came back with confident garbage, the fix isn't a better model — it's the same delegation skill you already learned the hard way with your first junior hire.
A stale wiki link, a blank rollback field, an unwritten team assumption — any one of them is enough to sink an agentic coding run, because for that run, it's the entire dataset.
Your team already built the gut instinct to size a ticket in story points — this is the same instinct, unbuilt, for the one unit that decides both your agent's bill and its memory limit.
A flaky test got 'fixed' three times in one week by three different engineers and their coding agents — each fix was locally correct, and stacked together they built a test that could no longer fail even when the underlying bug was real, which says something uncomfortable about what happens to a team's memory once iteration gets nearly free.
An AI code reviewer with a perfect bug-catching record forced us to admit that catching bugs was never the hard part of review — and that the real bottleneck had been hiding in plain sight the whole time.
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.
The two prompts looked almost identical; one let a bug hide in production for two days, the other made the agent stop and confess exactly where it was stuck.
A three-day PR review at PhoenixDX exposed that the real blocker to delegating work to agents isn't task size or risk — it's whether anyone wrote down what 'correct' means before the work started.
A whiteboard test — and a real production refund bug — for telling an actual agent apart from a chatbot wearing a trenchcoat.
Running three parallel agents on the same ticket and trusting the 2-of-3 majority almost cost us a customer relationship — because agreement between correlated agents isn't confirmation, it's the same blind spot showing up twice.
A production incident traced back to a junior's agent-authored PR revealed that clean, fast diffs can ship with zero understanding underneath them — and most teams haven't redesigned onboarding to account for it.
Giving every engineer a coding agent seat multiplied throughput but not judgment capacity, and the fix was a review contract, not more seats.
A hiring-loop story about why the scarce skill in the agent era is distrust of confident-looking code, not the ability to write it.
Agent-assisted engineers aren't losing their coding skills, they're quietly losing the ability to defend architectural decisions — and the fix is a trackable ratio of decisions made versus decisions merely inferred.
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.
A billing bug that sailed through human review shows where the real skill shift is happening: writing specs precise enough that a literal-minded agent can't misread them, and deciding on purpose which parts of the system still need a human holding the whole picture.