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. The tools are the fast part; you can buy them in an afternoon. The slow part is people, who 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.

What a published curriculum doesn't give you

Take a concrete case: the Claude Code architect certification. The curriculum is public and documented in depth; anyone can read what the test covers. 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. Lemur is the result: a design-sprint prototype rather than a shipped product. 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. A lesson-bounded tutor is less impressive in a demo and more trusted in week three.

Test yourself flips the same tutor from answering to asking. Explanations feel like learning whether or not they stick; producing the idea is the honest check. The tab 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.

If you're putting an assistant into any product whose users can't verify its answers, the question this prototype is built around applies directly: can your users tell when your assistant is wrong? If they can't, the boundary is the feature to design first.

What a finished rollout looks like

The rollout that company asked for ends with people, and that's how a platform like this should be judged. A quarter after the cohort starts, are the engineers certified against the published bar? Are they doing their daily work the new way, having learned it from material that speaks their company's language? Progress dashboards and completion counts are proxies; the change in how the work gets done is the result.

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. Lemur is the design-sprint version of that argument for learning. The screens end where a real deployment would begin, with a company's own processes in the lessons and its own people, a quarter later, working differently.