A field technician is kneeling beside a packaging line at 2:14 in the morning, gloves on, a fault code blinking on the controller, and a phone in one hand. She is not going to launch a forty-minute e-learning module. She has ninety seconds before the line backs up, and what she needs is one page: the exact reset sequence, in order, for this machine. That one page is a job aid, and whether it saves the shift or sends a wrong step into a live machine depends entirely on whether someone verified it against the real procedure before it shipped. AI can draft that page in under a minute. The minute that matters is the one after, when a human checks every step against the machine's actual maintenance manual.

Performance Support Often Beats a Course

For decades, the reflex in corporate learning has been to answer every performance problem with a course. Someone makes a mistake, a stakeholder asks for training, and the L&D team builds a module. But a great deal of what people get wrong at work is not a knowledge problem at all. It is a memory problem, or a sequence problem, or a "which of the seven exceptions applies right now" problem, and you cannot solve those by making someone sit through content weeks before the moment they need it. You solve them by putting the right answer in front of the person at the instant they have to act.

That is the discipline of performance support: help delivered at the point of work, in the flow of the task, so the worker does not have to carry the whole procedure in their head. Why you care: a course teaches you to remember a procedure; a job aid means you never have to. For anything complex, infrequent, high-stakes, or constantly changing, the job aid is usually the better intervention, and often the only one that actually changes behavior on the floor.

A job aid is the concrete artifact that delivers that support: a checklist, a decision tree, a quick-reference card, a flowchart, a labeled diagram, a one-page procedure. It is the thing taped inside the cabinet door, pinned in the team channel, or surfaced by a search box the moment a worker types the fault. The job aid does not try to build deep understanding. It tries to make the right action easy and the wrong action hard, exactly when it counts.

A course tries to make a procedure unforgettable. A job aid makes it unnecessary to remember. For a complex, rare, or dangerous task, the second one is usually the better instructional design decision, not the lazy one.

The Moment of Need and 70-20-10

The reason performance support matters is best understood through the moment of need, a simple lens that asks: at what instant does a person actually need this help? The classic framing names five moments. When someone is learning something for the first time (new). When they are deepening what they already know (more). When they have to apply it in the real task (apply). When something breaks and they have to solve it (solve). And when something has changed and what they knew is now wrong (change). Why you care: a formal course serves the first two moments well and the last three badly, because the first two happen in a classroom and the last three happen at the machine, in the call, in the meeting, where nobody is going to pause and take a course.

This is also where a famous heuristic earns its keep and shows its limits. The 70-20-10 model proposes that roughly seventy percent of workplace learning comes from doing the job, twenty percent from other people, and ten percent from formal training. Why you care: the numbers are a reminder, not a measurement. The exact ratio was never the point and was never validated as a law; treat it as a directional nudge that most capability is built in the flow of work, not in the course catalog. Read honestly, 70-20-10 tells the learning professional to stop pouring every budget dollar into the ten percent and to design deliberately for the seventy, and the job aid is the single most cost-effective tool for doing exactly that.

So before any AI gets involved, the design judgment is human and it comes first: is this a moment-of-need problem better solved by a job aid than a course, and which of the five moments are we serving? AI does not make that call. It accelerates the build once you have made it.

The Types, and What Each Is For

Not every job aid is a checklist, and matching the format to the cognitive task is where evidence-based design lives. A few durable types, each suited to a different kind of work:

• Checklist: for a sequence of steps where the risk is forgetting one. A pre-flight check, a closing routine, a release checklist. The format makes completeness visible.
• Decision tree or flowchart: for a branching judgment, where the right action depends on conditions. "If the customer is past due more than 30 days, then... otherwise..." The format makes the logic walkable.
• Reference or lookup table: for facts you retrieve rather than reason through. Dosage by weight, error code to remedy, tax rate by region. The format makes the right value findable.
• Worked example or annotated sample: for a task you do by pattern-matching to a good model. A filled-in form, a labeled diagram, a sample report. The format makes the standard concrete.
• Step-by-step procedure: for a linear task done rarely enough that nobody has it memorized. The format makes the path unambiguous.

The wrong format is its own failure mode. A branching judgment crammed into a flat checklist forces the worker to guess which line applies. A simple sequence drawn as an elaborate flowchart wastes the reader's attention on navigation. Choosing the format is design work, and it is one of the things you must decide before you prompt, because the model will happily produce a beautifully formatted job aid in the wrong format for the task.

Drafting the Job Aid With AI, Fast

Here is where the speed is real and worth capturing. Drafting a job aid by hand has always been slow not because the content is hard but because the formatting, the ordering, the trimming to one page, and the plain-language rewriting all take time. This is precisely the kind of work a generative model is good at: take a dense source and reshape it into a tight, scannable artifact. A model can turn a six-page SOP into a one-page checklist, convert a wall-of-text policy into a decision tree, or rewrite a procedure at a lower reading level, in seconds.

But the speed is only safe under one condition, and it is the condition this entire program is built on. The model must reshape your verified source, not invent from its training data. This is grounding, also called grounded generation or RAG (retrieval-augmented generation): forcing the model to work from the approved document you give it rather than its own memory. Why you care: an ungrounded model will cheerfully fill a gap in your SOP with a plausible step that was never in the procedure, and a job aid is the worst possible place for that, because a job aid is followed literally, in the moment, with no instructor in the room to catch the error.

So the disciplined draft prompt names four things: the source ("use only the attached maintenance manual, section 4"), the format ("produce a numbered checklist"), the audience and reading level ("for a first-year technician, eighth-grade reading level"), and the refusal rule ("if a step is not in the source, do not invent it; flag the gap instead"). That last instruction is the one most people skip and the one that matters most. It tells the model that a hole in the source is something to surface, not something to paper over with a guess.

A Worked Draft, in Two Passes

Imagine the source is a five-page lockout/tagout SOP for a specific conveyor. The first prompt is loose: "make a job aid from this." The model returns a clean, confident one-page checklist. It reads well. It is also subtly wrong in two places: it has merged two distinct isolation points into one step, and it has added a "verify zero energy" step in a position that is not where the SOP places it. The model did what loose prompts invite, smoothing the messy real procedure into a tidy generic one. A worker following that tidy version would skip an isolation point.

The second prompt is disciplined: "Using only the attached SOP, produce a numbered checklist that preserves every isolation point as its own step and keeps the verification step in the exact position the SOP specifies. Do not combine, reorder, or add steps. If any step is ambiguous in the source, list it and stop." Now the model produces a checklist that maps one-to-one to the SOP, and where the source was genuinely ambiguous, it says so instead of guessing. Same tool, same minute, completely different artifact, because the prompt forced the model to be a reshaper of verified content rather than an author of plausible content.

Verify It Against the Procedure It Points To

The draft is not the deliverable. The verified draft is. And the verification for a job aid has a particular shape, because a job aid does not live alone: it points at a real procedure, a real machine, a real policy, and the only meaningful check is whether the aid still tells the truth about that thing. This is the iron rule of the program in its performance-support form: AI assists, the human verifies the aid against the source it points to, the human owns it, and "the AI wrote it" is not a defense when a worker follows a wrong step.

Verification means walking the job aid against the source of truth, step by step, with three questions for every line. Is this step actually in the source? Is it in the right order? Does it say the same thing the source says, in the same conditions? A job aid that adds a step the SOP does not contain, drops a step the SOP requires, reorders a sequence where order is safety-critical, or softens a "must" into a "should" is not a faster job aid. It is a defect waiting for the moment of need.

There is a second verification that performance support specifically demands: currency. A job aid is a snapshot of a procedure, and procedures change. The SOP gets revised, the policy threshold moves, the machine gets a firmware update, and the job aid taped to the cabinet keeps confidently telling people the old way. AI makes this risk worse, because AI makes job aids so cheap to produce that they proliferate, and a proliferating set of one-pagers is a maintenance problem nobody owns. The verification step has to include a version reference and a review date, so the aid traces to a known revision of the source and has an expiry attached.

That last row deserves its own emphasis. A job aid is content, which means it is in scope for accessibility just like a course. An AI-generated quick-reference card delivered as a flat image with the text baked in is invisible to a screen reader, and a decision tree with red-green color coding and no labels fails for a colorblind worker. WCAG 2.2 AA (the Web Content Accessibility Guidelines, the conformance target for learning content) applies to the one-pager exactly as it applies to the module. Accessibility is a gate on the job aid, not a polish step, full stop.

A Before and After, on the Floor

Before. A maintenance lead is under pressure to document twelve recurring machine faults before an audit. He pastes each fault's troubleshooting notes into a chatbot, asks for a one-page job aid each, and pins the twelve clean PDFs in the team channel by lunch. They look professional. Three weeks later a technician follows the aid for a jam clear, and the aid omits a guard-replacement step that the real SOP requires, because the troubleshooting notes the lead pasted in were themselves incomplete and the model filled the gap with a generic clear-the-jam sequence. The guard stays off. The near-miss gets written up. When the safety officer asks "what source did this aid come from and who checked it," the answer is "the AI made it from my notes," which is exactly the answer that does not survive an inquiry.

After. The same lead does the same work but treats the model as a reshaper, not an author. For each fault, he grounds the prompt on the approved SOP for that machine, not his loose notes, and adds the refusal rule. The model drafts; he walks each aid against the SOP with the seven-check list; he catches the two places where the model smoothed over a step; he adds the SOP revision number and a six-month review date to each aid's footer; he confirms each is real text with adequate contrast and alt-texted diagrams. The twelve aids ship a day later than the "before" version. They are also correct, current, traceable, and accessible. When the safety officer asks the question, the lead opens the footer: SOP revision 7, verified on this date, review due on that one. That footer is the difference between a time-saver and a liability.

The lesson is not that AI job aids are dangerous. It is that the danger lives in the gap between "the model produced a clean page" and "a human confirmed the page tells the truth about the procedure it points to." Close that gap and the speed is a gift. Skip it and you have mass-produced confident wrong instructions and pinned them where people act on them without thinking.

Key Takeaways

• Performance support, help delivered at the point of work, often beats a course for complex, rare, high-stakes, or fast-changing tasks, because it serves the moments of need (apply, solve, change) that a classroom cannot reach.
• 70-20-10 is a heuristic, not a measured law: treat it as a directional reminder that most capability is built in the flow of work, and design deliberately for the seventy percent the course catalog ignores.
• Match the job aid format to the cognitive task: checklist for sequences, decision tree for branching judgment, lookup table for facts, worked example for pattern-matching, procedure for rare linear tasks. The wrong format is its own failure mode.
• AI is genuinely fast at reshaping a verified source into a tight one-page aid, but only when grounded on your approved document with a refusal rule, so it reshapes truth instead of inventing plausible steps.
• A job aid is followed literally at the moment of need with no instructor present, which makes a hallucinated or dropped step more dangerous here than almost anywhere else in learning.
• Verify every job aid against the procedure it points to: step presence, completeness, order, conditions, modal force, currency with a version and review date, and accessibility to WCAG 2.2 AA.
• AI makes job aids cheap enough to proliferate, which turns currency into a real risk; every aid needs a source revision reference and an expiry so a stale one-pager does not keep teaching the old way.
• The iron rule in performance-support form: AI assists, the human verifies the aid against its source, the human owns it, and "the AI wrote it" is never a defense when a worker follows a wrong step.