Manual eLearning production is slow and inconsistent. Every new course re-litigates the same interactions from scratch, brand drift creeps in the moment a designer looks away, and review happens across scattered threads with no clean way to hand notes back to whoever's building. It's a lot of skilled time spent on work that shouldn't need a human every time.

• On-brand output with no designer babysitting the result.
• Interactions built once as reusable parts, never re-solved per course.
• Non-technical reviewers can approve or reject without touching code.
• Edits round-trip cleanly back into the build environment.

An AI-assisted production framework, built in Cursor. A script goes in; a brand-compliant, review-ready SCORM course comes out. Under it sits a library of interaction primitives (originally hand-coded in HTML to do what off-the-shelf tools can't), a machine-readable brand and UI spec the generator is bound to, and an Apps Script review portal that packages the course, routes it for approval, and feeds comments back to the developer backend.

Guardrail as code. Rather than trusting a style checklist, I made the brand system a spec the generator has to obey, so off-brand output isn't a mistake that can happen.

Primitives over one-offs. Solving each interaction once meant the system got faster and more consistent with every course.

Review without code. The approval loop was designed for the people who sign off, not the people who build, which took the dev team out of the bottleneck.

Multi-day manual builds collapsed toward same-day output, brand consistency became automatic instead of hand-policed, and course review stopped waiting on developer availability. More to the point: it moved the team's skilled time off assembly and onto the parts that actually need judgment.

The platform had no memory between conversations. Every new chat started cold: restate the goal, the role, the constraints, the context. Long code sessions made it worse, because the work itself would fill the context window and I'd end up re-explaining problems I had already walked through minutes earlier. Every session felt like onboarding a stranger who happened to be fast.

• Context available at the start of a session without manual re-typing.
• A clean split between durable facts and fast-changing state.
• The model flags when its picture of my work has gone stale.
• A defined working relationship, not just a data dump about me.

A layered instruction system for a stateless AI platform. Three layers do the work: a durable brief covering how I work, my role, and my goals; a dated volatile layer holding current projects and standpoints; and a persona layer defining how the model should interact with me, what I value, and what success and failure mean. To make the brief accurate, I had the model run reasoning tests and used the deltas between runs to find and cover blind spots in my own self-description.

Durable vs volatile. Separating stable facts from weekly churn keeps the core steady while the current-state layer stays fresh.

Calibrate against blind spots. Test deltas surfaced gaps a self-written brief would have missed, so the instructions describe me more accurately than I could unaided.

Design the relationship. Giving the model a persona and clear success and failure definitions made results land right without constant re-steering.

The honest answer is that the impact resists a clean metric, and I would rather not invent one. What changed is qualitative but real: sessions start warm instead of cold, I stopped re-explaining the same context every chat, and long code sessions no longer collapse into re-litigating solved problems. Each conversation now picks up like a continuation rather than a first meeting. The durable-versus-volatile pattern also became my default way of working with any stateless model, not just this one.