Lathe Wants LLMs to Teach You, Not Do the Work for You

There's a quiet skill-atrophy problem hiding inside every productive AI coding session. You ship faster, but you often learn nothing. Lathe, a new open-source tool that hit Hacker News this week and picked up nearly a thousand GitHub stars fast, takes direct aim at that tradeoff.

The premise is simple and deliberately old-school: use an LLM to generate a multi-part, hands-on tutorial about whatever domain you want to learn, then actually work through it yourself in a purpose-built local UI. No AI co-pilot finishing your sentences. Just you and a well-structured exercise.

How It Works

Lathe is a Go CLI paired with a set of "skills" — structured prompt files that teach Claude Code, Cursor, or Codex how to build and manage tutorials. The binary is self-contained; after install you drop the skills into your project (or globally) with a single command:

lathe skills install          # project-local, Claude Code
lathe skills install --user   # user-global
lathe skills install --agent cursor   # Cursor slash commands
lathe skills install --agent codex    # Codex Agent Skills
lathe skills install --agent all      # all three

From inside an active LLM session you then trigger generation with a natural-language prompt:

/lathe build a 3D Slicer in Erlang

The LLM runs the skill, writes the tutorial, and stores it via the CLI. Then:

lathe serve   # starts the local web server, opens the browser

The web UI lets you read the tutorial, ask questions about it, have the LLM verify its accuracy, or extend it with a new part — but crucially, every one of those follow-up actions hands you back a prompt to run yourself. The UI doesn't shortcut the learning loop; it scaffolds it.

Each generated tutorial also records its provenance: which model produced it, what prompt set the "voice," and where the source material came from.

The Philosophy Behind It

The creator traces Lathe's motivation to formative experiences learning C++ through the PSP homebrew community in the mid-2000s, and to years of upskilling via hands-on resources like Crafting Interpreters and the build-your-own-x repository. That style of learning — zero-to-one in a new domain by actually building something — is what he's trying to preserve.

The concern isn't that LLMs are bad tools. It's that their default affordance is completion, not comprehension. When a model writes the raytracer or the time-series database for you, you've shipped something but you haven't earned the mental model that lets you go from one-to-ten on your own. Lathe's bet is that the same generative capability can be pointed at explaining rather than doing, and that the output can be good enough to replace the scattershot quality of searching for tutorials on niche topics.

This is also why skills are tuned specifically for approachability — the README calls it "skills tuned to make content approachable" — rather than just dumping a wall of reference documentation at you.

Installation and Toolchain

Lathe ships as a single binary. On macOS, Homebrew is the recommended path:

brew install devenjarvis/tap/lathe

Linux users can use the curl installer or go install (requires Go 1.25+, notably a future release at time of writing):

curl -sSf https://raw.githubusercontent.com/devenjarvis/lathe/main/install.sh | sh
# or
go install github.com/devenjarvis/lathe@latest

The skills themselves are Markdown files (SKILL.md) that Claude Code and Codex consume natively. Cursor maps them to slash commands (/lathe). Because Codex uses the same format as Claude Code, those skills ship verbatim; a few runtime handoff details differ on Cursor.

Worth Watching

Lathe is explicitly labeled an experiment, and there are obvious open questions: How well do the generated tutorials hold up on genuinely obscure domains where the underlying model is thin on data? How much does tutorial quality vary across models? The provenance metadata is a smart hedge here — at least you know which model you're trusting.

But the core insight is sound and underexplored. The developer tooling ecosystem has invested enormous energy in making LLMs better at writing code on your behalf. Very little of that energy has gone into making them better at teaching. For developers who care about actually understanding the systems they work with — and most good engineers do — that gap is worth closing.