Your teams use AI every day. The work still runs as it did before.
The problem
Volume 1 drew a map of AI adoption. This volume zooms in on one part of it. If you have not read volume 1, this page is all you need.
What is added
Horizon 2, where individual gains become changed processes. Its chapters show how to redesign the work and run a first redesign (chapters 1 and 2), what to do with the agents and tools people now build (chapter 3), how software teams build with AI (chapter 4) and how to know whether any of it is working (chapter 5). Chapter 6 takes the first steps towards Horizon 3.
Three horizons. Where the change happens: in one person’s work (Horizon 1), in a process (Horizon 2), in the organisation (Horizon 3).
Blast radius. The more a mistake could spread, the more control you need. Six questions size it: how far it reaches, what is at stake, whether AI acts or only advises, how often it runs, how sensitive the data is, and whether a person checks before it counts.
Five enablers. What must be in place to move safely: skills, knowledge, security, governance and operations.
The person is augmented. The process is not.
The problem
In the first horizon, AI changes how people find, understand and produce information. Someone summarises a long thread, drafts a note, searches years of documents, or asks for a second opinion. The work gets faster, and often better. But the process around it stays the same. The same steps, the same handovers, the same approvals.
What is added
In the second horizon, the question changes. It is no longer "how can AI help this person with this task?" It becomes "how should this process work, now that AI can read, classify, draft, check and act?" The unit of change is no longer the individual. It is the process. And in a redesigned process, people stop doing every step. They handle what the process cannot: the exception, the judgment call, the decision that needs a name attached to it.
This is not a bigger version of the first horizon. It is a different category of work.
Two horizons, two kinds of change
Because a redesign moves everyone at once, including those who would have waited, a first redesign rarely goes all the way, and should not try to. It helps to name three states a process can be in. A decorated process has AI added on top of steps nobody redrew; this chapter's pitfall describes it. A redesigned process has been redrawn with AI in mind, but the people in it still recognise it. In goal-driven work, people state the goal and the system works out the steps from the context. These are states of a process, not the three horizons, and not a score to reach.
Attachment is not the only reason steps survive. In a regulated organisation, many steps carry a control, an audit trail or a named accountability. A process that runs differently every time is harder to check than one that runs the same way every time. So the steps can loosen only as fast as the controls, the data and the people supervising the work can follow. A first redesign is a stage, not the destination: it should move people and controls forward together. Chapter 6 looks at where that direction may lead.
The technology accelerates the work. The organisation preserves the friction.
The problem
Put a modern assistant on top of a workflow designed twenty years ago, and individual steps will improve. People will draft faster, search faster, summarise faster. Then they will submit the result through the same sequence of reviews, handovers and approvals as before. The technology accelerates the work. The organisation preserves the friction.
What is added
The reflex is common. A team has a painful process that crosses several systems. Someone proposes to "connect agents" to it: one agent here to read the incoming requests, another there to update the system, a third to draft the reply. Each agent works. The process remains exactly as painful, only now it has more moving parts to maintain. The better question is not "where can we add agents?" It is: "what would this process look like if AI and automation had always been there?" Start from the whole process, then decide which parts deserve automation, which deserve AI, and which should disappear.
Worse, speed can amplify the flaws. A process with unclear ownership, inconsistent data or unnecessary loops does not become healthy because its steps run faster. It produces its errors faster, and in larger volumes. AI needs clear inputs, logical flows and consistent rules to work at scale. A convoluted process gives it none of these. You end up with a faster, more expensive broken process.
This is why process redesign is a leadership task, not a technology project. If nobody with authority is willing to ask the uncomfortable questions, AI will be added to the process as it stands. Usage will grow, training will expand, and the way the work runs will stay largely the same.
Inseparable in design, distinct in control.
The problem
A real process is a chain of steps. Some steps must run identically every time: route a request, check that a field is filled, update a system of record, send a confirmation. That is classic automation, and it is good at it. Other steps need judgment or language: read a free-text request and understand what the person actually wants, compare a document against a policy, handle a case nobody wrote a rule for. That is where AI helps.
What is added
A redesigned process mixes both, often several times over. A deterministic step routes the request, an AI step interprets it, another deterministic step checks it against the rules, and an AI step drafts the answer for a person to confirm. You cannot label the whole process "automation" or "AI". They are two kinds of step inside the same chain.
- 01Route the requestRule
- 02Understand what the person actually wantsAI
- 03Check it against the business rulesRule
- 04Draft the answerAI
- 05Confirm it, or handle the exceptionPerson
- 06Update the system of recordRule
Rule: same result every time · AI: judgment and language · Person
When a well-built step meets a missing field, it stops and asks instead of guessing.
Inseparable in design, distinct in control.
A redesigned process is a chain
Decide the tier before the product. Most large organisations run more than one automation platform, and people regularly ask which one to use. The useful distinction is not which platform is more powerful. It is robustness and ownership. Heavy, system-level processes need enterprise-grade automation, built and operated by professionals. Local workflows close to people's daily tools can use citizen-grade automation, built by the people who use them, under lighter rules. Products change; the question "which tier does this belong in?" does not. Answer it first, then choose the platform.
The first rule of building is to avoid it when you can. Before you build anything, exhaust what the tools you already own can do. Native capability first, configuration second, custom build last. The burden of proof sits with the build.
Complexity is not free. It must be earned.
The problem
Technical organisations respond to a new capability the way they were trained to: by building. Before the problem is fully understood, the requests arrive for an agent, an integration, a platform. "The standard assistant is fine for emails and meeting notes, but my problem is more complex. I need a custom agent." Sometimes that is true. Often it is a reflex.
What is added
The cost of an unnecessary build is rarely visible at the start. It appears later, as ownership nobody wants, tests nobody runs, a connector that breaks when a supplier changes an interface, an approval that must be renewed, and eventually a retirement nobody plans. Complexity is not free. It must be earned.
There is a balance to keep here, and it matters. Some wasted effort is the price of learning. A person who spends ten hours automating a one-minute task has made a poor trade on paper. But those ten hours may be how they learned the tool, and that person may later build something that saves thousands of hours. Asking "is this worth building?" before every experiment is how you create an organisation where nobody experiments. The right control is visibility and regular review, not approval in advance. Chapter 3 returns to this, and to the point where an experiment becomes something others depend on.
Most AI business cases compare a new way of doing a task with the old one. That is how automation has always been judged: it makes known activities cheaper or more reliable. AI can do that too. But its more interesting effect is different. It makes activities viable that were not worth doing before.
Three moves to make now
- Draw one process end to end. Pick a process that frustrates people and involves several teams. Draw it as it really runs today, with every handover and approval. You will find steps nobody can justify.
- Ask the redesign question before the automation question. For the next request to add AI or an agent, ask first: "If we designed this process today, what would it look like?"
- Make builds prove themselves. For any request to build a custom solution, ask what the existing tools were tried for, and who will own the result in two years. Keep experiments free; make lasting builds justify themselves.
Interlude
The compliance laboratory
A team did not look for the easiest process. It looked for one that mattered to the organisation, because that is where support comes from. Compliance was becoming more important every year, and the way it was done could not grow with it.
The idea was simple to state and hard to do: move from periodic compliance to continuous compliance. Instead of proving once a year that controls worked, check them as the work happens. Deterministic automation collects the evidence that already exists in systems. AI reads what rules cannot: free-text justifications, documents, exceptions. People look only at what the checks flag.
That is why the team called it a laboratory rather than a project. A project succeeds when it delivers. A laboratory succeeds when it teaches you something you can reuse.
The laboratory is still running, but it has already taught the team three lessons. AI still makes mistakes, and a compliance process calls for a very conservative approach. The redesign required some standardisation of how evidence is documented. And it took a lot of testing to cover different cases, because teams are not exposed to the same risks, so they do not have the same controls, or they simply work in different contexts. A team building its own software and a team configuring a platform bought as a service are both development teams, but their risks and controls are not the same.
Start with one process
The problem
Many leaders support AI. They mention it in town halls, approve licences, encourage their teams to experiment. That is useful, and it is enough for the first horizon. It is not enough for the second.
What is added
A leader can be enthusiastic about AI and still be unwilling to sponsor a process redesign. Sponsoring means making choices that cost something: which processes matter most, who owns the change, which work stops, which approvals go, which risks the organisation accepts. It means settling disputes between departments that each own a piece of the process. And it means giving people time, because redesign cannot be done in the margins of a full job.
So before you choose a process, check that three things are in place. A sponsor who will make the uncomfortable decisions, not just applaud them. People whose time is explicitly given to the work. And an agreement that the goal of the first redesign is to learn, not only to deliver.
Learn to redesign one process well, so that the next ten go faster.
The problem
The temptation is to choose the process with the biggest business case, or the one a senior leader is most impatient about. Neither is a good first choice on its own. The first redesign has a different job: it must teach the organisation how to redesign. Choose it for what you will learn, and for how many other processes that learning applies to.
What is added
One reason came first when the team in the interlude chose the compliance laboratory, and four others supported it. All five work well in general:
- It matters. It is tied to something the organisation cares about, and the current way of working will not scale. That is where support comes from.
- Visible pain. People already know the process hurts. You don't need to convince anyone that it deserves attention, and those who live it will help.
- Broad relevance. Many teams recognise the problem, even if their version differs. Success will be understood beyond the team that owns the process.
- A strong story. The result can be explained in two sentences to someone outside the project. This is what turns one pilot into a reason for others to try.
- One of many similar processes. Of the four supporting criteria, this one matters most. If the process is unique, you will learn how to fix it. If it is one of a family, you will learn how to fix the family.
Until all of that is true, the pilot stays a pilot.
The problem
Most pilots are run as smaller versions of a technical project: build it, show it works, then roll it out. That misses the point. A process redesign can fail for reasons that have nothing to do with the technology. The people cannot work with it. The knowledge it relies on is out of date. The controls do not fit. Nobody can support it once the pilot team leaves. A pilot should test the whole proposition, not only the software.
What is added
The step from pilot to lasting service deserves its own name. I call it the bridge. Crossing it has a clear definition of done: the solution's running costs are known, its versions are tracked, its dependencies are declared, it can be monitored, the way it operates is written down, and a named owner has been trained and has accepted it. Until all of that is true, the pilot stays a pilot.
- Is the problem real, and as big as we thought?
- Does the technology produce useful results on real cases, including the awkward ones?
- Can the people in the process work with it, and do they want to?
- Is the knowledge it depends on ready, or does it need work first?
- Are the controls effective, and proportionate to the risk?
- Can the organisation run and support the result over time?
Start with the least autonomy that tests the value. If advice or a draft is enough to prove the idea, do not give the system the power to act. Let it prepare, suggest and draft, and let people decide and commit. Volume 1 called this starting low on the autonomy ladder. As evidence builds and the enablers mature, autonomy can grow. This lets you learn without exposing the organisation to risks you do not yet understand.
Set decision gates in advance. Finishing the build must not mean going live automatically. At the end of the pilot, there are four honest outcomes: stop, revise, expand or scale. A solution that creates value but cannot be governed or supported needs more work. A solution that is safe but does not change the outcome does not deserve more investment. Decide the criteria before the pilot starts, when nobody is attached to the result yet.
Do not let a prototype become a service by accident. This is the most common failure. The pilot works, users like it, and it quietly becomes something people depend on, without trained users, clear ownership, monitoring or support. A working prototype without those is not progress. It is a risk nobody has decided to take.
Automation needs standard work, and can pay for it
The problem
Sooner or later, someone will say it: the foundations are not ready. The data is inconsistent, the knowledge is out of date, the controls were never designed for AI, the platform lacks a capability. So why start?
What is added
They are usually right about the foundations. They are wrong about the conclusion. You will not find out which foundations matter, and how weak they are, by studying them in the abstract. You find out by trying to run a real process on them. A pilot that hits a wall has not failed. It has shown you exactly where to build, which is information no assessment would have given you.
One discovery comes up in almost every redesign. The same process is performed differently by different teams, sites or individuals. Each variant has its reasons: a local regulation, a customer's habit, a manager's preference, a workaround that became permanent. Individually, the variants are harmless. For automation, they are a wall. You cannot automate twelve versions of a process. You can only automate one, perhaps with a few well-defined exceptions.
When organisations staff their first redesigns, they tend to look for AI skills: people who know the models, the platforms and the prompts. Those skills matter, but they are rarely the bottleneck. The rarer skill is process engineering: the ability to map how work really flows, find the root causes of delay, challenge steps that exist only by habit, design a better process and bring the people who run it along.
The model I propose sits between the two, and it has five parts.
The problem
In the first horizon, a single central team can do a lot: introduce tools, train people, support champions. As the second horizon grows, that model reaches its limits. The central team cannot know every process in every function, cannot hold deep expertise in finance, legal, operations and engineering at once, and cannot redesign work it does not own. If it tries, it becomes a bottleneck, and the business watches from the side.
What is added
The opposite extreme fails too. If every unit transforms on its own, teams solve the same problems repeatedly, choose different tools for similar needs, duplicate investment and set diverging standards. Nothing dramatic happens. Value simply dilutes across many disconnected initiatives, and lessons stay local.
- A central team introduces new capabilities. When a new generation of AI or automation capability arrives, a central team assesses it, pilots it on real work and learns what the enablers need: which skills, which knowledge, which controls, which operating rules. It does this before the capability reaches everyone. This team stays central at every scale: it prepares the organisation to adopt each new capability, so that redesign can continue.
- Enablement grows the skills. Training, communities and support help people and teams become fluent with each new capability, matched to their role, as volume 2 described.
- Local transformation teams, as the organisation scales. Each major unit has dedicated people who own the redesign of its processes. They are funded and have a mandate, and they are sponsored by the unit's own leaders. This is a real role, not a volunteer activity on top of a full job. How many such teams, and how soon, is the organisation's own decision: the larger the organisation or the ambition, the more of them it needs. Volume 1 described what happens when champions are given a mission without a mandate.
- Shared engineering capacity for the heavy work. Some solutions are "tractor-grade" (chapter 3): they touch critical systems, run unattended or serve many people. Those need professional engineering, which local teams should draw on from a shared pool rather than recreate.
- A coordinating body with authority. Someone must set the standards, decide what is reused rather than rebuilt, and handle processes that cross several units. This body needs real authority, not only good intentions. Alongside it, a community of practice circulates what people learn. The community shares; the coordinating body decides.
Three moves to make now
- Test your sponsorship. For the process you most want to redesign, write down the three decisions it will need (an approval removed, an owner named, a team's way of working changed). Ask your sponsor whether they will make them. Their answer tells you whether you are ready.
- Choose your laboratory. Check first that the process matters to the organisation. Then score your candidates on the four other criteria of 2.2, with extra weight on "one of many similar processes". Pick one.
- Write the gates before you start. Agree what evidence would lead you to stop, revise, expand or scale, and what the bridge to a lasting service requires. Share it with the control teams on day one.
Free to build, not free to own
The problem
For most of the history of computing, building software required rare skills, and that scarcity was a kind of control. Only a few people could build, so only a few things got built, and most of them passed through a formal process.
What is added
People build software in four different modes today, and most debates about "citizen development" or "vibe coding" go wrong because they mix them up.
The engineers are right, and it does not matter. Think of a farmer. To plough large fields, the farmer needs an industrial tractor: heavily engineered, carefully maintained, closely monitored, because the harvest depends on it. Around the farmhouse, the same farmer uses a robotic lawnmower. Nobody knows exactly how it works inside, and if it breaks, it is cheaper to replace than to repair.
Engineers are trained to build tractors, and they judge vibe coding as if it were one. As a tractor, it is terrible. But a lawnmower does not need a tractor's engineering. Its opacity does not matter as long as the grass is cut. The reverse is just as true, and just as important: nobody should plough a field with a lawnmower.
Contain with the environment, not with prohibition
The problem
The first instinct of most organisations is to sort risk by builder. Engineers can be trusted; business users need supervision. It sounds reasonable, and it fails as soon as you look at how things actually go wrong.
What is added
Weak code and ungoverned software are cheap to contain. The controls can live in the environment rather than in rules about who may build. Let people build freely, but inside a space where applications cannot call production systems directly, where calls to shared systems go through a gateway that enforces limits, where secrets and dependencies are scanned automatically, and where nothing leaves the space without passing a check. The application that would have overloaded the ticketing system hits a rate limit instead. The one that breaks on Monday breaks inside a sandbox, not in front of a hundred colleagues. The builder barely notices the constraint. The limit is on where things can run, not on whether people can build.
Most organisations frame this as a single dial: more control means less innovation, more freedom means more risk. That framing produces bad policies, because the cost of control is very different from one risk to the next.
Resist that instinct. The slop phase is a necessary step in the journey, not a mistake to prevent: you can only govern what you know and understand. That volume tells you things no strategy paper could: that people are engaged, which needs are real, how people actually use the tools, where the pitfalls are, and therefore what the learning journey must cover, and which early adopters are ready to become the champions of the next phase. Heavy restrictions imposed too early do not stop the behaviour. They push it onto personal accounts and unmonitored tools, where you can see nothing at all.
The condition is containment. Slop inside a contained environment is discovery. Slop that reaches shared systems, sensitive data or customers is a risk. Do not wait for the pain to tell you it is time to add structure. By the time engineering pipelines choke on the volume of generated code, search and retrieval stop finding the truth under the pile of generated documents, or risk teams discover applications running on personal credentials, the clean-up is long and costly. Watch for the early signs instead: a tool others start to depend on, one that runs unattended, one that writes to a system of record or touches sensitive data. Those are the crossing signals of 3.4, and they call for structure as soon as they appear. Free to build does not mean free to own.
This is the same idea as in volume 1: a gate, not a wall.
The problem
Most things people build stay small, and should. A personal assistant that sorts your own notes, a quick application to prepare one workshop, an agent that drafts replies you always check. Those are lawnmowers. Let them be.
What is added
The problems start when a lawnmower quietly starts ploughing. It happens gradually, and nobody decides it. A colleague asks for a copy. The team starts relying on it every morning. Someone connects it to a shared system to save a step. Six months later, a tool built in an afternoon has become part of how a process runs, with no owner, no tests and no support.
Tool · The crossing rule
The crossing rule gives you four signals that a tool has crossed that line. It has crossed when any one of these becomes true:
Others depend on it. It is no longer used only by the person who built it.
It runs unattended. It acts on a schedule or on events, without a person checking each result.
It writes to a system of record. It changes data that other people and processes treat as the truth.
It touches sensitive data or customers. Personal data, confidential information, or anything that reaches people outside the organisation.
Those are lawnmowers. Let them be.
When a tool crosses, you have two choices, and "leave it as it is" is not one of them.
Contain it. Pull it back inside the line. Promote it. Treat it as the tractor it has become.
This is the same idea as in volume 1: a gate, not a wall. People can cross, and should when a tool proves its worth. But the crossing is deliberate, visible and checked.
The rule also answers a question that divides many organisations: should business users be allowed to build at all? Yes. Who builds matters for one thing only: whether the people running the tool can tell when it is wrong. Once a tool crosses the line, the builder no longer matters. An engineer's quick script that starts writing to a production database has crossed just as surely as a business user's application.
You cannot govern what you cannot see
The problem
A growing estate of agents and applications needs the same basic care as any other set of assets: knowing what exists, noticing when it changes, knowing what it costs, and removing it when it is no longer needed. None of this is glamorous. All of it is usually missing.
What is added
Keep an inventory. Every agent or application that others use should be registered somewhere: what it does, who owns it, what it connects to, who uses it. Make registration effortless, ideally automatic when something is shared or connected. An inventory that depends on people filling in forms will always be incomplete.
Watch for drift. An agent that was harmless when it was approved does not stay that way on its own. Its underlying model is updated by the supplier, or the software around it changes. Its instructions were tuned during testing to how that model behaved; with a new version, or even a different mode of the same one (a quick answer instead of extended reasoning), the same instructions can give different results. I have seen it happen. Each such change means testing the agent again, and that testing should be automated. Watch for signs of drift in everyday use too: if conversations between a customer-facing assistant and customers are getting longer, or more of them are being handed back to people, something has changed. Someone edits its instructions. It is given access to a new data source. More people start relying on it for more important work. Each change can move it across the line without anyone deciding it. The crossing rule is not a one-time check. It must be applied again whenever something material changes, and at regular reviews.
Tool · Try this · The ten-question agent readiness check
Before you share an agent or an application with anyone else, answer these ten questions. If you cannot answer one, that is your next task. If your answers to questions 3 to 6 say it has crossed the line, contain it or promote it.
Purpose
01 What problem does it solve, and what did you try first?
02 Who owns it?
The crossing signals
03 Who depends on it? Only you, your team, or people you do not know?
04 Does it run on its own? On a schedule or on events, without a person checking each result?
05 What can it change? Does it only read and suggest, or does it write to systems others rely on?
06 What data does it touch? Personal, confidential or customer data? Which systems does it connect to?
Safety and quality
07 How do you know it gives the right answers?
08 What happens when it fails, and how do you stop it?
Lifecycle
09 What does it cost to run, and who pays?
10 When will it be reviewed, and what would lead you to retire it?
If your answers to questions 3 to 6 say it has crossed the line, contain it or promote it.
If you cannot answer one, that is your next task.
Three moves to make now
- Find out what exists. Ask for a list of every shared agent and application in your area, with its owner and what it connects to. The gaps in the list are your first finding.
- Apply the crossing rule to the top ten. For the ten most used, check the four signals. Contain or promote each one that has crossed.
- Move one control from rules to environment. Pick one risk you currently manage by restricting who can build, and replace it with an environmental control: a sandbox, a gateway, a rate limit.
Code is cheap, checking is not
The problem
Software development was the first profession to feel the full force of AI, and it is still the one where the change goes deepest. Coding assistants were among the first tools large organisations deployed. Engineers were among the first to use agents daily. What happens in software engineering is a preview of what will happen, a little later, to other forms of knowledge work.
What is added
Now look at the release cycles of most enterprise software teams. Nobody is delivering sixty-two times faster. The reason is simple, and it took the industry a while to admit it: writing code was never the main bottleneck. Understanding what to build, fitting it into an existing system, checking that it works and is secure, and keeping it running: those were always the slow parts. AI accelerated the one step that was already the fastest. Call it the difference between agentic coding and agentic engineering.¹ Agentic coding is AI writing code, and it has become almost effortless. Agentic engineering is everything that turns code into reliable software: planning from a specification, verification, review and security testing. That is where the bottleneck now sits.
The result, in many teams, is a new kind of congestion. Reviews pile up because nobody can meaningfully read ten thousand lines produced in an afternoon. Test teams are overwhelmed. Technical debt grows even though coding is faster. The pressure has moved downstream, onto the people who check. And those people tire. Faced with more than they can read, they skim, approve by default, or lose interest in a job that has turned into checking someone else's work.
Automate the gate, not only the accelerator
The problem
AI agents change the balance. An agent has none of the implicit context a human colleague picks up in the corridor. It does not know the unwritten business rules, the reason behind an odd design choice, or what the product owner meant but did not say. Give it a vague request and it will not ask for clarification the way a colleague would. It will produce something plausible, polished and wrong, at scale.
What is added
The answer is to use AI and automation on the gate as well. Before a person opens a change for review, automated checks should already have run: security scanning, dependency and secrets checks, quality analysis, tests, and even a first round of proposed fixes. Human reviewers then spend their attention on what machines cannot judge: whether the design is right, whether the change does what the business needs, whether it fits the system. This is the review assistant volume 2 described, applied to code.
So the specification comes back, in a different form. Not a hundred-page document written once and forgotten, but a precise, structured description of what must be built, stored with the code, versioned with it, and read by the agent every time it works. This is spec-driven development: the specification drives the generation, the way source code used to drive compilation. Writing it well becomes the main act of programming.
Most organisations started by using AI to write code faster. That is pressing the accelerator. The gate, the checks that stand between code and production, stayed manual. It is no surprise that it jammed. Volume 2 described the same jam in knowledge work: review fatigue, when people are asked to check more than they can read. Software teams feel it first and hardest.
Specialisation does not disappear. It moves up. Value used to come from the difficulty of execution: only I can write this code. It now comes from clarity of intent and quality of judgment: I know exactly what to ask for, and I can tell whether the result is right, secure and maintainable.
Speed is no longer the constraint; judgment is.
The problem
Leave AI in software delivery to grow on its own, and every team will end up using the tools differently. Different prompts, different agents, different ways of checking, different ideas of what "done" means. Each team may be productive. Together, they become impossible to govern, support or learn from.
What is added
The two work as a loop. Someone experiments with a new way of working. The community tries it, compares it and evaluates it. The ones that prove safe, effective and reusable go to the council, which turns them into standards. The pipeline enforces the standards, so they apply without a gatekeeper. And because the tools change so fast, every standard has a review date. A rule written for last year's tools should expire, not linger.
The community of practice is the club. It is where practitioners share what works: prompting strategies, reusable agents and skills, patterns, lessons from failures. It is voluntary, energetic and indispensable. But a club cannot mandate anything. It cannot set security boundaries, enforce a definition of ready, or answer to a regulator when AI-generated code introduces a vulnerability.
The engineering council is the enforcement body. It sets the rules the community works within: which practices become standards, which boundaries are fixed, how risk is managed, what the pipeline enforces. When something goes wrong, it is the body that owns the answer.
On a five-year view, it is a trap. Senior engineers do not come from job adverts. They come from the hiring and training decisions made three to five years earlier. The judgment this whole chapter depends on (knowing whether generated code is elegant, scalable and secure; knowing whether a specification solves the real need) is built by years of doing the work, making mistakes and being corrected. Remove the first rung of the ladder, and in a few years there is nobody left to climb to the top. You cannot prompt a senior engineer into existence.
Three moves to make now
- Find where your bottleneck moved. Ask your engineering teams where work waits longest today: specification, review, testing, deployment. Invest there, not in more generation.
- Separate the club from the council. If you have a community of practice, keep it. Then name the body that sets and enforces standards, and give every standard a review date.
- Check your junior pipeline. How many entry-level engineers did you hire this year, and how are they learning to judge generated code? If the answer is "none" or "we don't know", fix it before it becomes a senior shortage.
Time saved is an input, not an outcome.
The problem
The most common AI metric is minutes saved. Someone completes a task ten minutes faster, multiply by the number of users and the number of working days, and the business case writes itself.
What is added
Except that the organisation does not automatically capture those ten minutes. They may be spent improving another document, helping a colleague, reading one more email, or simply coping with a workload that keeps growing. Volume 2 showed where saved time often goes: into more work of the same kind, and into the review load that AI creates. Time saved is real, but it is an input. What matters is what it turns into.
How hard to verify? In 2025, the research organisation METR asked 16 experienced open-source developers to work on 246 real tasks from their own projects, with AI tools allowed on tasks chosen at random.1 Before starting, the developers expected AI to make them 24% faster. Afterwards, they believed it had made them about 20% faster. Measured, they were 19% slower. The study covered one setting, mature code its developers knew well, and does not show that AI tools are unhelpful in general.
People’s own estimates of time saved can be far from what happened, and many “hours saved” reports are built on exactly those estimates.
Time to complete real tasks: 16 experienced open-source developers, 246 tasks from their own projects, AI tools allowed on tasks chosen at random. METR, 2025 (footnote 1).
Minutes saved are easy to claim and hard to verify.
Felt faster, measured slower
There is a deeper irony. Many organisations never measured the productivity of their knowledge workers before AI. They had no reliable figure for how long a proposal, an analysis or a review took. Yet they now ask for a precise calculation of how much AI improved it. They are trying to measure the movement of a number whose starting value was never known.
The masters come first.
The problem
Imagine giving a team a big box of Lego. On the cover is a picture of a house. Most leaders, under pressure to show results, immediately measure how much faster the team can build that house: in AI terms, how much faster people write an email or summarise a document. They might see a small gain, which then disappears into other work. Disappointed, they conclude the investment is not paying off.
What is added
That misses the purpose of the first box. Its job is not to build the house on the cover faster. It is to teach the builders how the bricks connect, what shapes are possible and where the limits are. The first investment is in the builder, not the building. Once people become masters, they stop following the instructions on the box. They start building things nobody printed on the cover.
Gartner presents these as a portfolio an organisation holds at the same time, not as steps in a sequence. But they map closely onto the three horizons of this series. Individual augmentation is mostly Defend. Process redesign is Extend. Changing the operating model is Upend. And the order matters in one respect: people who have never become fluent with the tools will not spot the Extend opportunities in their own work. The masters come first.
So the return has two parts, and they multiply each other. The first is how much exploration the organisation can afford: time reinvested in trying ideas, and how fast each idea can be tried. The second is its capacity to industrialise the few that prove themselves, which chapter 3 described: the crossing rule, and the rebuild with engineering discipline. Plenty of exploration with no capacity to industrialise produces demonstrations. Industrial capacity with no exploration produces efficient versions of old ideas. You need both.
Financial return is a lagging indicator: it tells you what already happened, often long after the decisions that caused it. In the early stages of AI adoption, you need leading indicators, signals that predict whether value is on its way.
Two cautions. First, leading indicators are easy to game. Usage can be inflated by mandatory training exercises, satisfaction scores by pleasant sessions that change nothing. Look for evidence in the work, not only in the dashboard.
An organisation that never stops anything is not measuring; it is advertising.
The problem
AI programmes produce a lot of activity, and activity is easy to count: licences activated, features announced, people trained, pilots launched, agents built. Those numbers describe effort. They do not prove that the organisation has become more capable. A programme can grow on every one of them while the way the organisation works stays the same.
What is added
The discipline is simple to state: for every activity you report, ask what outcome it is supposed to produce, and measure that. The right outcome changes with the horizon.
5.5 Separate activity from outcome, horizon by horizon
Use measurement to stop things, not only to justify them. The best reason to measure honestly is that it tells you what to drop. A pilot that is safe but changes nothing deserves to stop, as chapter 2 said. So does a tool that is widely used but produces no visible outcome. An organisation that never stops anything is not measuring; it is advertising.
Three moves to make now
- Audit your AI report. Mark every indicator as activity, signal or outcome. If more than half are activity, rebuild it around the table in 5.5.
- Start a baseline before your next pilot. Measure the process for a few weeks before anything changes, so that you will have a “before” when you need it.
- Ask the Lego question. In your next review, ask not “how much faster are we doing what we did?” but “what are people now building that was not on the box?” Collect those examples. They are your leading indicator for the second horizon.
Today, people are the integration layer.
The problem
Look at the systems a large organisation runs on. One for documents and email. One for people and HR. One for service tickets. One for finance. One for customers. Each was chosen at a different time, for good reasons, and each is good at its job. Each also has its own screens, its own navigation and its own login.
What is added
Now look at what it takes to get one thing done. Find the context in one system. Find it again in the next. Copy a reference from one to another. Wait for an approval in a third. Stitch the result together by hand. No individual system is badly built. The problem is the seams between them. And who fills the seams? People. Today, the human is the integration layer. It is an expensive use of judgment that nobody would design on purpose.
Take a simple case. You want to take a week of leave. You open the HR system and file the request. Your manager approves it in the same system, or by email. You block your calendar. You set an out-of-office message. You delegate a few approvals. You move or decline the meetings that fall in that week. Six steps, four systems, and not one of them requires real judgment.
For most of their history, business applications competed on the experience they offered to people: better screens, easier navigation, more pleasant workflows. In a world where agents do more of the work, that matters less. What matters more is whether the system can be trusted.
The third horizon begins when the organisation's assumptions change
The problem
The first horizon changes what individuals do. The second changes what processes do. The third changes what the organisation is.
What is added
Chapter 1 described one way this may begin. Each redesign is a stage. As people and controls catch up, the fixed steps of a process can loosen, towards what that chapter called goal-driven work: people state the goal, and the system works out the steps from the context. How far that can go is not known. In a regulated organisation, it will go no faster than the systems behind it can be trusted, as 6.2 described.
It is tempting to describe the third horizon as "more automation" or "more autonomous agents". That misses the point. The second horizon can already include sophisticated agents and large automated processes. The third begins when the assumptions the organisation is built on stop holding: that work flows through a fixed sequence of roles, that each function owns its step, that management means directing people.
When generating text, code, images and documents costs almost nothing, organisations produce more of all of them. Much of it is individually fine. Nothing is technically wrong with the long report, the polished email, the well-structured page on the intranet. But it was generated without a real reader in mind, and it multiplies faster than anyone can absorb it. That is AI slop, and it is the most immediate side effect of everything described in this series.
What these volumes have tried to show is that the roads are not made of technology.
The problem
The first chapter of volume 1 began with an image: a hundred thousand cars dropped into a city that had no roads, no rules and no driving licences. As volume 1 put it, the technology arrived before the roads. Three volumes later, the image still holds. The cars keep getting faster. The roads are still being built.
What is added
What these volumes have tried to show is that the roads are not made of technology. Any organisation can buy the same models, hire the same consultants and sign with the same suppliers as its competitors. Those things are available to everyone, so they cannot be what makes the difference. What makes the difference is organisational, and it cannot be bought:
- Leaders who can tell activity from value.
- Leaders fluent enough to govern the technology they are adopting, because they use it themselves.
- The courage to redesign processes rather than decorate them with assistants.
- Governance built from experience, which accompanies adoption rather than standing in front of it.
- Local initiative connected to shared standards, so that every experiment makes the next one smarter.
- People who keep their judgment sharp while the machines do more of the work.
- An ambition for AI that goes beyond doing the same work with fewer people.
None of these is new. Good organisations have always needed them. AI simply makes their absence visible faster, and more expensively.
For now, the advice is simple. Get out of theory land. Use the tools yourself. Build the roads while the cars are arriving. And remember that the work that matters most, on this journey, is still done by people.
Three moves to make now
- Count the seams. Pick one common request in your organisation (leave, onboarding a new joiner, a supplier payment) and count the systems a person must cross to complete it. That number is the cost of people acting as the integration layer, and a map of where a conversational front door would help first.
- Ask your key suppliers about trust. At your next platform review, ask not only about new features, but how the platform will let agents act safely: controlled actions, audit trails, permissions that hold across systems.
- Reward curation. In your own team, praise the shorter document, the page removed, the answer in three lines. Make it visible that less, done well, counts.
Tool · Self-assessment
Are you changing the work, or decorating it?
This volume is about the step where most organisations stall: moving from people using AI to the organisation changing how its work is done. These twelve questions show where your organisation stands on that step, and what is most likely to block it.
Twelve questions for the second horizon
Answer yes or no. A "partly" counts as no.
01 Has at least one process been redrawn end to end before any AI or automation was added to it? (Ch. 1)
02 Must a request for a custom agent or application show which existing tools were tried first, and who will own the result? (Ch. 1)
03 Does your first process redesign have a sponsor who has agreed to make the uncomfortable decisions: an approval removed, an owner named, a way of working changed? (Ch. 2)
04 Were the decision gates (stop, revise, expand, scale) agreed before the pilot started, including what it takes to become a lasting service? (Ch. 2)
05 Are there people whose time and budget are formally given to transforming processes in each major unit, rather than volunteers doing it on top of their jobs? (Ch. 2)
06 Can you list every shared agent and application in your area, with its owner and what it connects to? (Ch. 3)
07 When a tool starts to be relied on by others, runs unattended, writes to a system of record or touches sensitive data, is it either contained or rebuilt properly? (Ch. 3)
08 Are most AI building risks contained by the environment (sandboxes, gateways, limits) rather than by restricting who may build? (Ch. 3)
09 Must a specification be agreed before AI agents write production code, and do automated checks run before every human review? (Ch. 4)
10 Is there a body with authority to turn good engineering practices into standards, and does every standard have a review date? (Ch. 4)
11 Does your AI reporting measure outcomes (cycle times, errors, risks removed) and not only activity (users, licences, hours saved)? (Ch. 5)
12 In the last year, has measurement led you to stop at least one AI initiative? (Ch. 5)
How to read your answers
- This is not a score. Don't add up your yeses. One unowned agent writing to a system of record can matter more than eleven good answers.
- Start with three questions. A no to 03 (a sponsor who decides), 06 (knowing what exists) or 07 (the crossing rule) comes first, whatever else you answered.
- For every no, write three things. Who owns it. What evidence would turn it into a yes. The next action, with a date.
Start with these
One warning. If you answered yes to almost everything, ask someone two levels below you to answer the same questions. The gap between the two sets of answers is often the most useful finding.
The map, zoomed in