Put the parts of the work that never change into code: the form, the checks and the steps to sign-off. Then the bot spends its effort on the thinking, and the paperwork comes out the same way every time.
What it is
Every management system has two kinds of content. Some of it is fixed: the columns on a form, the rating scale, the rule that every risk needs an owner, where the master copy lives, who signs. The rest is judgment: what could go wrong, how bad it would be, what to do about it.
People learn the fixed parts once and stop thinking about them. A bot reads them fresh on every job, from written instructions, and can drift. One run adds a column. The next renames one. A third saves the file somewhere new.
This principle splits the two. The fixed parts go into code, and the code holds them steady. The bot gets the judgment, and a person signs.
It's the base of the stack. Principles, playbooks, skills and records guide the work. The code underneath holds the form. See Your bots need a management system.

When to use it
- When the same form gets filled again and again: an FMEA, a control plan, an A3, a risk register.
- When a missing field or a wrong format causes real trouble later.
- When a record has to be signed, and the sign-off has to match the exact version that was checked.
A one-off note or a quick draft doesn't need it. Written instructions are enough there.
How a bot helps
The bot does what it's good at: reading the project data, proposing what's missing and making the first call on each rating. It doesn't decide how the form looks or where it's saved. Those are already settled.
A bot can also help build the lock. Ask it to list every field on the form, the allowed values for each and the rule each field must pass. A person checks the list before anyone writes code.
The bot brief
For [form name], list the fixed parts and the judgment parts. Fixed parts: each column, its allowed values, the checks before a row is accepted, the steps from draft to signed, and where the one saved copy lives. Judgment parts: the fields a bot should propose and a person should review. Use [named form, template and revision]. Mark anything you're unsure of as an open question. Don't change the live form.
Where bots differ
A person who has filled in a hundred FMEAs doesn't re-think the columns. A bot might, every time, unless something stops it. Bots are similar to people in that they make judgment calls. They're different in that they don't carry the habit from one job to the next.
A written rule is a sign on the wall. Code is closer to a fixture. A sign helps most of the time. A fixture is built not to depend on anyone remembering. See Poka-yoke: make the mistake impossible and The hierarchy of controls.
Software is only as strong as the setup behind it. A fixture can be built wrong, and so can code. Test the lock the way you'd test a fixture: try a bad part and make sure it's refused.
Where code takes over
This whole page is about where code takes over. The split we use:
Code owns
- the fixed columns and allowed values
- the checks before a record moves on to review (no blank thinking fields, and no row without an action)
- the numbers that follow from other numbers, like a risk score
- the steps from draft to in review to reviewed to released
- the one saved copy, and the printout
The bot owns
- what could go wrong, and why
- the first call on each rating, with its source
- the proposed action
A person owns
- the review of the bot's thinking
- the yes that releases the record. See Nothing ships without a yes.
An example
A filled sample built this way is the process FMEA for a made-up product: an 18-volt cordless drill battery pack from a made-up company. It's developed but untested. The procedure behind it works on example data, but it hasn't been checked against a real line or in real use. Every name, part number, rating and date in it is example data.
Here's how the work split:
- Code fixed the form. The columns, the rating scales and the rule that every row needs an action and an owner were set before the bot started.
- The bot did the thinking. It proposed the failure modes, the causes, the ratings and the actions. One row: a cell with high internal resistance gets through incoming inspection, because only voltage is checked. The bot rated it 7 for severity, 4 for occurrence and 6 for detection. It proposed adding a resistance limit to the incoming work instruction, using a meter the line already has.
- Code did the bookkeeping. It gave the row its ID, worked out the risk score (168), marked which rows make up the top 80 percent of the risk and wrote the one saved record.
- Nobody has signed it. The record is "in review" on purpose. The release step needs a named person's approval, and none was given.
The result: 35 rows across 10 process steps, risk scores from 60 to 252, and 19 rows in the top-80% set. It prints as six pages, ending with the basis, the limits and an empty signature block.
Download the sample FMEA (PDF, 5 landscape pages)
Free to use under the MIT License.
What it doesn't show yet: that the lock can't be got around. That still has to be checked. Until it is, treat the code as a strong habit, not a guarantee. A person still reviews every record.
Lock the form in code: short outline
What it's for
Keep the fixed parts of a form steady across every bot and every run. Let the bot spend its effort on the judgment.
Columns
| Column | What goes in it |
|---|---|
| Form | The form and its revision, such as a process FMEA, revision A. |
| Fixed part | A column, an allowed value, a check, a step to sign-off, or where the saved copy lives. |
| Why it's fixed | What goes wrong if it changes from run to run. |
| Judgment part | The field the bot proposes and a person reviews. |
| Who reviews | The person who checks the bot's thinking. |
| Who signs | The person whose yes releases the record. |
| Test | The bad input you tried, and whether it was refused. |
| Status | Proposed, built, tested, or in use. |
Steps, each with its "done when"
- Pick one form that repeats. Start with the one that hurts most when it's wrong. Done when the form and its owner are named.
- Split fixed from judgment. Go column by column. Done when every column is marked fixed or judgment, and the owner agrees.
- Write down the checks. Required fields, allowed values, the numbers worked out from other numbers. Done when each check has a pass example and a fail example.
- Set the steps to sign-off. Draft, in review, reviewed, released. Say who moves the record each step. Done when only a named person can release.
- Build it and try to break it. Feed it a blank field, a wrong value and a missing approval. Done when each one is refused, and the test is saved.
- Let the bot fill one. Done when a person has reviewed the thinking and the printout matches the fixed form.