I started learning how to program at a time when content wasn't nearly as accessible as it is today.
And every time I say this, I feel like a boomer reminiscing about something oddly specific, like old football sticker collections.
I grew up when Wikipedia wasn't considered a reliable source, before fake news was even a concept, and before "just Google it" became the universal answer to everything.
Throughout my journey, not only as a developer but as someone trying to learn anything at all, I had to learn how to learn.
Videos, books, journals, blogs, forums. Whatever I could get my hands on.
Not having much money to invest in education forced me to be extremely deliberate. Every course, every book, every decision about where to spend time and energy actually mattered.
Looking back, this constraint shaped more than my learning path. It shaped my mindset.
It's one of the reasons becoming self-taught wasn't really a choice. It was simply the only viable strategy, which in hindsight made perfect sense when I eventually decided to become a developer.
During my first months learning to code, I remember struggling to understand something as basic as a for loop.
No peers, no networking, no one nearby working in what I then called "computer science". Just confusion and persistence.
The solution? Practice. Relentless practice. And communities.
I joined as many communities as I could. Forums, groups, discussions. Anywhere people were talking about software.
What surprised me wasn't the technical difficulty. It was the way people talked about software.
Everything sounded impossibly complex. As if becoming a programmer required at least five years of preparation just to maybe qualify as a junior, or to be worthy of an internship.
I don't want to focus on how wrong that perception was. What interests me more is how that experience connects to where we are today.
Because then came the pandemic. And the pandemic didn't just change remote work. It permanently reshaped how programming, and tech jobs as a whole, are perceived, accessed, and practiced.
When the pandemic hit, something unusual happened to our industry.
Software engineers, once treated as scarce, almost mythical creatures, suddenly became abundant.
Companies were hiring aggressively, remote work erased borders, and job hopping became normalized, sometimes even encouraged.
For the first time, having “as many engineers as possible” felt less like a competitive advantage and more like stockpiling a commodity.
But alongside this boom came something else: noise.
Even for me, someone who constantly felt like an impostor inside this whole system, it became difficult to ignore a strange pattern: people trying very hard to impress, while unintentionally showcasing the gaps in their understanding.
Confidence was everywhere. Depth… not always. And this wasn't about judging individuals. It was about recognizing a structural shift: when barriers drop quickly, access expands faster than mastery.
My response wasn't particularly elegant, but it was instinctive: invest as much as I could. Formal education, bootcamps, hundreds of courses, endless videos, more books than I could realistically finish.
I wasn't chasing certificates. I was chasing the hard stuff: the theory, the fundamentals, the concepts I had previously skipped, missed, or simply didn't have access to. Sometimes because of circumstance, sometimes because survival came first.
Growing up in the suburbs teaches you a very pragmatic lesson: learning is important, but paying bills is urgent.
At one point, dropping out wasn't a philosophical decision about academia versus the real world. It was the only way to keep working, to keep moving, to keep building a career under less-than-ideal conditions.
So I kept studying in fragments, piece by piece.
Because deep down, I had already sensed something that would later become obvious: the industry was changing. Again.
When the pandemic finally began to fade, something else appeared at the end of the tunnel: autocompletion on steroids.
First, the uncanny feeling of Copilot finishing your thoughts. Then, what felt like the full-blown LLM armageddon.
Suddenly, building things became… different.
With a strong foundation, it became possible to construct almost anything at a speed that previously felt unrealistic.
The power dynamic shifted. A specialist was no longer limited by memorization or familiarity. Interfaces, examples, patterns, edge cases. Everything was now instantly accessible.
What once required a week or even a month of careful assessment to understand a new library collapsed into hours. Sometimes minutes.
The entire industry seemed to move one step up the abstraction ladder.
Which raises an obvious question: this must be good for our field, right? And in many ways, it genuinely was.
For the first time, many of us witnessed something almost surreal: management teams watching backlogs being delivered on time. Predictability improved, output increased, friction decreased. At least on the surface. Because underneath this acceleration, something more subtle was happening. Something we're only beginning to understand.
Let's do a time skip. From 2022 to the beginning of 2026.
That period is strangely difficult to explain because the change didn't happen as a single disruption. It happened as a constant drift.
We came from a place where AI was mostly treated as a joke. A flashy feature, a marketing gimmick, something heavily hyped by companies. Everything felt blurry. Then every six months, a new tool appeared.
But the shift wasn't purely technological. Laws began adapting, regulations emerged, conversations moved beyond engineering circles. AI stopped being a niche curiosity. It became infrastructure.
Meanwhile, something else quietly changed. The jokes about replacing developers with agents stopped sounding like jokes. Meetings that once debated whether AI should be allowed became meetings where developers were encouraged, sometimes pressured, to use AI tools. The narrative flipped almost overnight.
And this is where "vibe coding" stopped being a meme and became a working model. Like many things in our industry, the term itself started as a joke. But then the environment changed. Tokens per second scaled, AI embedded itself into nearly every IDE. Typing speed, once treated as a badge of efficiency, began to lose relevance. Because now, an AI could build and wire a CRUD interface in less than a minute. The bottleneck was no longer writing. It became something else entirely.
if writing code is no longer scarce, what is?
You can no longer treat code as something expensive. That mindset made sense when writing software was the bottleneck. It doesn't anymore. When raw code production stops being scarce, engineering discipline stops being optional. You can't justify skipping tests anymore, you can't excuse fragile architecture, you can't hide behind duplicated logic. Because the traditional trade-off is gone. Tests are no longer expensive, refactoring is no longer painful. The real bottleneck is no longer writing. It's thinking. Decision-making, system design, judgment. In a world where generating code is cheap, the only sustainable advantage is doing actual software engineering.
vibe coding without engineering collapses at scale
Vibe coding works. Until it doesn't. And where it breaks is predictable: scale. Generating code is not the same thing as shaping systems. Without constraints, without structure, speed amplifies chaos. Which means your role subtly changes. You're no longer just writing code. You're guiding the machine that writes the code. Specifications become leverage, architecture becomes your compass. You're not just a developer anymore. You're an AI manager, a system designer, a decision-maker. Not all tasks are parallelizable. Uncontrolled acceleration is not productivity. It's entropy.
At this point, you may find yourself coding less and thinking more. Perfectionism can become procrastination. But there is a strange upside. For the first time, having too many options no longer needs to be paralyzing. If you have enough tokens, you can test them. Ideas are no longer constrained by implementation cost. Which raises a provocative thought: maybe this is the best moment in history to be a software engineer. But this transition can feel difficult if your identity is tightly coupled to being "just a developer". Because the industry is subtly redefining what creation actually means. And leverage now belongs to those who can think clearly, design deliberately, and guide complexity. Regardless of who or what writes the code.