One Week Into Rebuilding My Tech Stack

Amir Ali — Fri, 29 May 2026 12:06:07 +0000

It’s been a week since my first post about rebuilding my tech stack, so here’s my first update.

Progress has been slow, but steady. And honestly, I’m fine with that. Slow progress is still progress.

One thing I discovered very quickly is that I learn far better from books than from online courses. I don’t fully understand why yet, but online courses have always felt difficult for me to stay focused on. My brain just drifts away after a while. Books, however, keep me engaged. They force me to slow down, read carefully, and actually think about what I’m learning instead of passively consuming information.

It honestly makes me curious whether there’s actual research comparing long-term retention between books and video-based learning. Because at least for me, books feel significantly more effective.

This week, I started relearning C using The C Programming Language by Brian W. Kernighan and Dennis Ritchie.

Even though I still remember most of the basics from Chapter 1 from my university days, I’m going through everything carefully anyway. No shortcuts this time.

One important thing I changed is how I use AI.

I originally said I wanted to stop relying on it, but I realized something important: when learning alone, sometimes you genuinely don’t know whether you’re making mistakes. Normally, an experienced engineer or teacher would point those out.

So instead of asking AI to solve problems for me, I now use it more like a reviewer or mentor. I write the code myself first, then ask for feedback or guidance only when I get stuck. The difference feels huge already. I’m thinking through problems again instead of outsourcing the thinking process entirely.

So far, I’ve completed the character counting and line counting exercises. Next up are word counting and arrays, which I’m actually looking forward to.

On the game development side, I chose Godot 4 Game Development Projects by Chris Bradfield as my main learning resource.

Before this, I had watched videos about the Godot engine from Brackeys and GDQuest YouTube channel. The videos were helpful, but my learning felt inconsistent and scattered.

The book has been a completely different experience.

Right now, I’m still in Chapter 1, building a very simple game with basic movement and input systems. Technically, I probably could have built it without the book, but that’s not really the point. The book explains small design decisions and implementation details I would never have thought about on my own.

So I’m taking it slowly and reading everything line by line.

This first week wasn’t explosive or dramatic. No “10x productivity.” No overnight transformation.

Just consistent effort.

And honestly, that already feels like a huge step forward.

I’ll keep posting updates as I continue this journey.

Peace.

Yamato out.

Rebuilding My Engineering Mind

Amir Ali — Thu, 21 May 2026 19:28:41 +0000

A 5-Year Roadmap Back to Strong Fundamentals

In 2018, I started my bachelor’s degree in Computer Engineering with almost no real passion for it.

At the time, I was just there to get a degree.

I attended classes, did assignments, passed exams, and moved forward because that was the expected path. Programming was simply another subject to survive. But somewhere along the way, something changed. Little by little, I started enjoying the process of building things. Not just writing code, but understanding systems. Understanding why things break. Understanding why some designs scale while others collapse like wet cardboard castles under production traffic.

By 2024, I landed an internship as a junior Angular developer. That experience changed a lot for me. For the first time, programming stopped feeling academic and started feeling alive. Real projects. Real problems. Real consequences. I finally felt connected to the craft.

Then came the era of LLMs.

Like many people, I started using them to speed things up. At first, it was harmless. Small questions. Boilerplate. Debugging assistance. Then slowly, without realizing it, I became what the internet calls a “vibe coder.”

I stopped solving problems properly.

Instead of thinking through implementation details, I started outsourcing the thinking itself. Homework became prompts. Bugs became prompts. Entire features became prompts. And because the results worked most of the time, I convinced myself I was still learning.

But I wasn’t.

After finishing my bachelor’s degree, I got accepted into a Cybersecurity master’s program. That experience gave me a completely different perspective on software engineering. I started seeing systems from the security side: trust boundaries, attack surfaces, infrastructure, protocols, reliability, operational risk. Software stopped being “just code.” It became architecture.

The program was difficult enough that I had to leave my internship and fully focus on studying.

And somewhere during all of this, I lost something important.

One day, I decided to write a simple C++ program I had written before. Nothing complicated. Just basic logic.

My mind went blank.

Not “I forgot a syntax detail” blank.

I mean genuinely blank.

I realized I had become dependent on AI to the point where I had weakened my own ability to think through code independently. That moment hit me harder than any failed exam ever could. It felt like discovering that the engine inside the machine had quietly rusted while the dashboard lights still looked fine.

That was the wake-up call.

So I made a decision:

I’m going back to fundamentals. Properly this time.

Not for grades.
Not for tutorials.
Not for productivity dopamine.
For mastery.

I built a long-term roadmap for myself. A 4 to 5 year journey focused on rebuilding my foundations from the ground up and growing into the kind of engineer I actually want to become.

The goal is not speed.

The goal is depth.

The Roadmap

Phase 1: C and Linux Fundamentals

This is where I start rebuilding my low-level understanding of systems. Memory, processes, pointers, filesystems, shells, tooling. No abstractions to hide behind.

Phase 2: Python, Bash, and Operating Systems

Automation, scripting, internals, process management, scheduling, concurrency, permissions. Learning how machines actually behave beneath the UI layer.

Phase 3: Networks and the Internet

Protocols, routing, DNS, TCP/IP, HTTP, sockets, infrastructure communication. The invisible highways everything depends on.

Phase 4: Docker and Kubernetes

Containers, orchestration, deployment models, scalability, infrastructure management. Modern software engineering’s giant mechanical spiderweb.

Phase 5: CI/CD and Security

Pipelines, DevSecOps practices, hardening, monitoring, secrets management, secure deployment workflows.

Phase 6: Rust

Because I want to learn systems programming with modern safety guarantees while still staying close to the metal.

Phase 7: Databases and Distributed Systems

Replication, consistency, CAP theorem, transactions, fault tolerance, system design. This is where software starts becoming architecture.

Phase 8: C++

Returning to the language that exposed my weaknesses in the first place. This time with real understanding behind it.

Phase 9: Elixir and Haskell

Not because they are trendy, but because they force different ways of thinking. Concurrency models. Functional paradigms. Strong abstractions. Mental expansion through controlled suffering.

Alongside all of this, I want to keep following the thing that made me love engineering in the first place:

Game development.

At least two days every week will be reserved for building games, experimenting, and creating weird little worlds that may never ship but will keep the spark alive. I do not want this journey to become pure optimization and infrastructure grayness. A machine without creativity eventually becomes a factory.

This entire roadmap is going to take years.

And honestly, that’s fine.

For the first time in a long while, I’m not chasing shortcuts anymore.

I’m chasing competence.

My short-term goal is to land a DevOps role. My long-term goal is to become a system architect capable of designing reliable, scalable, and secure systems from the ground up.

And to keep myself accountable, I’m going to document the journey publicly through weekly posts. Progress, failures, discoveries, frustrations, all of it.

Maybe this series will help someone else who feels stuck in the same cycle.

Maybe it will simply become a record of one engineer rebuilding his foundations one layer at a time.

Either way, this is the start of something new.

The terminal is open.
The cursor is blinking.
And this time, I actually want to understand what I’m typing

DEV Community: Amir Ali