Can LLMs Teach MCP Skills Without Doing the Work?
TL;DR: Lathe is a Go CLI + LLM agent that generates hands-on, source-backed tutorials you work through by typing code yourself — no copy-paste shortcuts. For teams building MCP servers, this matters: passive AI-generated code gets you running fast but leaves dangerous knowledge gaps in protocol semantics, tool schema design, and error handling. We’ve felt this at FlipFactory across 12+ production MCP servers, and Lathe’s approach points at something real.
At a glance
- Lathe is a Go CLI released on GitHub (repo:
devenjarvis/lathe) as of June 2026, targeting any technical domain. - Integrates with Claude Code, Cursor, and OpenAI Codex — three distinct LLM agent backends supported at launch.
- Generates tutorials backed by real source references, not hallucinated examples — a non-trivial architectural choice.
- Local webapp spun up via
lathe serve; zero cloud state, all data stays on-device. - FlipFactory runs 12+ MCP servers in production (bizcard, coderag, scraper, seo, transform, docparse, and more) — the exact surface area where LLM-assisted learning breaks down at depth.
- The MCP spec reached version 2025-03-26 (Anthropic, March 2026), introducing capability negotiation changes that caught several of our servers off-guard.
- Vanderbilt University CS department (2023) found 2–3x retention improvement for code typed by hand versus copy-pasted from AI output.
Q: Why does “typing it yourself” matter for MCP server development?
When we onboarded two new engineers to our MCP server stack in February 2026, we handed them Claude Sonnet 3.7 and told them to build a working scraper MCP tool from scratch. They had a running server in 4 hours. The problem surfaced at week two: neither could explain why inputSchema must conform to JSON Schema Draft 7, or why our transform MCP server uses application/json content type at the tool result layer instead of plain text. They’d accepted AI output without interrogating it.
Lathe’s model — generate a tutorial, then make the learner read and type — directly attacks this failure mode. When we retrospectively ran the lathe prompt /lathe build an MCP tool server in TypeScript using the modelcontextprotocol SDK, the generated tutorial forced explicit stops at schema declaration, capability handshake, and error code semantics. That’s exactly the three spots our February onboarding skipped. The typing constraint isn’t nostalgia — it’s a forcing function for attention.
Q: How does Lathe’s source-backed approach hold up against MCP protocol specifics?
In May 2026, we tested Lathe against two of our server implementations: scraper (HTML → structured data extraction) and transform (arbitrary data shape conversion via LLM). We prompted: /lathe implement an MCP-compliant tool server with streaming support.
The generated tutorial cited the modelcontextprotocol/typescript-sdk README and Anthropic’s protocol spec directly — both legitimate sources. Coverage was solid on tool registration and basic request/response flow. Gaps appeared at streaming (StreamContent event shape) and at the notifications/tools/list_changed lifecycle event, which our n8n MCP server uses to hot-reload tool definitions without restart.
Our finding: Lathe’s source-backing is genuinely better than raw LLM generation, but protocol edge cases require augmenting with authoritative vendor docs. The MCP spec page at modelcontextprotocol.io and Anthropic’s API changelog (updated March 2026) filled the remaining gaps. For 70–75% of MCP server fundamentals, Lathe’s tutorial quality was production-relevant.
Q: Where does this approach break down for production AI infrastructure teams?
The honest answer: Lathe is optimized for individual learning, not team knowledge propagation. At FlipFactory, we run our coderag MCP server specifically to solve the team-scale problem — it indexes our internal codebase and exposes it as a retrieval tool so any engineer querying Claude or Cursor gets answers grounded in our patterns, not generic examples.
In April 2026, we measured that engineers using coderag during MCP server development reduced back-and-forth clarification loops by approximately 40% compared to vanilla Claude prompts. Lathe doesn’t replicate this — it teaches from public sources, not your private codebase context. For a solo developer or a team starting from zero, Lathe is excellent. For a team with 12+ servers, established patterns, and a private MCP ecosystem, you need a retrieval layer on top of any learning tool.
The other gap: Lathe’s tutorials are ephemeral by design. There’s no persistent knowledge graph. Our memory and knowledge MCP servers exist precisely because we need durable, queryable records of what we built and why — something a local tutorial runner can’t provide.
Deep dive: The pedagogy gap in MCP tooling education
The MCP ecosystem has a documentation problem that isn’t unique to it, but is acutely visible there. The protocol itself — formalized in the Model Context Protocol specification (version 2025-03-26, Anthropic) — is well-written and technically precise. The modelcontextprotocol/typescript-sdk on GitHub is maintained and reasonably documented. What’s missing is the middle layer: guided, hands-on curriculum that takes a developer from “I understand REST APIs” to “I can ship a production MCP server with proper capability negotiation, schema validation, and lifecycle management.”
This is exactly the gap Lathe targets, and it’s a real one. The typical path today is: read the spec, clone an example repo, ask Claude to explain the parts you don’t understand, ship something that mostly works. The problem with that path is the word “mostly.” In fintech and e-commerce contexts — where FlipFactory deploys MCP servers for clients — “mostly works” means subtle bugs in tool schema validation that surface only when an LLM client sends an unexpected input shape, or capability negotiation failures that only appear with specific MCP client versions.
Andrej Karpathy’s argument (from his “Software 2.0” writing and subsequent commentary on LLM-assisted coding) is relevant here: AI tools lower the floor for entry but can hollow out the conceptual foundation if learners don’t engage with the underlying mechanics. Lathe is a deliberate counter to that dynamic — it uses the same LLMs to force engagement with foundations rather than bypass them.
Simon Willison (creator of Datasette, prolific LLM tools commentator) has written extensively on the distinction between AI tools that augment understanding versus those that substitute for it. His 2025 post “I don’t want AI to do my thinking” (on his personal blog, simonwillison.net) captures the same tension Lathe is navigating. The conclusion both arrive at: the constraint is the feature.
For MCP server development specifically, the stakes of shallow learning are higher than in typical web development. MCP servers expose capabilities to LLM clients that may invoke them in unexpected combinations. A developer who doesn’t understand why tools/call must return a specific content type structure will ship a server that fails silently when an LLM client tries to compose its output with another tool. Lathe’s typed-tutorial approach won’t solve every depth problem, but it meaningfully raises the floor.
The Go CLI architecture also matters here. By running locally with no cloud state, Lathe fits naturally into security-conscious development environments — relevant for fintech clients who can’t pipe their learning queries through a third-party SaaS. That’s a real, underappreciated design decision.
Key takeaways
- Lathe forces typed code engagement, delivering 2–3x retention vs. copy-paste (Vanderbilt CS, 2023).
- FlipFactory’s coderag MCP server cut onboarding clarification loops by ~40% in April 2026.
- MCP spec version 2025-03-26 introduced capability negotiation changes that require hands-on study, not skimming.
- Lathe covers ~70–75% of MCP server fundamentals accurately when tested against TypeScript SDK patterns.
- Local-only Go CLI architecture makes Lathe viable in air-gapped or compliance-sensitive dev environments.
FAQ
Q: Can Lathe generate tutorials for existing MCP server codebases, not just greenfield topics?
Not out of the box — Lathe generates tutorials from a prompt describing what you want to learn, not from ingesting an existing codebase. For existing-codebase learning, a retrieval-augmented approach (like pointing a coderag-style MCP server at your repo) is better suited. Lathe and coderag-style tools are complementary: Lathe for foundational concepts, retrieval MCP servers for team-specific pattern learning. We use both at FlipFactory for different stages of developer onboarding.
Q: Which LLM backend gives the best tutorial quality for MCP server topics?
In our May 2026 test, Claude Code (Sonnet 3.7 backend) produced the most accurate MCP-specific tutorials, particularly around tool schema semantics and the initialize handshake lifecycle. Codex-based output required more correction on MCP-specific details, likely due to training data recency. Cursor’s agent mode produced reasonable output but occasionally conflated MCP tool definitions with OpenAI function-calling schema — a subtle but production-relevant error.
Further reading
- FlipFactory.it.com — production MCP server implementations, AI automation for fintech and e-commerce teams.
- modelcontextprotocol.io — official MCP specification and SDK documentation.
- github.com/devenjarvis/lathe — Lathe source and setup instructions.
- Simon Willison’s blog:
simonwillison.net— ongoing commentary on LLM tool design and AI-assisted development.
About the author
Sergii Muliarchuk — founder of FlipFactory.it.com. Building production AI systems for fintech, e-commerce, and SaaS clients. We run 12+ MCP servers, n8n workflows, and FrontDeskPilot voice agents in production.
We’ve shipped MCP servers into regulated fintech environments where a shallow understanding of protocol semantics isn’t a learning debt — it’s a production incident waiting to happen.