There is no lecturer at Zone01 Kisumu.
I walked in with no programming experience at all. I expected it to be hard, and I hoped for the best. What I got was harder, and more frustrating, than I'd prepared for.
In that first week, I was dropped straight into concepts I'd never seen and expected to find my own way through them. Nobody stands at a whiteboard and explains how loops work. You get a spec and a deadline, and you work it out.
Asking for help wasn't as simple as I'd imagined either. Everyone around me was at a different level. Ask a teammate who'd been coding for years, and you might get an explanation so deep and technical that it went straight over your head. The help was real, but it wasn't pitched at where I was standing.
It took a few weeks before I steadied myself. Even then, surviving the pool meant putting in more hours than most of the people around me, because I was starting from zero. I'm not saying that for sympathy. It's the honest starting point of this story, and it's why I think what came next is worth sharing.
I've since moved from JavaScript exercises to Go backends, a DNS server, a web forum, and a Lightning Network escrow system shipped at a hackathon. Looking back, almost everything I know came from one idea: you learn the most when nobody hands you the answer.
This article is about what that looks like in practice: what worked, what was hard, and what I'd tell someone about to start.
What "peer learning" actually means
Before the details, here is the model in plain terms.
At Zone01, there's no curriculum delivered by instructors. Projects are specified, and you're expected to figure out how to build them. When you get stuck, you ask your peers. When someone else is stuck, you're expected to help, which turns out to be where a lot of the learning happens.
It's project-based all the way down. You don't finish a chapter and then take a quiz. You build something, and an automated grader or a peer review tells you whether it works.
That sounds simple, but it changes how you learn. In a lecture, you can feel like you understand something because the explanation made sense. In a project, you find out fast whether you do, because the code either runs or it doesn't.
The piscine: a month of productive confusion
The "piscine" (French for swimming pool) is the intense entry phase: you get thrown in and learn to swim. Mine was JavaScript.
Some exercises looked easy and weren't. I remember working through deep-freezing objects with Object.freeze(). The first version I wrote froze the outer object and nothing else, because Object.freeze() is shallow. Nested objects stayed mutable. That one bug taught me more about references and mutability than any definition could have, because I had to see the mutation happen to believe it.
Then came the regex exercises: sameAmount, ionOut, groupPrice, findIP. Regex is unusual in that you can't half-understand it. A pattern either matches what you meant or it doesn't. findIP in particular forced me to think about edge cases: what counts as a valid octet, what the boundaries are, what the pattern should reject.
The Date exercises were humbling for a different reason. Dates look simple until you hit month boundaries, leap years, and time zones. Seven projects on Date taught me to distrust my assumptions about "obvious" things.
By Level 12, the work moved to the DOM: keycodes-symphony, mouse-trap, pick-and-click, gossip-grid, where-do-we-go. This is where JavaScript stopped being abstract. You write code and something happens on screen. Events, state, and the order things run in all start to matter. Then came object utilities like invert, pick-omit, and fusion, which were small functions with a big lesson: when you rebuild the tools you normally take for granted, you understand what they actually do.
What the piscine really teaches
The exercises are the surface. Underneath, the piscine teaches habits:
- Read the spec twice. Most of my early failures were me solving a problem the spec didn't ask for.
- Run the grader, read the failure, change one thing. Changing five things at once means you never learn which one mattered.
- Get comfortable being stuck. Being stuck isn't a sign you're failing. It's the state in which learning happens.
Debugging is the real curriculum
One project stands out when I think about what this program teaches: a JavaScript crossword solver, split across multiple ES modules.
It wasn't hard because of the algorithm. It was hard because of the bugs. An indexing mistake that was off by one. A variable referenced in a file where it was never defined. And my favorite, a direction check in placeWord.js that was logically inverted, so words were being placed in exactly the wrong orientation.
None of those bugs are impressive. Every one of them cost me hours. And every one of them made me better, because I learned to stop guessing and start tracing: print the state, check the assumption, narrow the problem down.
Multi-file projects were the other lesson. Once your code is spread across modules, "where does this value come from?" becomes a real question. That's closer to real work than any single-file exercise.
I also built a superhero database app in vanilla JavaScript with sorting, filtering, and pagination. Doing it without a framework was the point. I had to implement the logic that a library would normally hide, and now I understand what frameworks are saving me from.
Moving to Go: concurrency stops being theory
After the JavaScript phase, the projects got bigger and the language changed to Go.
The TCP chat server
My Net-Cat clone, a TCP chat server, was where Go clicked. It uses goroutines for each connection, channels for communication, and the Hub pattern: a central goroutine that owns the state and coordinates everyone else.
Before this project, "concurrency" was a word. After it, I'd felt what a race condition is. Two clients writing at once will find every flaw in your design.
The Hub pattern also taught me something about design: instead of protecting shared state with locks everywhere, you give one goroutine ownership of that state and have everyone else talk to it through channels. It's a way of thinking, not just a technique.
The web forum
Next came a web forum in Go with SQLite: authentication, posts, comments, and tests.
This was my first project that felt like a real application. It had users, sessions, a database, and the dull-but-important concerns that tutorials skip: validating input, handling errors without leaking details, and keeping the database layer separate from the handlers.
Writing tests for it changed how I coded. When your code is hard to test, it's usually badly structured, and the tests tell you so before anyone else does.
The DNS server
I also built a DNS server in Go. DNS is one of those things you use a thousand times a day without thinking about it. Building a server meant reading about how queries and responses are structured, then writing code that speaks that protocol.
It was the first time I felt the gap between using the internet and understanding it.
Shipping under pressure
Hackathons are where the peer-learning model shows its value, because the conditions are the same as the program: unclear problem, tight deadline, and a team that has to figure it out together.
At one hackathon, I shipped Karanda, a Lightning Network escrow system. Before that, my exposure to Bitcoin and the Lightning Network was a week-long developer bootcamp, where I worked through a Go-based blockchain explorer against a local regtest node, debugged JSON-RPC issues, configured bitcoin.conf, and set up Lightning nodes for two test users.
Going from "I just learned what a channel is" to "I shipped an escrow built on it" in a short time is only possible because the program trains you to learn on demand.
The hackathon lasted 48 hours, and there were five of us. We didn't split into neat, fixed roles. We coordinated across everything together, picking up whatever the project needed at the moment. That's peer learning in its purest form: no one assigned the work, and no one had all the answers.
It was tight. We finished with the deadline nearly on top of us. But what I remember most isn't the pressure. It's that we took an idea and turned it into something real. Lightning had been new to me, and now there was a working product built on it.
The biggest lesson wasn't technical. It was scoping. Under a deadline, you learn quickly to separate "must work" from "nice to have", and to ship something small that works over something ambitious that doesn't.
The habits nobody warned me about
Some of the most useful parts of Zone01 aren't coding at all.
Daily standups. Logging what you did, what's blocking you, and what's next feels like paperwork at first. Over time it becomes a way to stay honest about your progress. It's hard to tell yourself you're making progress when the log says otherwise.
OKRs and documentation. Writing objectives and documenting your work felt corporate to me at first. Now I think it's what separates someone who can code from someone who can work on a team. *
Writing publicly. I started writing on dev.to, covering events and sharing what I was building. Explaining something in writing is the fastest way I know to find out whether you actually understand it. If I can't explain it clearly, I don't know it well enough yet.
What peer learning doesn't give you
It would be dishonest to pretend this model is perfect.
- No one tells you if your approach is idiomatic. A grader can say your code works. It can't say your code is good, or that there's a much cleaner way.
- Help is uneven. Who can help you depends on who's around and what they've already learned. Sometimes the answer is "nobody here knows this yet," and you're on your own.
- Gaps hide easily. If you can pass the grader without understanding something, it's easy to move on. You have to be disciplined about going back.
- Fundamentals can get skipped. Project-first learning means theory (data structures, networking, how databases work) can arrive late, or only when a project forces it. I closed those gaps by reading other people's code, contributing to open source, and writing about what I learn. None of it was assigned. All of it mattered.
Advice if you're about to start
If you're joining a program like this, here's what I'd tell you:
- Read the spec twice before you write a line. Most wasted hours come from solving the wrong problem.
- Ask for help, but ask well. Before asking, be able to say what you expected, what happened, and what you've already tried. That question usually answers itself halfway through.
- Help others even when you feel unqualified. Explaining a concept you've just learned is the best test of whether you understand it.
- Don't just pass the grader. After a project works, ask: could I rebuild this without looking? Do I know why each part is there?
- Build things for real people. Exercises teach syntax. Projects with users teach judgment.
- Document and publish as you go. Future you, and anyone else who's stuck on the same problem, will thank you.
Peer learning isn't the easy way. It's slower at the start, more frustrating, and less comforting than being taught. But it builds something lectures can't: the ability to walk into a problem you've never seen and figure it out.
That's the skill I took from the piscine to production, and it's the one I expect to keep using long after any specific language or framework has changed.
Top comments (0)