The Early Internet Years
When I first started getting interested in web development it was the late 90s. I was definitely too young to properly understand what the internet would eventually become, but I was fascinated by it anyway.
Back then my first real exposure to anything digitally creative wasn't programming at all. It was making forum signatures and little avatars for gaming forums, which were huge before social media and Discord swallowed basically all online communities.
Before that I'd mostly been making custom maps for Delta Force 2, which in hindsight was probably another early sign that I liked building systems and spaces more than simply consuming them.
I remember seeing other people's signatures and thinking they looked impossibly cool, glowing text, abstract shapes, terrible lens flares everywhere. Eventually I got hold of Adobe Photoshop 5.5 and started teaching myself through random internet tutorials.
At the time it didn't feel like engineering.
But looking back, those were probably the foundational skills that shaped most of my career later on. Learning how to learn online, following curiosity hard enough to brute-force understanding into existence, experimenting endlessly because nobody was standing over your shoulder telling you the "correct" way to do things.
That idea feels even more true now than it did then. If somebody is interested enough in something and willing to spend time with it, the internet makes an absurd amount of knowledge accessible.
Tables, FrontPage And Absolute Chaos
Eventually Photoshop led into UI concepts and mock web pages.
Then came Microsoft FrontPage and later Dreamweaver, which felt incredibly advanced at the time. Most of what I was building relied heavily on sliced Photoshop exports, giant HTML tables and bits of manually edited code stitched together inside visual editors.
Objectively, a lot of it was awful.
But it was working awful, which is honestly how most engineers learn in the beginning.
I wasn't building elegant systems yet, I was building strange little constructions held together with trial and error and curiosity. Like learning carpentry by nailing random bits of wood together until something vaguely resembles a chair.
You learn a lot doing that.
The Light Switch Moment
One of the biggest turning points for me was meeting my first real-life friend who actually understood web development properly.
Suddenly the world shifted from generated tables into div layouts, floats, CSS positioning and flexible page structures. Looking back now, float layouts were slightly cursed, but at the time they felt revolutionary.
That was also around the point where I first started learning PHP.
Honestly, PHP felt like wizardry back then.
The moment I realised websites could do things instead of just displaying static pages genuinely rewired my brain a bit. Forms processing, sessions, dynamic content, database-driven systems, suddenly the web stopped being digital posters and started becoming software.
As far as I was concerned at the time, if I could properly learn PHP then theoretically I could build almost anything.
Which was both true and wildly naïve at the same time.
Drifting For A While
By the early 2000s I was leaving school and moving toward college.
I was doing IT-related courses and graphic design work, but despite that I didn't really progress much professionally for several years afterwards. I'd entered that awkward early-adult phase where you're trying to work out where you fit in the world while mostly just trying to survive financially.
Without commercial experience or serious projects behind me, getting into software engineering felt increasingly unrealistic.
At one point I honestly started convincing myself I'd probably missed the opportunity entirely.
Which sounds dramatic now, but I think a lot of people in technical careers quietly hit that wall at some stage.
The Call Centre Era
A few years later I was working temp jobs, including a call centre role that I absolutely hated.
Not even in a dramatic way, it just slowly drained the life out of me. Every day felt grey and repetitive. One lunchtime I remember sitting there thinking, very calmly actually, "I can't keep doing this".
So I quit.
No backup plan. No new role lined up. No real idea what happened next.
Which in hindsight was either brave or catastrophically irresponsible depending on perspective.
Then somehow, through what felt like pure luck at the time, a small web company working with accountants was hiring for a junior office admin role.
I applied because it felt adjacent enough to technology to maybe become something more.
Honestly, I was terrible at admin work.
I get bored very quickly with repetitive organisational tasks, and once boredom kicks in my focus tends to evaporate entirely (ADHD and spreadsheets are not natural allies).
Thankfully they realised fairly quickly that I probably had more future as a developer than an administrator.
That changed everything.
Trial By Fire
From that point onwards my life became almost entirely about learning fast enough to survive in a real engineering role.
And honestly, learning on the job is brutal sometimes.
There's no clean tutorial path. No carefully structured progression. You just get dropped into real systems with real deadlines and slowly absorb information through repeated exposure and mild panic.
But weirdly, that environment suited me.
Pressure has always been a strange motivator for me. If something genuinely matters, my brain suddenly wakes up properly.
At the time the stack was still very hand-built compared to modern development. Lots of template engines, manual workflows and direct implementation.
I was using Dreamweaver, Fireworks, Photoshop, experimenting with Flash and ActionScript in my spare time, while simultaneously diving deeper into PHP.
PHP 4 was still dominant back then, though people had started talking more seriously about PHP 5 and object-oriented programming.
That rabbit hole alone probably consumed years of my life.
Learning Before YouTube Took Over
One thing that feels strange looking back is how different learning resources were.
YouTube existed, but it wasn't the giant educational platform it later became. Most technical learning still came from written tutorials, forum posts, PDFs, IRC chats or private course repositories.
You had to dig for knowledge more.
I remember when platforms like Treehouse started appearing years later and thinking new developers had absolutely no idea how good they had it compared to endlessly reading walls of PHP tutorials on slightly broken websites at 2am.
Though to be fair, there was something oddly satisfying about that era too. The internet still felt a bit scrappy and exploratory.
The Industry Started Accelerating
The speed at which software engineering modernised after that was honestly pretty staggering.
It genuinely doesn't feel that long ago that transpiling ES6 into ES5 became normal practice. Suddenly engineers could use newer JavaScript features without worrying constantly about browser compatibility exploding underneath them.
That shift alone removed huge amounts of friction.
Then tools like Kite started appearing, early AI-assisted coding before most people really framed it that way. Documentation hints, autocomplete, debugging help, contextual suggestions.
Primitive compared to now, but you could already see the direction things were heading.
At the time I remember waiting ages for proper JavaScript support in Kite and eventually never really using it myself, though several engineers I knew absolutely loved it.
In hindsight it feels like the very beginning of what eventually became today's LLM tooling.
The LLM Shift
When generative coding models first started appearing properly, there was a lot of scepticism around them.
Fairly justified scepticism honestly.
The outputs were inconsistent, hallucinations were everywhere, and sometimes the generated code was so confidently wrong it became almost comedic.
Using AI-generated code in commercial environments was often looked down upon as lazy or reckless. Nobody really knew whether the tools would become genuinely useful or remain glorified autocomplete forever.
Then something shifted.
Models like GPT-4, Claude and several others suddenly crossed a threshold where the outputs became genuinely usable in the hands of experienced engineers.
That distinction matters quite a lot.
The models themselves are not magically replacing engineers. What they are doing is massively increasing the leverage of engineers who already understand architecture, debugging, trade-offs and system design.
I used to be considered a fairly fast coder.
But over the years I also became increasingly burnt out from repeatedly rebuilding variations of the same systems over and over again. Different company, different project, slightly different implementation, but fundamentally the same scaffolding repeated endlessly.
Auth systems. CRUD interfaces. Dashboards. API wiring. Validation layers. Deployment configs.
You spend years typing the same shapes into slightly different boxes.
The AI tooling finally started removing some of that cognitive load from my day-to-day work. Instead of spending all my energy manually constructing repetitive implementation details, I could spend more time thinking about architecture, reviewing quality, helping colleagues and trying not to contribute additional tech debt every single sprint because deadlines were crushing everything.
Honestly, it felt wrong at first.
Now I genuinely couldn't imagine going backwards.
Engineers As Orchestrators
I think one of the biggest shifts happening right now is that engineers are gradually becoming orchestrators more than pure implementers.
Every experienced engineer now effectively has access to several junior-level implementation engines simultaneously.
The skill is increasingly in directing the models properly, validating output, maintaining coherence across a codebase and understanding when the AI is confidently walking you straight into a disaster.
Which it absolutely still does sometimes.
Your value increasingly comes from judgement.
Knowing what to build.
Knowing why to build it.
Knowing what trade-offs are acceptable.
Knowing when complexity is becoming dangerous.
The implementation speed is incredible, but bad architecture also arrives faster now. Technical debt compounds faster too. AI accelerates mistakes just as efficiently as it accelerates productivity.
So the engineering part never disappeared really. The difficult parts just moved further up the abstraction ladder.
The Future Feels Strange Again
It's honestly hard to predict where all this ends up in one year, five years, or beyond.
The coding models are obviously going to continue improving. We're probably not that far away from systems capable of handling much larger sections of engineering workflows semi-autonomously.
Specification-driven development becoming normal no longer sounds unrealistic to me.
You can already feel the direction of travel.
For me personally though, I'm mostly interested in using AI where it genuinely reduces friction, cognitive load or repetitive work.
I want to spend more time thinking creatively, learning new things, designing better systems and generally enjoying life a bit more instead of drowning in implementation detail forever.
Which honestly feels like a fairly healthy direction for the industry overall.