How it all started
A few years ago, I created RustInsight. It was a set of step-by-step Rust courses where the reader built an application by following instructions — kind of like assembling a LEGO set. You’d go step by step, adding code to source files, and that’s how you learned Rust.
At the same time, the application was being built as you progressed, so you could always see what the final result should look like and compare it with your own work. In the end, you didn’t just learn — you practiced and got a real, working application, like a microservice.
The downside was that if you made a mistake, you had to debug it yourself (though diffs sometimes helped).
Why I still believe in this idea
I still think the core idea was right. People don’t really learn by endlessly watching videos or reading articles — they learn by building things with their own hands.
RustInsight brought me my first customers. People actually needed this. But it was also my first serious launch, and I didn’t do everything right. I barely tracked metrics, didn’t fully understand what worked and what didn’t, and sometimes I simply couldn’t keep up with support requests.
I didn’t shut the project down, but it slowly drifted into stagnation.
Then the AI revolution happened
By that time, I was already actively using AI in my work. It helped me test applications, process voice recordings, and turn speech into structured text. It made both content creation and development much faster.
But there was a problem: all these improvements mostly helped me, not the learner.
Meanwhile, developers had already started using AI agents in their daily workflows.
Rethinking the format
That’s when it clicked — the old format had to change. It wasn’t enough to just create good step-by-step courses anymore. AI had to be embedded directly into the learning process, because we now work inside dev agents (some people have even ditched IDEs altogether — though I still stick with good old vim).
This is also the point where I started building what eventually became Knowledge.Dev — a new attempt to rethink how learning-by-building should work in the AI era.
First attempt: a web-based player
At first, I built a new player as a web app. It would set up context for an AI agent (locally, in a selected folder — which was a pretty neat idea), and the agent would act as an instructor: helping you build the app, guiding you, explaining things, and nudging you forward step by step.
It worked in a really interesting way. But it also had limitations. Everything relied on the File Access API, which meant it mostly worked well only in Chrome. Plus, the AI agent would sometimes lose context and forget what it was supposed to do.
A different approach: MCP
So I decided to try a completely different approach.
I built a player with no separate interface at all — just a local MCP server that connects directly to your AI agent. It loads step-by-step instructions and guides the agent throughout the learning process. The agent then helps the learner write code, complete tasks, and understand key concepts along the way.
The breakthrough moment
And this is where it started to feel like a real breakthrough.
There’s now way more hands-on practice than before. Learners don’t have to sit through long chunks of text anymore. Instead, they get short, clear tasks, complete them step by step, and gradually build a full product.
Not a toy. Not a code snippet. A real application.
That’s exactly what I wanted from the very beginning: learning that mirrors real engineering work.
Trade-offs and what’s next
Yes, learning through MCP might not be the easiest entry point for beginners. It’s not as simple as opening a website and clicking a button. But for me, what matters more is that learners gain real, practical engineering experience — not just the feeling that they’ve “covered the material.”
That said, I do have another big idea in mind to make the experience even better, and I’m actively working on it.
Try it out
If this kind of learning sounds interesting to you, check out the project here: https://knowledge.dev
That’s what I’ve built so far. There’s also a small demo that doesn’t require MCP — give it a try to see how it works.
Let’s talk
And if you’d like to follow the progress or discuss the idea, join the Discord: https://knowledge.dev/discord/
I just launched it recently, so you can reach me there directly. Maybe you even have an idea for a specific playground 🙂
Top comments (0)