The work behind the result.

AI in untrained hands is a cost with nothing to show for it. The licences get bought, a few people try it, the rest go back to how they worked before, and the bill arrives anyway. The limit is almost never the tool. It is how far along your people are, and they are rarely all in the same place.

• We stop here

  You sign the plan

  Nothing is designed or delivered until you have the ranked plan in writing and have agreed it. If the honest answer is that AI would not pay back here, this is where we tell you.

1. 01

   Measure where you actually are

   We assess two groups separately, because they are usually far apart: what your leadership understands about what AI can and cannot do, and what the people doing the daily work can actually get out of it.

   You bring

   Access to both groupsHonesty about what has already been tried

   You get

   A plain reading of where each group sitsThe gap between the two, named

2. 02

   Watch the real work

   We sit with people while they do their job and look for the places where AI would genuinely help. Some of what looks automatable is not, and we say so.

   You bring

   Time with the people who do the work, not only those who own it

   You get

   A map of where the hours actually go

3. 03

   Rank what is worth doing

   A short list, in order, with the effort and the running cost against each one. Things that are not worth doing come off the list here, rather than after you have paid for them.

   You get

   A ranked plan in plain EnglishThe expected running cost of each item

4. 04

   Train each level on your own work

   Gate before this

   Separate sessions for separate levels, built around your real documents and your real tasks. Generic training does not survive contact with a Monday morning.

   You bring

   Real examples of your work we may usePeople in the room

   You get

   Training built from your materialSomething each person can use the same day

5. 05

   Set the rules

   What may be put into a model and what may not, who signs off what, and a spend limit that does not creep. Written down, so it outlives the people who were in the room.

   You get

   A short usage policy your team will actually readA predictable monthly ceiling

6. 06

   Come back and check it stuck

   We return and find out what people are still using and what they quietly abandoned. Abandonment is the normal outcome of training, and fixing it is the point of this stage.

   You get

   An honest read on adoptionThe abandoned things either fixed or dropped

A messy process is usually not a technology problem. It is that nobody has written down who does what, what counts as correct, and what is meant to happen when it breaks. Automating a process nobody has agreed on only makes the wrong thing happen faster.

• We stop here

  You sign the spec

  No build starts until the spec and the examples are agreed in writing. This is the point at which scope is cheap to change, and the last point at which it is.

• We stop here

  You accept it

  You test it on real work, against the examples you signed. Nothing goes live on anything you have not accepted.

1. 01

   Map it as it really runs

   With the person who does the work, not the person who owns it. Including the steps that live only in somebody's head, and the exception everyone has stopped noticing.

   You bring

   An hour with whoever actually does itPermission to see the real cases

   You get

   A written map of the process as it is today

2. 02

   Find the owner and the failure paths

   Who is accountable when this goes wrong, what happens today when it does, and who notices. If nobody notices, that is the first thing we fix.

   You get

   A named ownerThe failure paths written down

3. 03

   Agree what correct looks like

   We collect real examples, the awkward ones included, and agree the right answer for each. Those become the test the finished system has to pass, so correct stops being a matter of opinion.

   You bring

   Real examples, the messy ones includedA decision on the edge cases

   You get

   A signed specThe set of examples we will be judged against

4. 04

   Decide what stays human

   Anything that sends money, sends a message or commits the business goes to a person for approval unless you tell us otherwise. We agree that line before anything is built, not after an incident.

   You get

   An agreed line between automatic and approved

5. 05

   Build it against the examples

   Gate before this

   The system is built to pass the examples you signed off. Progress is measured as how many it passes, so there is no argument about whether it is finished.

   You bring

   Access to the systems it needsSomebody to ask when a case is unclear

6. 06

   Test the awkward cases

   Empty input, a system it depends on being down, the same job running twice, permission refused, a rate limit. Anything that sends or spends has to be safe to repeat. Most of the real work is here.

   You get

   The result of every case, pass or fail, in writing

7. 07

   Fit it into what you already run

   Gate before this

   It has to live inside the tools your team already opens. A system people have to remember to visit is a system that gets forgotten.

   You bring

   The systems it must sit alongside

8. 08

   Hand it to a named person

   Someone who owns it, alerts we have proved reach a human, and a written runbook for when something needs doing. We do not close a job with nobody holding it.

   You bring

   Somebody to own it

   You get

   A runbookAlerts tested in front of youThe code and the accounts

An agent that invents an answer is worse than no agent, because people believe it. Everything below is arranged around one thing: making it answer from your material, and making it say it does not know when it does not. Getting an agent to refuse well is harder than getting it to reply.

• We stop here

  You sign the scope

  The answer list, the refusal list and the material are agreed in writing before anything is built. That document is what the finished agent gets judged against.

• We stop here

  You accept it

  You see the graded results and try it yourself before a single customer does. It goes live when you say it does.

1. 01

   Decide what it answers and what it refuses

   The refusal list matters more than the answer list. Prices, promises, medical or legal questions, anything only a person should say. We agree this before anything else.

   You bring

   A view on what it must never handle

   You get

   A written scope, including everything it will decline

2. 02

   Find where the knowledge really lives

   Usually not where people expect. Recorded calls, a shared drive, help desk history, somebody's notes, videos. The best material has often never been written down.

   You bring

   Access to your materialSomebody who knows where the good answers are

   You get

   An inventory of what we found and what is missing

3. 03

   Prepare the material so it can be searched

   Transcribing, cleaning and indexing. This is the largest part of the work and the part nobody sees. The quality of every answer it will ever give is decided here.

   You get

   Your knowledge in one searchable place, which is useful on its own

4. 04

   Build the confidence gate first

   Gate before this

   Ordinary code, not a model, decides whether your material actually holds a good enough answer. Below that line the model is never asked to make a claim. That is the mechanism behind saying I do not know, and it exists before the agent does.

   You get

   A refusal you can rely on rather than hope for

5. 05

   Build the agent behind the gate

   Now the part people picture. It answers in your voice, from your material, and it never gets to answer a question the gate has already stopped.

   You bring

   Examples of how you would answer, in your own words

6. 06

   Test it on real questions

   Including the ones it must refuse, the ones written badly, and the ones designed to talk it into something. We grade the answers rather than glance at them.

   You bring

   Real questions your people actually ask

   You get

   A graded set of results before it meets a customer

7. 07

   Put it where your people already are

   Gate before this

   Their chat tool, their inbox, your site. Wherever the question already gets asked, rather than somewhere new they have to be persuaded to go.

   You bring

   Access to the channel it will live in

8. 08

   Put a person on the flags

   Everything it declined goes to a human. Those answers then go back into the material, so the set of things it cannot handle shrinks every week instead of standing still.

   You bring

   Somebody to review the flags

   You get

   A queue of what it could not answerA system that improves rather than drifts

A dated site costs you work you never hear about, because the people who bounced off it do not write in to tell you. A site also has two audiences now. People read it, and so do the assistants people increasingly ask before they ever visit. Most sites are built for only the first.

• We stop here

  You sign the direction

  The direction and the words are agreed before the build starts, so what you see at the end is what you approved at the beginning.

• We stop here

  You accept it

  You walk the finished site on your own phone before it replaces the old one. It launches on your word.

1. 01

   Agree the one job the site has to do

   Get an enquiry, get a booking, get a phone call. Sites that try to do five things do none of them. Deciding this first is what makes every later decision easy.

   You bring

   A decision on what a win looks like

   You get

   One measurable job, written down

2. 02

   Look at what happens on the current one

   Where people arrive, what they read, where they give up. If nothing is measuring that today, we say so plainly rather than inventing a before figure.

   You bring

   Access to whatever analytics exist, if any

   You get

   An honest read on the current site, or a clear note that there is no data

3. 03

   Set one direction and sign it off

   One direction, agreed before anything is built. Redesigning during a build is the most expensive way to work and the most common.

   You get

   A direction you have seen and approved

4. 04

   Write it before designing it

   The words decide the layout, not the other way round. A design built around placeholder text gets rebuilt when the real words arrive, and the real words are always longer.

   You bring

   Time on the copy, or the decision to have us write it

   You get

   Approved words for every page

5. 05

   Build it

   Gate before this

   Built to load fast on a phone on a poor connection, because that is where most of your visitors are, and because a slow site loses people before it has said anything.

6. 06

   Test it on real devices

   Actual phones and actual tablets, not a desktop browser made narrow. Phone first, since that is where the majority of the traffic and the majority of the problems are.

   You get

   Results across the devices your visitors really use

7. 07

   Make it legible to machines as well as people

   Structured so search engines and AI assistants can read what you do, who you serve and how to reach you. More buying decisions now start with a question to an assistant than with a search.

   You get

   A site the tools people now ask can quote correctly

8. 08

   Launch and hand over

   Gate before this

   Everything in your name. The domain, the hosting, the code. You should never need our permission to change your own website.

   You get

   Ownership of the code and every accountA short guide to changing it yourself