Ninety days from now there are two versions of you. One has read another stack of articles, watched a few tool demos, and can still only say "AI seems risky for compliance training," which is true and useless. The other has shipped one real thing: a single module, grounded in a verified source, with one validated assessment item, an accessibility check that passes, and a measurement plan that can prove whether it changed behavior. The gap between those two people is not talent and it is not access to a fancier tool. It is a plan. This lesson is that plan, broken into three thirty-day phases, each ending in a named artifact you can point to and say "I made this, and here is why it holds up."

Why an On-Ramp, and Not a Reading List

The reason most learning professionals are stuck at "I have touched AI but cannot operate it" is that they treat AI literacy as something you read your way into. LinkedIn's 2025 Workplace Learning Report captures the trap precisely: about 71% of L&D professionals are already exploring, experimenting with, or integrating AI, yet only roughly 25% factor it into their work routinely. The gap between 71% and 25% is not a knowledge gap, it is a doing gap, and you do not close a doing gap by reading. You close it by shipping one small, complete, defensible build and learning every hard lesson in miniature before the stakes are real.

So this plan is deliberately not "learn everything about AI." It is the opposite: pick the smallest real artifact that still touches every part of the discipline, and build it end to end. One module. One claim verified. One item validated. One accessibility check. One measurement design. Small enough to finish in a quarter, complete enough that finishing it makes you genuinely an AI-aware learning professional rather than someone who has read about being one. The artifacts are the point. At the end of each phase you should be able to hold something up, not just feel more informed.

You do not read your way from aware to capable. You ship one small, complete, defensible thing, and the artifact is the proof you crossed the gap.

The 90-Day Plan at a Glance

Here is the whole arc on one page. Read down the artifact column: each phase ends in something concrete, and the artifacts stack into a single defensible build by day 90.

Notice that the plan moves you across the exact arc the whole program teaches, source to verified content to valid assessment to accessible experience to measured impact, but at the smallest survivable scale. You are not building a catalog. You are building one thing that is correct, accessible, and provable, which is infinitely more valuable than ten things that are none of those.

There is a reason the artifacts are designed to stack rather than stand alone. Each one is the precondition for the next, and seeing that dependency is part of understanding why the order is not negotiable. You cannot produce a trustworthy grounded draft until you can reliably catch what AI gets wrong, which is what the verification checklist gives you. You cannot meaningfully validate an assessment item until you have content whose claims you trust, which is what the grounded draft gives you. You cannot honestly design a measurement of impact until you have a build that is correct and accessible enough to be worth measuring, which is what the validated item and the accessibility check give you. Do the phases out of order and each artifact rests on an unverified foundation: you would be validating items against content that might be false, or measuring the impact of a module that might exclude part of the audience. The sequence is itself a verification principle in disguise, every step builds on a step you already checked.

Days 1 to 30: Read an AI Module With Suspicion

The first thirty days are about replacing a vague feeling with a precise habit. Right now, faced with an AI-drafted module, you can feel that something might be wrong. By day 30 you should be able to name exactly what to check and find the problems on purpose. The exercise is simple and you can start it this week: take any AI-drafted learning output, a module, a quiz, a script, and read it like an auditor who assumes it is wrong until proven otherwise.

As you do, write down every category of thing you find yourself checking, because that list becomes your first artifact: a verification checklist. It will grow to include things like: does every fact, threshold, and procedure step trace to an approved source, or did the model generate it from memory (the hallucination check, where a hallucination is fluent, confident output that is simply false). Does each assessment item actually test the stated objective, or does it test reading comprehension. Does the media pass basic accessibility, captions, alt text, contrast, reading order. Is the reading level right for the audience. Are there invented citations or statistics. The checklist is not theoretical; it is the residue of you actually hunting for problems in real output. Why this is first: you cannot safely build with AI until you can reliably catch what it gets wrong, and you cannot catch it reliably from a feeling. The checklist turns suspicion into a repeatable procedure.

One discipline to build now: when you find a wrong claim, do not just fix it, note how you knew it was wrong. Did you trace it to a source? Compare it to a policy? Recognize it could not be true? That meta-habit, knowing how you know, is the difference between a checklist that works once and a verification skill you can teach a team.

A common mistake in this phase is to confuse fluency with correctness, and the whole point of reading like an auditor is to break that reflex. AI output is fluent by design; it reads smoothly, it sounds confident, it uses the right vocabulary, and none of that is evidence that it is true. The hardest errors to catch are not the obvious ones but the plausible ones: a threshold that is off by a number, a procedure with two correct steps in the wrong order, a citation to a real-sounding standard that does not exist, a statistic that is exactly the kind of number that gets quoted but was invented on the spot. By day 30 you should have trained yourself to feel a specific discomfort at any load-bearing claim that does not yet have a source attached, the way an accountant feels about a figure with no supporting document. That discomfort, applied consistently, is most of the skill. The checklist is just the written form of it, so that on a tired Friday you check by procedure instead of by mood.

Keep the checklist in whatever form you will actually use, a one-page document, a saved note, a template you paste into every review. Its value is not in being comprehensive but in being applied every single time, including the times you are sure the output is fine. The most dangerous AI output is not the one that looks wrong; it is the one that looks perfect, because that is the one you are tempted to wave through. A checklist exists precisely to stop you from trusting your own first impression of polished work.

Days 31 to 60: Build One Grounded, Defensible Thing

With a working checklist, the second thirty days move you from critic to builder, but a disciplined builder. Pick one small, real learning need, the smaller the better, and build a single module for it, with three rules that make it defensible.

Rule one: ground it. Do not let the AI draft from its training data. Give it the approved source, the SOP, the policy, the SME transcript, and require that every load-bearing claim come from that source. The artifact this produces is a grounded draft, meaning a draft in which every fact, threshold, and procedure can be traced back to an approved document, not conjured by the model. Grounding (also called RAG, retrieval-augmented generation) is the practice of forcing the model to answer from your material rather than its memory; it is the single most important habit for keeping a hallucinated claim out of a live module.

Rule two: validate one item. Have the AI draft assessment items, then take exactly one and make it a validated item: confirm it measures the stated objective at the right cognitive level, that the correct answer is genuinely correct, and that the wrong options (the distractors) are plausible but clearly wrong for a reason. One item, done to a standard you could defend, teaches you more than a hundred items glanced at, because the cardinal rule of the program is that AI does not certify a learner as competent: a human validates the assessment and owns the pass or fail decision.

Rule three: check accessibility. Run a real accessibility check against WCAG 2.2 AA (the accessibility conformance standard, a W3C Recommendation since 5 October 2023) on whatever media your module includes: captions on video, alt text on images, sufficient contrast, logical reading order, keyboard access. Accessibility is a gate, not a polish step; an AI-generated experience that fails it does not ship. By day 60 you have three stacked artifacts: a grounded draft, one validated item, and a passing accessibility check, which together are a small but genuinely defensible build.

One module, grounded, with one validated item and a passing accessibility check, beats a whole catalog that is fast, fluent, and indefensible.

Days 61 to 90: Design the Proof It Worked

The final thirty days are where most learning professionals never go, and where the elevated career actually lives. You have a correct, accessible build. Now design how you would know whether it worked, because "people completed it" is not knowing, and a CFO facing nearly free content will not accept it. Your day-90 artifact is a measurement design across Kirkpatrick Levels 1 to 3.

The Kirkpatrick model is the standard four-level framework for evaluating training, and you only need the first three for this artifact. Level 1, Reaction: did learners find it relevant and worthwhile (the "smile sheet," useful but the weakest evidence). Level 2, Learning: did they actually acquire the knowledge or skill, measured by your validated assessment. Level 3, Behavior: did they do the job differently afterward, the level that actually matters and the one almost nobody measures. Designing to Level 3 means deciding, before launch, what on-the-job behavior would change if the training worked, and how you would observe it, a manager observation, an error-rate change, a system metric. You are not running the evaluation in ninety days; you are designing it, which is the skill. Why this is the capstone: it is the evidence direction in miniature, and it is exactly the work, proving impact, that AI cannot do for you and that the CFO is paying for.

One subtlety worth naming: designing to Level 3 will sometimes reveal that you cannot define a behavior that would change, and that is not a failure of the exercise, it is the exercise working. If you genuinely cannot say what a learner would do differently on the job after your module, you have learned something important about the module, that it may be teaching knowledge nobody needs to act on, which is exactly the curation judgment a learning professional is supposed to make. A measurement design that ends in "there is no observable behavior here" is a finding, not a dead end. It tells you the build may not deserve to exist, and catching that on one small practice artifact, before you have spent a quarter on a flagship, is precisely the kind of cheap, early lesson the on-ramp is built to give you.

Stack the three phases and look at what you have on day 90: a verification checklist, a grounded draft, a validated item, a passing accessibility check, and a Level 1 to Level 3 measurement design. That is not a reading list completed. That is one verified, accessible, measured build, made by you, defensible to a SME, an accessibility auditor, and a CFO. You have become, in one quarter and one small artifact, the AI-aware learning professional this level is named for, and you are ready for L2, where you do it all again, deliberately, with the prompting and grounding craft that makes it fast.

How to Actually Finish This

Before the rules, one honest acknowledgment: the hardest part of this plan is not any single phase, it is protecting the time at all. The reason most learning professionals stay at "I have touched AI" is not that the phases are difficult; it is that the urgent work of the day, the launch due Friday, the SME who needs a reply, the LMS ticket, always wins against the important work of building one small thing that has no deadline. The on-ramp only happens if you give it a deadline of your own and a slot on the calendar that you defend like a meeting with your boss. Treat the day-30, day-60, and day-90 artifacts as commitments with dates, ideally ones you have told someone about, because a plan you have announced is far harder to quietly abandon than a plan that lives only in your head.

A plan that does not survive contact with a real week is a daydream, so three rules for finishing. First, keep the artifact absurdly small. The instinct to pick an important, visible module will kill the on-ramp, because the stakes make you cautious and slow; pick something low-stakes enough that you can afford to learn on it. Second, do the phases in order and do not skip the checklist; building before you can verify is how the hallucinated claim gets into your one defensible artifact and embarrasses you. Third, treat every artifact as a teaching object: the checklist, the grounded draft, the validated item, and the measurement design are exactly the things you will hand a team when you move into one of the elevated roles, so build them clean enough to show. Ninety days is enough time to cross from aware to capable, but only if you ship the small thing instead of reading about the big one.

Key Takeaways

• The gap between "exploring AI" (about 71% of L&D pros) and "using it routinely" (about 25%) is a doing gap, not a knowledge gap, and you close it by shipping one small, complete, defensible build, not by reading more.
• The plan is three thirty-day phases, each ending in a named artifact: a verification checklist (days 1 to 30), a grounded draft plus one validated item plus a passing accessibility check (days 31 to 60), and a Kirkpatrick Level 1 to Level 3 measurement design (days 61 to 90).
• Phase one replaces a vague "AI seems risky" feeling with a precise verification checklist built by actually hunting for hallucinations, misaligned items, and accessibility failures in real AI output.
• Phase two builds one grounded module: every load-bearing claim traces to an approved source (grounding, or RAG), one assessment item is validated to a defensible standard, and the media passes a real WCAG 2.2 AA accessibility check.
• One validated item teaches more than a hundred glanced-at items, because AI does not certify a learner as competent; a human validates the assessment and owns the pass or fail decision.
• Phase three is the capstone most people skip: designing a Kirkpatrick Level 1 to Level 3 measurement, including the Level 3 behavior change that almost nobody measures and the CFO actually pays for.
• By day 90 the stacked artifacts are one verified, accessible, measured build, defensible to a SME, an accessibility auditor, and a CFO, which makes you genuinely an AI-aware learning professional.
• Finishing requires keeping the artifact absurdly small and low-stakes, doing the phases in order without skipping the checklist, and building every artifact clean enough to hand a team.