After working through a few small Python projects, something subtle began to change.
Not suddenly.
Not dramatically.
But noticeably.
For the first time, I wasn’t just typing code.
I was beginning to understand it.
From Guessing to Seeing
Before this point, most of what I did felt like guessing.
- Try something
- Run it
- Fix errors
- Repeat
Sometimes it worked.
Most times, I wasn’t sure why it worked.
But then, something shifted.
Patterns Started Appearing
I began to notice small patterns:
- Input comes in
- It gets stored
- Something happens to it
- Then it produces a result
This wasn’t theory anymore.
I could see it happening.
Code Became Predictable
That was the real turning point.
Instead of hoping the code would work…
I started expecting what it would do.
Even when I made mistakes, I could now trace:
“This is where it went wrong”
Understanding Over Memorization
I wasn’t memorizing syntax anymore.
I was thinking in steps:
- What do I want?
- What data do I need?
- What should happen to it?
That shift—from memorizing to thinking—changed everything.
The Role of Simple Projects
Looking back, it wasn’t complex projects that helped me reach this point.
It was the simple ones.
The Mad Libs project.
The small scripts.
The repeated practice.
They built something quietly:
confidence through clarity
A Different Kind of Progress
This stage didn’t feel like progress in the usual sense.
There were no big achievements.
No impressive outputs.
But internally, something important happened:
Things started connecting.
What I Learned From This Stage
- Understanding grows slowly, not suddenly
- Small projects are powerful
- Repetition builds clarity
- Logic is something you develop—not something you memorize
Where This Leads Next
Now, a new challenge begins.
Not writing code…
But understanding errors.
Because the next real skill is not getting it right the first time—
It’s knowing what to do when things go wrong.
Tech Journey — Season 1, Episode 10
Stage: Logic, Errors & the Terminal
Obi'sDeck 