One Claude Code skill generates a tutorial and makes you type every line

Lathe: a Claude Code skill that teaches instead of codes

Lathe is a Show HN project from Deven Jarvis — a Claude Code skill that generates hands-on technical tutorials on demand, then forces you to work through them yourself. The motivation, stated plainly in the README: the author kept having LLMs code for him and learning nothing. The thread surfaced it to 277 points and 51 comments, with Jarvis appearing throughout to field questions.

What Lathe actually does and how it is built

The system has two parts. A set of Claude Code skills — Markdown files that instruct the model — handles tutorial generation. A Go CLI manages storage and serves a local web interface at http://localhost:4242. The entry command is dead simple: /lathe build a 3D Slicer in Erlang inside a Claude Code session. The skill researches the topic using actual documentation and source URLs (logged as metadata), then produces a structured multi-part tutorial with a table of contents, "side-notes" prompting deeper thinking, and "left-to-the-reader" exercises at the end of each section.

A second model pass runs /lathe-verify in a temporary directory to test that the tutorial's code actually compiles before delivery. Metadata tracks the research URLs consulted, tool versions, the generation model, verification status, and creation date. Additional commands extend the series (/lathe-extend), answer questions about content (/lathe-ask), or add searchable tags (/lathe-tag). Tutorials are stored in ~/.lathe/tutorials/{slug}/ as a metadata.json file and markdown parts.

Two writing voices are available — a plainspoken default and a companion alternative — and users can define custom voices with /lathe-voice. Installation via Homebrew (brew install devenjarvis/tap/lathe) requires Go 1.25+.

The design principle the author cares about most

Jarvis draws a clear hierarchy in the README: if human-written documentation exists for a topic, use that. Lathe is for the gaps — new libraries, obscure tools, internal frameworks with no public docs. The rationale for forcing the user to type code rather than accepting generated output echoes how Jarvis learned programming through PSP homebrew communities: you read the example, you type it, you catch your own errors, you build fluency through contact with the material rather than passive consumption.

The verification step matters here. By testing that generated code compiles before the tutorial reaches the user, Lathe imposes a minimum correctness bar that a raw chat session does not. It does not eliminate hallucinations, but it does filter the most embarrassing category of them.

The thread's reversals: who is Lathe actually for?

Jarvis responds throughout the thread, which is the clearest signal that this is genuine Show HN territory — the author defending design decisions in real time.

The most direct challenge comes from a Udemy and Pluralsight instructor with years of technical education experience:

"Even now, LLMs are terrible educators. They do not make coherent progressive curriculums. They hallucinate details which the student will not have the knowledge to challenge. Don't expect it to teach you reliably though. It feels good to ask the LLM whatever you want, but if you're learning a topic you don't have the instinct to realize when it's giving you a poorly chosen progression of information or teaching you something flat out untrue." — Udemy and Pluralsight author, UX and AI strategist

That critique lands at the product's core tension: the audience most likely to use Lathe (beginners in a new domain) is exactly the audience least equipped to catch what the LLM gets wrong.

But another commenter inverts the frame entirely, drawing on Stephen Krashen's Input Hypothesis:

"I tested it on a programming language I had been learning for a while and was struggling with. After just a few hours of typing my fluency had skyrocketed. I realized that in several hours of typing I had written more code than in weeks of study… Understanding something theoretically and being able to use it are two very different things!" — an HN user citing language acquisition research

A third voice — a machine learning engineer building multi-agent frameworks with a PhD from CMU — describes a Socratic complement:

"A related idea is to have the LLM quiz you, Socratic-style about a topic of interest. It persists in asking questions at deeper levels until you arrive at the answer yourself. This forces you to think hard about a problem, and this effort helps with understanding, learning and retention. Strong LLMs are surprisingly good at this type of quizzing, they display a semblance of 'theory of mind.'" — Prasad Chalasani, Langroid author and CMU ML PhD

The attribution problem no one fully resolves

One comment the thread does not settle: a user points out that Lathe's tutorials serve content from human sources but strip the attribution. The README acknowledges this implicitly by logging research URLs in metadata, but those URLs are internal to the stored tutorial — the reader of the generated text sees no citation trail. For a tool explicitly positioned as a complement to human-written documentation, that gap is real. Jarvis does not have a clean answer to it in the thread, and no one pretends otherwise.