How I run it

1

The four questions

One workflow at a time. An hour with the two or three people who do it.

Point AI at the wrong part of the job and the saving is small. The fourth question is the one people skip, and it's usually the one that changes the answer.

1. What is the job to be done? Not the task in the process map: what the person is actually trying to achieve.
2. What pain does it remove, for the person doing it and for the customer waiting on it?
3. What gain does it create: time, quality, revenue, or something the customer couldn't have before?
4. What happens five minutes before it, and five minutes after? Time the whole thing end to end, not just the work.

The reasoning is in Where the time actually goes →

Take it with you: Working files on GitHub

2

Delete, automate, augment

Straight after the four questions, step by step, with the same people in the room.

Automating a step that should have been deleted is the most expensive way to keep it. It now has a vendor and a maintenance cost.

1. List every step in the workflow, including the waiting and the rework.
2. For each step ask what happens five minutes before and after it, then put it in one of three piles.
3. Delete first. Report what you deleted before you report anything you automated.

The reasoning is in If the AI becomes the business →

Take it with you: Working files on GitHub

3

Stages and gates

Before anything is built. One page per initiative, and the owner decides at each gate.

Agreeing first what would make you stop is what makes stopping possible, and it's also what lets you be generous early: in ideation and design, being wrong is cheap, so run more ideas than feel sensible and let the gate decide. AI makes every stage faster. It doesn't remove a gate, and it doesn't mean jumping straight to scale.

1. Write down, before the work starts, the result that would make you stop.
2. Be loose at the start and strict at the end. Try more in ideation and design; tighten at execution, because that's where it touches customers and the cost base.
3. Take a baseline before you build, so there's something to measure against.
4. At every gate, decide in the room: carry on or stop, on the measured evidence.
5. Publish what you stopped beside what you scaled. It's what makes the wins believable.

The reasoning is in Where the time actually goes →

Take it with you: Working files on GitHub

4

The two columns

Kept by whoever holds the budget. Looked at monthly.

Time saved isn't money until someone banks it. A buyer's diligence team discounts the first column heavily and pays for the second.

1. Claimed: every saving a tool is said to produce, with where the estimate came from.
2. Banked: only what passed one of two tests in the same quarter. The freed time went to named work that earns, or the cost left the accounts.
3. A line moves across when someone can point to it in the accounts. Never on a forecast.
4. The ratio between the columns is the finding. Report both together.

The reasoning is in If the AI becomes the business →

Take it with you: Two columns template (CSV) · Working files on GitHub

5

The test set

One per workflow. Start with thirty cases.

The real answer to “how do you know it works?”. It's also what lets you test a new model in a day rather than a quarter.

1. Ask the people who do the work best to pick real cases from the last two years: clear passes, clear fails, and the awkward ones in between.
2. Mark the right outcome, and for the fails, why. Strip anything that mustn't leave the business.
3. Version it. Never share it with the vendors whose models it tests. Their tools may run it; they never write it.
4. Run it on every change to an agent (model, prompt, data, version) before it keeps its grade.
5. Refresh a share every quarter. A set nobody has touched in a year is measuring last year's business.

The reasoning is in Earned autonomy →

Take it with you: Working files on GitHub

6

The grades and the gates

Set the criteria in writing before anything is measured against them. One set for the whole company.

Autonomy is a grade an agent earns against criteria published in advance, and loses automatically. A grade like that is a control an auditor can test. Autonomy that was assumed is a liability nobody has priced.

1. Every agent starts at Observe, whatever the vendor says it can do.
2. Write the gate for each grade, with your own thresholds, and publish it first.
3. Demotion is automatic: drift against the test set, too many exceptions, a new market, or any change to what it may touch.
4. Report demotions beside promotions, so the promotions can be trusted.

The reasoning is in Earned autonomy →

Take it with you: Working files on GitHub

7

The register

A shared spreadsheet, one row per agent. Live in a week.

With it you can say what is acting in your name, on whose authority, how well it works and what it costs. If it isn't on the register, it doesn't run.

1. Every agent declares ten things. Anything not declared is denied.
2. The supervisor is a named person. Never a team, never a role title.
3. Any change to what it may touch or look up is a new version. It goes back to Observe. A new model is re-tested before it keeps its grade.
4. Once a month, look at the whole register together.

The reasoning is in Earned autonomy →

Take it with you: Register template (CSV) · Register template (Markdown) · Working files on GitHub

8

The curriculum exercise

Before your next three hires. An hour.

Most automation decisions sort tasks by what the output is worth. The second question is what doing the task taught. Miss it and the saving arrives this year while the cost arrives in five.

1. List what a newer person does in a normal month. Ask them, and ask whoever reviews their work.
2. Mark each task on two things: what the output is worth, and how much doing it taught.
3. Place each task in the grid, and act on the box it lands in.
4. Write down which work you're keeping for people because it teaches, even where an agent could do it.

The reasoning is in The bottom was the training programme →

See it done in A junior's week →

Take it with you: Working files on GitHub

9

The model, step by step

Per step, never per workflow. Re-decide twice a year, or when prices move.

Not every step deserves the most expensive model. Ten times cheaper and two per cent worse is an easy decision, provided your test set exists to prove the two per cent.

1. Hard, rare, costly-if-wrong steps go to the best model you can rent or license.
2. High-volume, checkable steps go to the cheapest model that passes your test set, often a small open-weight model you host or run yourself.
3. Where data rules apply, they decide where the model runs before cost does: licensed in the right region, hosted, or on your own hardware.
4. For each step, write down which model it uses, where it runs and why, on the agent's page in the register.
5. Run the Friday test: could you change the model behind this step by Friday, and know by Friday whether the new one is as good? If not, move the instructions and the test set out of the vendor's product.
6. Measure how much customer material left your control, per case. That number can be checked; a policy can't.
7. Reconcile cost per outcome with finance. If people are cheaper for a step, say so and don't deploy there.

The reasoning is in The layer you own →

Take it with you: Working files on GitHub

10

The first ninety days

Almost all of it is publishing rather than building.

What makes the first three months credible is that other people can read what you did. Publishing what you stopped beside the wins is what makes the wins believable.

The reasoning is in Earned autonomy →

Take it with you: Working files on GitHub

11

Who owns it

Part of someone's job.

The title matters less than what the role owns: four documents, the banked number, and what the business sells next. Without the numbers it governs but delivers little; without the documents it delivers numbers nobody can check.

1. It owns four documents: the register, the test set, the grade criteria and the record of decisions.
2. It can demote an agent the business would rather keep running.
3. It's measured on one number: the banked column, agreed with whoever runs the money.
4. It owns what the business sells next because of AI, and keeps that revenue in its own column, apart from the savings.
5. In a small company this is usually the founder or the CTO, for a few hours a week. That's enough, as long as it's written down whose it is.

The reasoning is in Earned autonomy →

Take it with you: Working files on GitHub

12

Where the revenue is

An hour with whoever owns your biggest customer relationships, before you set this year's prices.

Most AI plans are cost plans, and the savings pass to customers as competitors buy the same tools. They stay with you longer when you charge for the outcome rather than the activity. The larger prize is usually something new to sell, and it's often hiding in work you already do.

1. What do we see, across our customers or suppliers, that none of them can see on their own? Look for data you hold from several sources that nobody's job was to join up.
2. What do we produce as numbers that someone would pay to have explained? Fluent commentary is cheap now. Knowing which change matters is not.
3. What do we already record about our own work that would show us what to automate, and when?
4. What do customers value that we charge for by the hour, the search or the report? As AI takes the cost of producing it down, a price per unit follows it down.
5. Run the pricing check: one row per thing you sell, how it's charged now, what it's worth when it goes right, and whether you could charge for the outcome.
6. Keep new revenue in its own column, apart from savings, in the two columns.

The reasoning is in Pay for the outcome →

Take it with you: Working files on GitHub