DEV Community: Okello Odhiambo

Building Confidence Without Knowing What You’re Doing (A Beginner’s Honest Story)

Okello Odhiambo — Wed, 13 May 2026 11:49:07 +0000

Last week, I passed an audit I was fully prepared to fail.

Not “maybe fail.”
Not “slightly unsure.”

Fail.

The kind where you’re already planning how you’ll explain yourself when everything starts falling apart.

But somehow… I passed.

And to be honest? I wasn’t even sure I deserved to.

Welcome to learning without a map

I’m currently learning software development at Zone01 Kisumu, where everything is peer-to-peer. No teachers. Just apprentices trying to figure things out, reviewing each other’s work, and occasionally pretending we understand what’s going on.

For the past two months, my learning journey has looked less like a straight line… and more like a circle.

Learn.
Unlearn.
Get confused.
Repeat.

At some point you even start asking yourself:

“Am I actually learning… or just surviving?”

The moment things stopped making sense

One project that really humbled me was ascii-art-web.

The task sounded simple enough:
Build a Go server and connect it to a web interface.

Simple… until it wasn’t.

Because just when I was starting to understand Go—just starting—HTML showed up like:

“Surprise 🙂”

Suddenly I wasn’t just thinking about logic anymore.
Now it was structure, templates, rendering…

At that point I just stared at my screen like:

“Wuod gi nyithindo, what is actually going on here?”

I didn’t fully understand what I was building.

But I still submitted it.

Because… what else are you going to do?

The real fear isn’t failure

Every time I hit “submit,” there’s a small moment of regret.

Like maybe if I close my laptop fast enough, the audit won’t happen.

Because the fear isn’t really failing.

It’s sitting in front of someone while they go through your code and ask:

“Why did you do this?”

And your brain just goes:

“We listen, we don’t judge.”

If I’m being honest, I’m less afraid of failing…

and more afraid of being exposed as someone who doesn’t fully understand what they’re doing.

The audit that almost ended me (but didn’t)

Then came net-cat.

Server. Client. Connections. Ports. Communication.

Big words. Serious things.

I walked into that audit already defeated.

And the auditor?
Very thorough. The kind who doesn’t just follow the questions—they expand them.

At some point, they started asking things that weren’t even on the audit sheet.

I remember thinking:

“Ah. This is where my journey ends.”

But somehow… I passed.

Passing without confidence is confusing

You’d think passing would feel amazing.

But instead, I just sat there wondering:

“Wait… so what exactly just happened?”

Because in my head, I was still the same person who didn’t fully get it.

That’s when something small shifted.

Instead of celebrating, I started seeing audits differently:

“Maybe this is not just a test… maybe this is where I actually learn the thing I thought I learned.”

What “not learning” really feels like

Let me be real.

There are days it feels like I’ve learned absolutely nothing.

Two months in… and sometimes I still feel like it’s day one.

You’re in a group discussion.
People are throwing around terms.
Debating solutions.

And you’re just there like:

“Yes… yes… I also agree… with… everything.”

Meanwhile, inside:

“Koro an gi wach matin… I am completely lost.”

And then the comparisons start.

“They understand this faster.”
“They explain things better.”
“They belong here.”

And you?

You’re not so sure.

But something is happening (quietly)

Even with all that confusion, there are small things that have changed.

I can push projects without struggling.
I understand my way around VS Code.
The terminal no longer feels like a place where mistakes go to multiply.

These aren’t big, dramatic wins.

But they matter.

Because a few weeks ago?
These same things felt impossible.

Maybe confidence isn’t the starting point

I used to think confidence comes first.

That one day I’d wake up and feel ready.

Now I’m starting to think that was a lie.

Because what’s actually happening is this:

You submit while unsure.
You get audited while nervous.
You pass… sometimes by surprise.

And slowly—very quietly—something starts to build.

Not loud confidence.
Not “I know everything now.”

Just a small, steady realization:

“I may not understand everything… but I’m not the same person I was when I started.”

So what does confidence mean to me right now?

It’s not clarity.
It’s not mastery.
It’s definitely not feeling ready.

Right now, confidence is much simpler than that.

It’s this:

Showing up. Submitting anyway. And refusing to quit.

Even when I feel lost.
Even when I can’t explain my own code properly.
Even when I’m sure I’m about to fail.

Because somehow… despite all that…

I’m still here.

Still learning.
Still confused.
Still moving forward.

And for now?

That’s enough.

After attending the piscine at Zone01 Kisumu twice (almost 60 days), I realized it’s less about coding and more about resilience. I wrote a story about the experience, the confusion, the checkpoints, the audits, and the lessons that come with them.

Okello Odhiambo — Thu, 12 Mar 2026 07:51:49 +0000

Okello Odhiambo

Mar 12

Surviving the Piscine at Zone01 Kisumu - 60 Days of Being Humbled by Code

#beginners #codenewbie #devjournal #learning

Comments

4 min read

Surviving the Piscine at Zone01 Kisumu - 60 Days of Being Humbled by Code

Okello Odhiambo — Thu, 12 Mar 2026 07:49:53 +0000

I attended the piscine twice.

That’s nearly 60 days of intense coding, confusion, debugging, and occasional existential crises in front of a computer.

And when I say intense, I mean the kind where you stare at your screen so long that even the keyboard starts judging you.

When I first joined the piscine at Zone01 Kisumu, I had zero tech background. Not “a little HTML” zero. I mean completely zero.

The closest I had come to programming was dialing USSD codes like *544# to check bundles.

Yet somehow, I had decided to learn software engineering.

Looking back, that decision would lead to one of the most challenging and transformative experiences of my life.

Day One: A Very Fast Reality Check

The first day of the piscine is where reality politely introduces itself.

You sit down, open your computer, log into the system, and look around the room.

Some people immediately start typing like they’ve been preparing for this moment since childhood.

Within the first hour, something becomes obvious.

Not everyone is starting from the same place.

Some participants come from computer science backgrounds or have already spent time coding. They move through exercises quickly and confidently.

Meanwhile, you’re still reading the instructions.

At Zone01, finishing an exercise is often called “BIM-ing” it.

So imagine hearing someone say:

“I’ve already BIM’d that exercise.”

And you haven’t even figured out what the instructions mean yet.

That’s the moment when your brain quietly asks:

“Are we sure we belong here?”

But stubbornness is powerful.

So you stay.

The Weekly Cycle: Hope vs Reality

The piscine has a rhythm that every participant eventually recognizes.

During the week, you start gaining confidence.

You solve a few exercises.
You fix a bug.
Maybe you even help someone else.

For a moment, you feel like you're finally getting the hang of things.

Then comes the checkpoint.

The 4-Hour Checkpoint Experience

The checkpoint is a timed exam designed to test your understanding.

And it’s also where confidence goes to die.

Everyone starts at the same time.

You open the exam.

You read the first question.

Then you stare at the screen.

Five minutes pass.

Ten minutes pass.

Meanwhile, the person next to you is already on Level 3.

At this point, many people develop the same coping mechanism: typing random commands just so it looks like you're working.

Your screen is empty.

But your keyboard is extremely busy.

Checkpoints have a way of reminding everyone that learning to code is not a straight line.

Group Projects: When Confidence Meets the Audit

Group work is one of the most interesting parts of the piscine.

People gather around one screen discussing solutions, sharing ideas, and proposing approaches.

Someone says:

“Let’s use recursion.”

Everyone nods.

Even the people who have absolutely no idea what recursion is.

For a moment, the team feels unstoppable.

Then comes audit time.

An auditor reviews your project and asks a simple question:

“Can you explain this part of the code?”

If you truly understand it, no problem.

If you don’t, the explanation suddenly becomes very creative.

You start sentences like:

“Basically what happens here is… you see… the function…”

And somehow the explanation never reaches a conclusion.

It’s a humbling moment that most piscine participants remember very clearly.

The AI Temptation

Let’s talk about something modern developers understand very well.

The temptation to use AI.

When you're stuck on a problem for hours, the thought appears:

“Maybe I should just get a small hint.”

Suddenly, perfect code appears.

Clean. Elegant. Working.

You submit it feeling brilliant.

Until someone asks:

“Can you explain what this line does?”

That’s when the real test begins.

The piscine doesn’t just evaluate whether your code works.

It checks whether you understand what you wrote.

And that’s a lesson many developers learn the hard way.

What the Piscine Actually Teaches

At first glance, the piscine looks like a coding bootcamp.

But after weeks of struggling through exercises, something becomes clear.

The real lesson isn’t just programming.

It’s resilience.

You learn how to deal with frustration.

You learn that confusion is part of the learning process.

And you learn that everyone—no matter how experienced—gets stuck sometimes.

A Luo proverb says:

“Piny owacho gi chike, to ng’ato nyalo puonjore.”
The world has its rules, but a person can learn them.

The piscine forces you to accept that progress happens slowly, one concept at a time.

Why I Came Back the Second Time

After my first attempt, I had a choice.

Walk away.

Or try again.

I came back.

Not because coding suddenly became easy.

But because something had changed.

I understood that the goal wasn’t to be the fastest person in the room.

The goal was simply to keep improving.

One exercise.

One concept.

One bug at a time.

Final Thoughts

Looking back at nearly 60 days in the piscine, one thing stands out.

The experience tests more than your technical ability.

It tests your patience.
Your humility.
Your willingness to keep learning.

Some days your screen is blank.

Some days the person next to you is already on Level 3.

But if you stay long enough, something interesting happens.

You start solving problems that once felt impossible.

And slowly, line by line, the code begins to make sense.

💬 If you’ve ever gone through a coding bootcamp, a 42/Zone01 piscine, or any intense learning experience, I’d love to hear your story.

What was the moment that humbled you the most?

Because if there’s one thing the piscine proves, it’s this:

Every developer has that moment.