MENTOR IDE Learning System
Most people who try to learn to code never finish. The median completion rate across 221 online courses is 12.6%. The failure isn't content — it's structure and environment. Beginners learn in browser sandboxes that don't transfer to real tools, and from fragmented resources that dissolve into tutorial hell. MENTOR is a product built to close that gap: coherent, sequenced instruction delivered inside VS Code — the editor they'll actually use — with local AI narration, offline lessons, and progress that persists across sessions.
"A beginner does not fail because the material is too hard. They fail because nothing told them what to do next, or because what they learned didn't survive contact with a real computer."
12.6%
MOOC completion rate
The problem MENTOR was built to solve
$14k
Avg bootcamp cost
vs MENTOR at $15/mo
6
Milestones shipped
End-to-end, from web auth to narrated lessons
100%
Local TTS
No API cost, no latency, runs in worker threads
My role
Solo product designer and developer — designed the learning system architecture, the VS Code extension panel, and the web app onboarding. Shipped the full stack from Figma to production VSIX.
Timeline
Ongoing — web app and VS Code extension live as of June 2026. Lesson content expanding quarterly.
Tools & tech
Next.js, Supabase, VS Code Extension API, Kokoro TTS, TypeScript, Figma
The convergence gap
Abundance solved access. It did not solve outcomes.
A beginner in 2026 can choose from hundreds of platforms and millions of hours of video, yet most never reach the point of building something real. Two failures explain it: the path dissolves — fragmented resources with no single voice carrying the learner forward — and the skills don't transfer — browser sandboxes that hide the real machine, so everything learned evaporates the moment the tab closes.
Delivering coherent, sequenced instruction inside a real development environment at the same time — something the market treats as an impossible trade-off
Building a local TTS narrator (Kokoro) that runs in VS Code worker threads without blocking the extension host, with chunking, caching, and stale-audio protection
Making the experience accessible to absolute beginners (zero prior setup) while keeping the environment genuine — real terminal, real editor, real version control from lesson one
The map
One image, one claim.
Every beginner platform takes a position on two axes: instructional coherence and environment realism. The valuable quadrant — coherent instruction inside a real environment — is nearly empty. MENTOR occupies it at $15/month.
Platforms positioned by environment realism (x) and instructional coherence (y). Mentor is the only platform in the top-right quadrant built for absolute beginners at accessible cost.
One path, not a catalogue
Most platforms hand beginners a catalogue and ask them to assemble their own curriculum — the hardest task you can give someone who came to acquire the expertise required to do it. MENTOR has a single, ordered journey from first variable to first deployed project.
How it was built
- Designed a content model with typed step formats: intro, concept, analogy, exercise, and win — each with explicit progression rules
- Shipped Course 01, Lesson 1 with 6 steps covering variables, types, and the terminal — tested with zero-experience beginners
- Built ID-safe routing so progress persists across restarts using full IDs (c01-l01-s01) rather than fragile numeric indices
- Bundled the full lesson JSON with the VSIX so lessons work offline from day one — no server round-trips required
Real tools from day one, with guardrails
Sandbox platforms protect beginners from the real environment. MENTOR does the opposite: beginners work in VS Code — the editor professionals use — but the extension scaffolds the experience progressively so complexity reveals itself in order.
How it was built
- Built a VS Code extension that activates on startup, catches deep-links from the web app, and opens lesson panels in context
- Designed the lesson panel as a webview inside VS Code — same editor, same terminal, guided by the panel alongside their real workspace
- Implemented a doctor command (Mentor: Check setup) that diagnoses the environment without requiring the learner to understand it
- Auth token stored in VS Code secret storage — no plaintext credentials, no manual configuration
A narrator, always on
Reading alone is slow and passive. Audio narration keeps beginners engaged and reduces cognitive load on dense concept steps — but cloud TTS adds latency, API cost, and a dependency that breaks offline.
How it was built
- Integrated Kokoro TTS (local, open-source) via kokoro-js — no API key, no external dependency, runs fully offline
- Isolated ONNX inference in a worker_threads worker so the extension host never blocks during generation
- Implemented sentence-level chunking at ~200-char boundaries, preventing token-limit cutoff and white-noise artifacts on long narrations
- Built proactive pre-generation — the next step's audio generates while the learner reads the current one, so playback is instant
Built, not just finished
Progress measured by lessons marked complete produces a false sense of mastery. MENTOR tracks what learners can actually do — position is saved across restarts, resume shows exactly where they left off, and every stage ends in something real on their own machine.
How it was built
- Saved step position to VS Code globalState on every navigation event using full course/lesson/step IDs
- Resume prompt on activation shows chapter and lesson title with Resume / Start over options — no auth required
- Exercise steps use a checkbox task list that auto-advances only when all tasks are checked — completion is verified, not assumed
- Packaged the full system as a VSIX that installs and runs outside dev mode — 401MB including Kokoro and onnxruntime native binaries
Reflection
Outcomes & learnings
Shipped
- End-to-end learning system live: web onboarding → deep-link → VS Code extension → lesson panel → narration → progress sync.
- Local Kokoro TTS with chunking, caching, pre-generation, and stale-audio protection — zero API cost, works offline.
- VSIX installs and runs outside F5 dev mode. TTS model cache persists across VS Code restarts; cold start paid once.
- Lesson panel renders 5 step types with keyboard navigation, back/forward, replay, hint, and context-aware CTA labels.
Learnings
- The convergence gap is real and measurable: coherence and environment realism are jointly necessary, not interchangeable. Optimising one without the other produces the 12.6% completion rate.
- Local inference (Kokoro in worker threads) is now a viable first-class choice — it removes a class of failure modes (latency, API keys, network dependency) that cloud TTS introduces.
- Building solo across design and code collapses the handoff gap — design decisions get validated in minutes, not sprints.
Where it goes from here
This is a position, not a proof. The next milestone adds learner-outcome data — completion rates, transfer metrics, and independent-build rates — measured against the same two axes. That is the test the claim has to pass.
"Stop teaching beginners in a box the real world doesn't have."