← The ADLC library
Engineering leadership
A desk of the Fastpace GroundTruth library
What happens to the people when the code writes itself.
The shape of engineering organisations after generation stops being scarce: where the bottleneck moves, what a staff engineer is for, how review and on-call change when nobody remembers writing the code, and which of the old rituals are worth keeping.
FoundationsRoles & orgSDLC vs ADLC 55 articles
Articles
- Blast radius beats diff size Every review process on earth triages by lines changed, because for thirty years lines changed was a decent proxy for effort and risk. Generation broke that proxy. What a change can reach now matters far more than how big it is.
- Your review SLA is making quality worse A four-hour review target puts a number on the one variable you should let float. There is always a way to hit the clock, it is called approving, and under agentic volume that is exactly what the target buys you.
- The review comment that engages with nothing A nit about a variable name used to be harmless. On a generated pull request it is often the only recorded evidence anyone looked, and it certifies a review that did not happen. The unreviewed merge is not the worst category.
- The rubber stamp leaves no artifact A careful forty-minute review and a ninety-second scroll produce identical records in your system. No amount of analysis of approval data can separate them, which means the fix is not another metric. It is changing what a review emits.
- Against uniform review One review policy applied to every change is why review is collapsing. You already have tiers, set by whichever diff happened to look boring on a Thursday afternoon. The only real question is whether you chose them.
- Pickup time is the metric your dashboard is hiding The interval between a change being ready and a human first looking at it is where delivery time now accumulates. It is also the only number that measures whether your engineers are willing to open the diff.
- Trust in AI output fell to 29%. That is the correct direction. A falling trust number is usually read as an adoption problem to be managed. It is calibration improving. The real problem is that stated trust and actual behaviour are moving in opposite directions.
- Merge on green is a policy. Choose it deliberately. Most teams already merge on green. They just have not admitted it, so nobody has decided what green needs to mean. Undeclared merge-on-green is the worst of both worlds.
- A model reviewing a model is not verification Pointing a second model at the first one's output feels like a control. It is a filter with correlated blind spots, and the confidence it manufactures is the dangerous part.
- What review is for when the author cannot explain itself Code review was always half a conversation with a person who held the intent. Remove the person and most of the ritual stops working. What survives is narrower and more valuable than what we lost.
- What Bitbucket automation does, and exactly where it stops Bitbucket never set out to be an automation platform, and understanding that saves you a week of looking for features that were never there. What it does have is enforcement at the merge, and that is the part worth using properly.
- The zero-review merge is the only number that matters Most review metrics can be satisfied without anybody reading anything. The rate at which changes reach production entirely unread cannot. It is the one figure I would put on a wall.
- The ADLC in one diagram, explained slowly Six stages and two loops. Most of it is your existing life cycle unchanged. The parts that are new are new for a specific reason, and it is worth walking each one at reading pace.
- Branch and PR conventions that survive contact with Asana Asana has no short issue key, so the usual branch naming advice does not apply. Here is what to link instead, how to mint a human-typable key if you really need one, and how to check it is working.
- What Azure DevOps automation does, and exactly where it stops Azure DevOps has four separate automation surfaces and none of them is a general rules engine. Here is what each one is genuinely good at, and the exact point where you have to write code.
- What GitLab automation does, and exactly where it stops GitLab's answer to almost every automation question is a CI job, which is more powerful than a rule builder and much less convenient. Here is what that trade costs you, and the four places it genuinely runs out.
- What Linear automation does, and exactly where it stops Linear automates more out of the box than most trackers do after a month of configuration, and then offers almost nothing between that and writing GraphQL. Here is how to work with the missing middle rung.
- On-call for code nobody remembers writing Incident response has always leaned on a hidden asset: somewhere in the organisation, a human remembered building the thing. That asset is quietly disappearing, and most runbooks assume it is still there.
- What the SDLC got right that we should keep Nine pieces arguing that the old life cycle rested on broken assumptions. This one argues the other side: which practices were load-bearing for reasons that have nothing to do with who writes the code.
- Autonomy versus control is a false binary The choice everyone thinks they face is how much to let agents do. The actual choice is how much you can verify, and it is verification, not restriction, that buys autonomy.
- Branch and PR conventions that survive contact with Bitbucket Bitbucket and Jira will link your branches, commits and pull requests to issues automatically, if the key is present. Here is what the native linking covers, the account-mapping trap that silently breaks it, and how to check.
- Handoffs: fewer people, more machine boundaries Lean thinking taught us that every handoff is waste. Agentic teams have fewer human handoffs and considerably more boundaries, and the new ones fail differently: silently, plausibly and at speed.
- Hiring for the ADLC, and what to screen for now Technical interviewing was calibrated to predict who could produce correct code under time pressure. That signal is now cheap to fake and less predictive of the job, and almost nobody has rewritten the loop.
- Branch and PR conventions that survive contact with Linear Linear will move issues through your workflow on its own, but only for branches that carry the identifier. Here is how the matching actually works and how to catch the work it never sees.
- Documentation that regenerates itself We can now generate accurate descriptions of what code does, cheaply and continuously. That solves the smaller half of the documentation problem and makes the larger half more urgent.
- Team shapes when throughput stops tracking headcount Almost every planning assumption in a modern engineering organisation rests on output being roughly proportional to people. Break that link and team design, capacity planning and the org chart all need different logic.
- What a life cycle even is, and why yours is implicit Nobody at your company wrote down how work becomes software. It happened anyway, by accumulation, and the parts nobody chose are the parts that fail first under speed.
- Linking Bitbucket work to code, reliably Bitbucket's link to your tracker is built from issue keys in branch names and commits. Here is what Cloud and Data Center each give you, where the link silently drops, and how to close the gap.
- Branch and PR conventions that survive contact with GitLab How to name branches and merge requests so GitLab links them to issues on its own, what its native referencing actually covers, and where the automatic link quietly stops working.
- Ground truth as an organising principle Every record in your company is a copy of something except one. Deciding which artefact is authoritative, and deriving the rest from it, turns a hundred small arguments into one design decision.
- The pull request as the new unit of governance Every control an organisation cares about is converging on one artefact that was designed for none of them. That is mostly good and worth doing deliberately rather than by accident.
- QA does not disappear, it moves left and up Testing has been declared dead twice in twenty years and has come back larger each time. The agentic life cycle does not remove the need for quality work, it relocates it to the two places nobody staffed.
- Sprint boundaries in a world of hourly cycles The two-week sprint was a batching decision made when planning was expensive and deployment was risky. Both costs collapsed. What remains is a rhythm, and rhythm is worth more than most people think.
- Why the tracker became the weakest link Jira did not get worse. The world it was designed for stopped existing. Understanding what it quietly assumed explains why it fails now in a way that no configuration can fix.
- The bottleneck moved, from typing to verifying Speeding up one stage of a pipeline does not speed up the pipeline. It moves the queue. Here is where the queue went, and why verification is a much harder constraint than production ever was.
- What code review becomes when most code is generated Review was designed for a world where writing code was slow and expensive. Both halves of that assumption have broken, and the ritual has not been redesigned to match.
- Why "AI writes code" is the least interesting part of the shift Code generation is the visible half of the change and the settled half. The unsettled half is everything the act of writing code used to hold together on its way past.
- Linking Linear work to code, reliably Linear's git integration is the best-designed one on the market and it still leaks. Here is exactly how the branch-name link works, the four ways it breaks, and what to do about each.
- QA: what changes when tests are also generated A green suite used to be evidence because a human wrote the assertions from a different understanding than the code. When one system writes both, the independence disappears and the signal quietly weakens.
- The staff engineer in an agent-heavy codebase When generating code stops being the constraint, the highest-leverage engineer in the building stops being the one who writes the most of it. What replaces that is less glamorous and considerably more important.
- Standups: the ceremony agents made obsolete The daily standup was a synchronisation protocol for a system with no other way to read its own state. Most of what it transmitted is now derivable. The part that is not is worth protecting deliberately.
- Linking Azure DevOps work to code, reliably Azure DevOps can refuse to complete a pull request that has no work item attached. Here is how the linking actually works, when to turn that policy on, and what it still will not catch.
- Engineering managers as system designers When output stops being scarce, managing output stops being the job. What is left is designing the queues, the gates and the loops that decide whether the output is any good.
- Linking GitLab work to code, reliably GitLab links issues to merge requests better than any other combination on the market. Here is how the mechanism works, the four ways it still slips, and how to measure the gap.
- The product manager's job in the ADLC When code stops being the constraint, the specification becomes it. That is a promotion for product management and a much less comfortable one than it sounds.
- Code review: from gatekeeper to sampler Reading every diff was always a fiction, and agents turned it into an obvious one. What replaces it is not less rigour but rigour aimed at classes of change rather than individual ones.
- Review is the bottleneck. Adding reviewers will not fix it. The numbers on agentic pull requests are worse than most teams realise, and the obvious response is the one that reliably fails. Queue length is a system property, not a staffing gap.
- Who actually writes your code now, an honest audit Most teams have a confident opinion about how much of their code is agent-written and no evidence for it. Here is how to find out, and why the answer is usually uncomfortable in both directions.
- Linking GitHub work to code, reliably Closing keywords, the development sidebar and Projects automation do more than most teams use. Here is how the link is really made, where it silently fails, and how to measure your own linking rate.
- Linking Jira work to code, reliably How Jira's development panel actually gets filled in, the handful of ways the link silently fails, and how to get linking rate close to 100 percent without adding ceremony.
- Planning: from estimation ritual to derived plan Estimation was never really about accuracy. It was a scheduling device for scarce human attention. When the attention stops being the constraint, the ritual stops paying for itself.
- Requirements: prose for humans versus criteria for agents A ticket written for a colleague and a ticket written for an agent look almost identical and behave completely differently. The gap between them is where most agentic rework comes from.
- What a TPM does when the chasing stops Most of a technical program manager's week is spent reconstructing a status that already exists somewhere. Take that away and what is left is the part that was always the job.
- The two assumptions the SDLC was built on, and why agents break both A human wrote the change. A human kept the plan honest. Take those apart one at a time and you can see exactly which load-bearing wall agents removed.
- What we mean by the Agentic Development Life Cycle The SDLC rested on two quiet assumptions. Agents break both, and most of the pain teams are feeling right now is the sound of that breaking.
The other desks
Delivery & program intelligenceWhat the numbers do when agents arrive. Governance, security & complianceThe questions an auditor will ask, before they ask them. Product & acceptance criteriaDone, defined precisely enough that a machine can check it. Platform economics & toolingWhat this actually costs, and what it is worth.