From Apprentice to Senior Engineer: 10 Years Later

Over ten years ago I started a software engineering apprenticeship and began documenting what I was learning on this blog. At the time, I was focused on understanding the fundamentals of programming, shipping my first real projects, and figuring out how the industry worked.

A decade later, after working as a software engineer and building production systems in the real world, I wanted to reflect on that journey. That includes what I’ve learned, what surprised me, and how the field has changed, especially with the rise of AI-assisted development.

I re-read some of the posts from that time and was reminded how special the apprenticeship period was. The software market was hot, Ruby on Rails was everywhere, CoffeeScript was a thing, and we spent a lot of time thinking about code quality and testing. Much of the focus was on learning how to write clean, maintainable code and understanding the tools we were using.

Today the landscape looks very different. AI tools can generate large portions of code from a prompt, and productivity expectations for developers continue to increase. Instead of writing every line ourselves, we are often reviewing, guiding, and refining code produced by tools.

In some ways this shift makes sense. Over time the surface area of software engineering has grown enormously. Developers are expected to understand frontend frameworks, backend systems, infrastructure, databases, and deployment pipelines. AI-assisted tools are becoming part of how we manage that complexity.

But one thing that has not changed over the past decade is the importance of fundamentals. The most valuable skills I developed during my apprenticeship were not tied to a particular language or framework. They were learning how to debug systems, how to reason about problems, and how to build software that works reliably in production.

AI can generate code, but it still relies on engineers who understand the systems that code runs in. Someone still needs to decide what should be built, how it should behave, and how the pieces fit together. In many ways, this makes strong engineering fundamentals even more important than before.

Looking back after ten years, the tools have changed dramatically, but the core of software engineering has stayed the same: understanding problems, designing systems, and building software that people can depend on.