Stage 01
Problem
A real, named problem worth solving.
Every useful AI system starts with a specific problem experienced by specific people — not with a tool looking for something to do. A good problem statement names who is affected, what happens today, and what it costs them in time, money, or missed opportunity.
Example (Local Business Missed-Call Recovery): The shop misses 15–20 calls a week while staff are on job sites. Most callers do not leave voicemail; they call the next business on the list.
Humans own this stage. People experiencing the problem define it. No model can tell you what matters to your community.
No AI role. AI has no role in deciding which problems deserve attention.
Failure points
- Starting from a tool ("we should use AI") instead of a problem
- A problem statement so broad that any solution fits — and none works
- Assuming the problem without asking the people who live it
Evidence to record
- A one-sentence problem statement
- Notes from conversations with affected people
- A description of what happens today, before any system
Stage 02
People
Who is affected, who acts, who is responsible.
Systems touch more people than their operators. Map everyone: the people the system serves, the people who run it day to day, the people whose data it touches, and the person accountable when something goes wrong. If you cannot name the accountable human, you are not ready to build.
Example (Local Business Missed-Call Recovery): Callers (potential customers), the office manager who follows up, the owner who is accountable, and field staff whose schedules are affected.
Humans own this stage. Roles, responsibilities, and accountability are assigned to named humans.
No AI role. AI cannot be the accountable party. Accountability always belongs to a person or organization.
Failure points
- No named owner for the system after launch
- Forgetting people whose data flows through the system
- Operators who were never consulted about how they actually work
Evidence to record
- A list of affected groups
- Named roles: operator, reviewer, accountable owner
- Notes on what each group needs from the system
Stage 03
Context
The environment the system must survive in.
A workflow that works in a demo fails in the real world if you ignore context: budget, staffing, devices, connectivity, language, trust, regulation, and the habits people already have. Context is not decoration — it decides what is buildable.
Example (Local Business Missed-Call Recovery): Small budget, one shared phone line, staff who live on their phones but not in dashboards. Customers expect a reply within the hour, not the week.
Humans own this stage. People who live in the environment describe it. Assumptions get tested against reality.
No AI role. AI does not sit in your building, meet your customers, or know your constraints unless you deliberately encode them.
Failure points
- Designing for ideal conditions instead of actual ones
- Ignoring the tools people already use and trust
- Missing legal, policy, or funding constraints until late
Evidence to record
- A written list of constraints
- The tools and channels already in use
- Any rules the system must respect
Stage 04
Inputs
What the system is allowed to know.
Inputs are the raw material: messages, forms, calls, documents, spreadsheets. Define exactly which inputs the system receives, in what format, from whom, and with what permission. Bad or missing inputs are the most common reason AI systems produce useless output.
Example (Local Business Missed-Call Recovery): Missed-call notifications with the caller's number and time; any voicemail transcription; a simple price-and-services sheet; the weekly schedule.
Humans provide input. Humans decide what data is collected, why, and with whose consent.
AI may assist. AI can help classify, clean, or transcribe inputs — it should not decide what is collected.
Failure points
- Collecting more data than the purpose requires
- Inputs that arrive unstructured, incomplete, or late
- No permission or consent trail for personal information
Evidence to record
- A list of input sources and formats
- Consent or permission notes for personal data
- An example of a real input, sanitized
Stage 05
Workflow
The steps, in order, from trigger to outcome.
Map the workflow before choosing any tool. What triggers it? What happens next, and next? Where does information move between people and systems? Where does it wait? A workflow map on paper exposes gaps that no amount of prompting can fix.
Example (Local Business Missed-Call Recovery): Call missed → notification fires → caller details logged → draft response prepared → office manager reviews → approved message sent → outcome logged → follow-up reminder if no reply.
Humans own this stage. The people who do the work help draw the map. The map is wrong until they say it is right.
AI may assist. AI can help draft a workflow diagram from a description — humans verify it against reality.
Failure points
- Mapping the workflow as imagined instead of as practiced
- Skipping exception paths: the angry caller, the missing form, the holiday
- Steps with no clear owner
Evidence to record
- A step-by-step workflow map
- Named owner per step
- The top three exception paths
Stage 06
Knowledge & Data
What the system needs to know to do its job.
Most useful AI systems need reference knowledge: prices, policies, schedules, eligibility rules, FAQs. This knowledge must be gathered, kept current, and owned. Outdated knowledge is worse than none — the system will answer confidently from stale facts.
Example (Local Business Missed-Call Recovery): Current services and price ranges, service area boundaries, available appointment windows, and answers to the ten questions every caller asks.
Humans own this stage. A named person owns each knowledge source and its update rhythm.
AI may assist. AI can help organize, summarize, and retrieve knowledge — humans keep it true.
Failure points
- Knowledge that exists only in someone's head
- No update process — information decays silently
- Sensitive information mixed into general knowledge
Evidence to record
- A list of knowledge sources with owners
- Last-updated dates
- Rules for what must never enter the knowledge base
Stage 07
AI Assistance
The specific jobs AI does inside the workflow.
Now — and only now — define what AI actually does: drafting, classifying, summarizing, extracting, translating, matching. Each AI job should be small, checkable, and replaceable. If the AI job description is vague, the results will be too.
Example (Local Business Missed-Call Recovery): AI drafts a short, friendly text response referencing the likely service need, and summarizes any voicemail into three lines for fast review.
Humans decide here. Humans choose which tasks AI touches and which it never touches.
AI may draft, humans finalize. This is the stage where AI earns its place: narrow, defined, checkable tasks.
Failure points
- Asking AI to "handle it" instead of defining a task
- One giant prompt doing the work of five checkable steps
- No fallback for when the AI output is wrong or missing
Evidence to record
- A list of AI tasks, one sentence each
- For each task: what good output looks like
- The fallback when AI fails
Stage 08
Decision Point
Where a choice changes what happens next.
Every workflow has moments where a choice matters: is this request urgent? Does this person qualify? Should this message be sent? Mark these points explicitly and decide who or what may make each one — and which decisions AI may prepare but never take alone.
Example (Local Business Missed-Call Recovery): Is this a routine inquiry (draft a reply) or an urgent situation like a leak or no-cool call in July (alert the owner immediately)?
Humans decide here. Consequential decisions belong to humans. Some routine classifications can be delegated with review.
AI may assist. AI may recommend, score, or sort. The riskier the decision, the tighter the human control.
Failure points
- Hidden decisions no one noticed were being made
- AI making consequential calls by default because no one marked the decision point
- No criteria written down, so decisions drift over time
Evidence to record
- A list of decision points in the workflow
- Written criteria for each decision
- Who decides, and what AI may contribute
Stage 09
Human Approval
A named person says yes before action.
Before the system acts on anything that matters — sending, spending, publishing, enrolling, declining — a named human reviews and approves. Approval is a designed step with a clear interface, not an afterthought. Fast to review, easy to correct, impossible to skip silently.
Example (Local Business Missed-Call Recovery): The office manager reads every drafted reply and taps approve or edits first. Urgent alerts go to the owner without waiting.
Human approval required. This stage exists so responsibility stays with people. Approvals are logged.
AI may draft, humans finalize. AI prepares the item for approval: the draft, the summary, the recommendation. It never presses send.
Failure points
- Approval queues so long that reviewers rubber-stamp
- No record of who approved what
- Systems that act first and notify later
Evidence to record
- The approval step in the workflow map
- Who approves, and how long review should take
- The log of approvals and edits
Stage 10
Action
The system does something in the world.
Actions are where systems touch reality: a message sent, an appointment booked, a record updated, a task created. Actions should be specific, reversible where possible, and logged. The blast radius of an action decides how much review it needs before it runs.
Example (Local Business Missed-Call Recovery): An approved text is sent from the business number, and a callback task is created for anything urgent.
Human approval required. Humans define which actions exist and their limits. Irreversible actions get the strongest controls.
No AI role. AI does not act directly here; the workflow executes approved actions through ordinary tools.
Failure points
- Actions that cannot be undone and were never reviewed
- Silent actions nobody knows happened
- Automated actions firing on bad inputs with no guardrail
Evidence to record
- A list of possible actions and their reversibility
- The log of every action taken
- Limits: volume, timing, recipients
Stage 11
Output
What people actually receive.
The output is what the world sees: the reply, the summary, the scheduled visit, the report. Outputs carry your organization's name, so they need a voice, a quality bar, and a check. People should be able to tell a human is still responsible for what they receive.
Example (Local Business Missed-Call Recovery): The caller receives a plain, warm message: thanks for calling, here is how we can help, here is how to reach a person.
Humans own this stage. Humans set the quality bar and the voice. Outputs represent the organization, not the model.
AI may draft, humans finalize. AI drafts many outputs; humans finalize anything consequential.
Failure points
- Outputs that sound generic, robotic, or off-mission
- Confident output built on missing or wrong inputs
- No path for a recipient to reach a human
Evidence to record
- Example outputs, reviewed and approved
- The quality checklist for outputs
- The "reach a human" path
Stage 12
Measurement
Numbers that tell you if it works.
Define usefulness before launch: response time, recovered calls, completed intakes, hours saved, error rate, cost per action. Measure a small set of honest numbers. If you cannot say how you will know the system is failing, you are running on hope.
Example (Local Business Missed-Call Recovery): Response time per missed call, percentage of missed calls that turn into conversations, conversations that turn into booked jobs, cost per month.
Humans decide here. Humans choose what "working" means and which numbers count.
AI may monitor and flag. AI can help tally, summarize, and flag anomalies in the numbers — humans interpret them.
Failure points
- Metrics chosen after launch to fit whatever happened
- Counting activity (messages sent) instead of outcomes (problems solved)
- No baseline from before the system existed
Evidence to record
- The short list of metrics with targets
- The baseline from before the system
- Where the numbers live and who reviews them
Stage 13
Feedback
Reality talks back.
Users, operators, and recipients all generate feedback: complaints, corrections, edits, silence. Build deliberate channels to capture it — the edit a reviewer makes to an AI draft is some of the most valuable data your system produces.
Example (Local Business Missed-Call Recovery): The office manager's edits to drafts are logged; callers can reply "stop" or ask for a call; the owner hears about any complaint same day.
Humans own this stage. Humans decide how feedback is collected and what happens because of it.
AI may assist. AI can help cluster and summarize feedback themes for human review.
Failure points
- No channel for recipients to complain or correct
- Reviewer corrections thrown away instead of studied
- Feedback collected but never read
Evidence to record
- The feedback channels
- A log of corrections and their themes
- A regular review rhythm
Stage 14
Improvement
The system gets better on purpose.
Improvement is a loop, not a launch-day event. Evidence from measurement and feedback leads to small, deliberate changes: a clearer instruction, a better knowledge source, a new guardrail. Each change is tested, logged, and reversible.
Example (Local Business Missed-Call Recovery): Weekly fifteen-minute review: which drafts needed edits, which questions are missing from the knowledge sheet, whether response time is holding.
Humans decide here. Humans decide what changes, when, and why. Improvement is governed, not accidental.
AI may assist. AI can propose improvements from evidence — humans choose and test them.
Failure points
- Changes made live with no test and no rollback
- Improvement that only happens when something breaks publicly
- No log of what changed, so failures cannot be traced
Evidence to record
- A change log
- Before/after comparisons for changes
- A scheduled improvement review
Stage 15
Boundaries & Safeguards
What the system must never do.
Write down the never-list: what the system must never say, decide, send, spend, or store. Add the safeguards that enforce it: spending caps, blocked topics, escalation triggers, kill switches. Boundaries are a feature you design, not a hope you have.
Example (Local Business Missed-Call Recovery): Never quote exact prices by text, never send marketing messages to missed callers, never contact anyone who opted out, cap total monthly spend.
Humans own this stage. Humans write the never-list, test it, and own the kill switch.
AI may monitor and flag. AI can help watch for boundary violations and flag them — enforcement is designed by humans.
Failure points
- Boundaries discussed but never written down
- Safeguards that exist but were never tested
- No fast way to stop the system when it misbehaves
Evidence to record
- The written never-list
- Test results showing safeguards fire correctly
- The stop procedure and who can trigger it
Stage 16
Cost & Resource Awareness
What the system spends to run.
AI systems spend money, time, and attention: per-call costs, subscription fees, human review time, maintenance. Know the cost per action and per month, and compare it honestly to the value. A system that costs more than the problem it solves is a hobby, not a solution.
Example (Local Business Missed-Call Recovery): Phone notification tooling plus per-message AI drafting runs roughly the cost of one recovered job per quarter — the owner checks this math monthly.
Humans own this stage. Humans set budgets, watch them, and decide if the value justifies the spend.
AI may monitor and flag. AI can help track and report usage costs — budget decisions stay human.
Failure points
- No idea what each automated action costs
- Usage growing silently until the bill arrives
- Human review time ignored in the cost calculation
Evidence to record
- Cost per action and per month
- The budget and alert threshold
- A value comparison: cost vs. time saved or revenue recovered