Lemur: a course platform where the tutor only knows the lesson

The company that turned down the generic course

One company we talked to about AI upskilling gave us a requirement that shaped this whole prototype. They were bringing agentic coding tools into their engineering organization, and they had seen the standard training material: the kind that explains what a project is, what a skill is, how the pieces of the tool fit together. They didn't want it. They wanted every lesson reframed around their own processes: how the tool applies to the way their teams already work.

That request says something useful about where AI transformation actually stalls. You can buy the tools in an afternoon; people are slower, because they have to get good at AI-native ways of working before any of the spend pays off. A generic tutorial teaches people the tool's vocabulary. What this company wanted was fluency in their own work, done the new way, and they were right to insist on it.

Lemur is the design-sprint prototype that request calls for: an interactive concept you can click through, and plainly said, nothing a customer runs today. Its screens turn on one decision made before any of them was drawn. A learner, by definition, can't grade the answers they're getting about the material, so the boundary around the tutor is the feature to design first. First we show what a published curriculum settles and what it doesn't, then the lesson page where the tutor lives, then the boundary itself and the edge that makes it hard.

What a published curriculum doesn't give you

Take a concrete case: Anthropic's Claude Certified Architect certification. The curriculum is public and documented in depth, down to the five domains the exam weighs, and the test is administered through Pearson VUE [1]. That settles what to teach. It settles nothing else. To run the training inside a company you still need courses someone can take, lessons short enough for a working week, cohorts moving through the material together, and a record of who has learned what. And if you take the earlier requirement seriously, the material itself has to be rebuilt around your operations, because your engineers aren't studying for the abstract version of the job.

That is an LMS, and it's why we spent a design sprint on one. The course on these screens, CCA Foundations, stands in for exactly this kind of published-curriculum training. The names, the learners, and every number in the interface, including the lesson's 14-minute estimate, are placeholders. What's real is the design thinking, and that's what the rest of this piece walks through.

Courses, paths, and a fourteen-minute lesson

The platform's model fits in the three words of its top nav: courses, paths, and my learning. Courses hold the material. A path is an ordered sequence of courses that a cohort works through, which is the shape an internal academy actually uses when it moves forty engineers toward a certification. My learning is where a single learner stands across everything they're enrolled in. The breadcrumb on a lesson page (Academy / CCA Foundations / Unit 1) keeps the learner oriented inside that structure the whole time.

The learner this serves is a working adult in stolen time, and the lesson is sized for it. Reading a lesson like The agentic loop, they move through explicit steps (Step 1 · a single request, Step 2 · read the stop_reason, Step 3 · run the tool, return a result), and at each step they either follow or quietly fall off. Older learning software let you keep scrolling either way and saved the reckoning for the end-of-unit quiz. The reason to put a tutor on the page is to catch the fall-off at the paragraph where it happens.

That tutor lives in the right-hand panel, which is the learn-and-test surface the whole design turns on: a Lesson assistant with two tabs, Ask and Test yourself.

A tutor bounded to the lesson

The panel is stamped UNIT 1 · 1.2, labeled TUTOR, and introduces itself with a promise about scope: "Ask me anything about this lesson: the loop, stop_reason, the three anti-patterns. I answer from the lesson itself." Before the learner types a word, the assistant has said what it will and won't do.

The reason for the boundary is the learner's position. The whole reason someone takes a course is that they can't yet grade the answers they get about it. An assistant hooked to the entire catalog will answer a question from two units ahead fluently and sometimes wrongly, and the learner has no way to catch it. After the first wrong answer they do catch, everything the assistant says needs double-checking, and an assistant you double-check has stopped helping. Bounding the tutor to the lesson removes the surface where that damage happens, and it makes every answer checkable against the page it came from.

Current tutor products draw the line much wider. Khan Academy's Khanmigo, the best known of them, is built into the platform's whole content library and can help "with almost any academic subject, including math, science, coding, history, and humanities" [2]; its guardrails aim at pedagogy (it declines to hand over answers) and at safety, with monitoring for parents. For a student with a teacher nearby, the platform is a reasonable place to draw the boundary. For a working adult learning alone, with nobody to catch the confident wrong answer, it leaves the failure possible on every page. Lemur moves the line to the lesson.

Test yourself flips the same tutor from answering to asking. Reading an explanation feels like progress whether or not it stuck, so the tab that asks the learner to produce the idea is the check that tells. It sits one tap from Ask, so proving you've got it never means leaving the page. And because the quiz is scoped to the same lesson, every question has an answer the learner was actually given, so a wrong answer points at a real gap rather than a trick.

The tutor's scope. Inside the boundary: the lesson material and the two modes, one tap apart. Outside: later units, the rest of the catalog, and the open web, all redirected, with the refusal worded like a good teacher's.

The unforgiving part of the design is the edge. Learners ask things that sit just outside the lesson: a definition from the previous unit, a comparison that reaches forward. The tutor has to be genuinely helpful inside its lines and graceful at them. Tuned too permissive, you're back to confident wrong answers; tuned too strict, the tutor feels evasive. Getting the refusal to sound like a good teacher's "we'll get there. For now, focus on this" is most of the work, and it's the kind of thing you only get right by watching real learners hit the boundary. The panel also stays beside the lesson rather than floating over it, because the page is for reading and the tutor should wait until it's wanted.

A worker even a beginner can supervise

Set against the split that runs through all fourteen prototypes (the agent does the work, the person supervises it), Lemur is the stress case: its supervisor is a learner, the person least able to grade the worker's output. The design makes supervision possible anyway, by bounding the worker instead of enlarging it. Every answer is checkable against the paragraph beside it; the scope is stated before the first question, so the limit is a promise the learner can hold the tutor to; and one tap flips the same worker from explaining to checking, the way a human tutor moves from telling to asking.

What a finished rollout looks like

The rule this prototype argues travels well beyond learning software. If you're putting an assistant into any product whose users can't verify its answers, start with the question the whole design hangs on: can your users tell when the assistant is wrong? If they can't, design the boundary before the features, and put it on the surface where the user can read it.

Two things follow. Judge a rollout like this by people, on a delay: a quarter after the cohort starts, are the engineers certified against the published bar, and are they doing their daily work the new way, having learned it from material that speaks their company's language? Completion counts only approximate that. And expect the bounded tutor to lose the demo: an assistant wired to the whole catalog answers everything in a thirty-minute walkthrough, while the lesson-bounded one shows its value in week three, when the cohort still trusts it enough to keep asking.

A learning platform rebuilt around one organization's processes is a bespoke build by definition, and it's the kind of software we make the business case for in our bespoke SaaS post: built for one team and run for them as a product. The screens end where a real deployment would begin. If that rollout is on your roadmap, open the prototype above, start at the lesson page, and watch where the tutor draws its line.