The tech industry is going through massive upheaval. Roles are disappearing, engineers are being laid off by the thousands. Companies are discovering they no longer have a business model, and the global economy is desperately trying to both absorb the impact and understand the implications of what’s going on.
This was the industry 25 years ago, back when I was first getting started in tech around the time of the dotcom crash.
Less than 10 years later, it was happening again: the iPhone had launched, so we’d figured out how to make mobile sites. Then the App Store launched, so we had to figure out how to build apps, instead. The development landscape was changing faster than any one person could keep up: how could you possibly be a good developer now?
Good Development Then
Even back then, writing the cleverest, or neatest, or fastest code was only a part of being a good developer. The industry was rapidly iterating on development practices and developer tooling: you didn’t write code in notepad.exe, you used a code editor, or perhaps even an IDE. You didn’t copy files into production, you used version control. These tools had existed in the corporate world for years, of course, but open source alternatives were making them available to anyone who wanted to be a a developer. They improved, too: adding auto-complete, templates, and integrating test environments for rapid iteration.
The democratisation continued, too: from the rise of Stack Overflow as a source of code snippets that you could easily re-use, to package managers made it even easier to re-use code on an industrial scale, through to the proliferation of through to the proliferation of transpilers and build tools. It got to a point where it where didn’t even really matter what language you wrote your code in. As long as you had the right build tool for it, it could run anywhere.
The history of our industry has been defined by a never-ending drive to increase the leverage of every keystroke, but it’s always been at something of a measured pace. But what happens when a giant leap occurs?
Good Development Now
A couple of year couple of years ago, LLM-based development tools were little more than slightly smarter (but infinitely slower) autocomplete, and it looked like they’d stalled there. A year ago, agentic development tools came along, and it was starting to look like there might actually be something useful here, though they were far too prone to making unacceptable mistakes. More recently, the current generation of agentic tools emerged, and we find ourselves able to generate production-ready code with minimal developer intervention.
So if we no longer need to write code, what becomes of the software developer?
Hint: you’re still coding, just at a a different abstraction level. Your job has always been to take a problem, and solve it with software. The exact method you used to produce that software has never been prescribed, you use the right tool for the job.
Right now, the tools are pretty messy. Concepts are changing week to week, state of the art last quarter is today’s legacy. I’m reminded of when the mobile web was first emerging, the horrible CSS hacks we’d previously reserved for Internet Explorer now had to be applied to make things work in mobile browsers, too. When we first started building mobile websites, they were entirely different code bases, but we slowly figured out how to make the same code work everywhere. The change came as a hurricane, the tooling followed later, cleaning up the mess.
HOWTO: Be a Good Developer
Once again, the tech industry is in a state of upheaval. The good news is, the exact same mindset that made you a good developer previously is what will keep you being a good developer today. Some of the bad habits we picked up along the way might have to go, though.
You can’t just look at the code in front of you any longer. Closing out your 5 tickets for the sprint won’t help you use agentic tools: it’s impossible to stick to your little corner of the machine if the tooling is suddenly able to reach everywhere. You need to learn how the entire system works: not necessarily so you can create code that spaghetti-fies its way through the system, but so you can know when it’s right to make changes elsewhere.
Think about the tools that always made it easiest for you to create good code. From the simplest code formatter to the most comprehensive test suite: these tools gave you fast, reliable, timely, and actionable feedback that you can act upon. The exact same tooling is what will give you the best output from agentic development tools today.
The same is true of process. Well-written, unambiguous requirements produced in a collaborative, iterative fashion creates clear guidelines for what needs to be built creates clear guidelines for what needs to be built. Useful code reviews that helped you learn more about the system you’re building inside of ensures you’ve built it the right way ensures you’ve built it the right way. Comprehensive real world testing with clear, actionable feedback checks that you’ve solved the problem.
Creating great software was never about being the most brilliant coder, it’s always been about creating an environment where great software comes naturally: that’s as true today as it was yesterday.
Raising the Floor
Information sharing has always been a key driver in pushing the software engineering practices forward. From the global Open Source movement right down to how your team works together, sharing compounds exponentially. Where one developer with a well-configured CI pipeline raises the quality of their own output, an entire team on the same pipeline raises the floor for everyone.
Start with shared guardrails. If you’ve set up a test coverage ratchet or a linter config that’s been improving your own work, propose it to the team. Champion it in a PR, explain why it caught something it would otherwise have missed, and make it part of your shared CI standard. Remember that you’re not trying to impose process, you’re aiming to help the team’s agents work to the same standard as yours. When everyone’s feedback loop is well-configured, the whole team moves faster with less rework.
Work on shared review culture. In code reviews, start asking questions like “what guardrails did you put in place?” and “how did you verify the agent’s output?” You’re not looking for gotchas: be genuinely curious, and find the patterns that can help evolve the tooling everyone uses.
Talk about what “done” looks like. Define acceptance criteria and type checks that everyone agrees on, so that agents across the team are working to the same standard, instead of individual interpretations of what’s good enough. Always remember that you’re not looking to create bureaucracy, you’re defining alignment: when developers and agents share a common north star, when you’re pulling in the same direction, the job becomes easier and you can move onto new and bigger opportunities.
Choose Your Own Adventure
There are big changes happening in the industry right now, the practice of software engineering is evolving to encompass agentic development tools. Your choice remains, however: just as you could always choose whether you prefer to use a full IDE, a code editor, or notepad.exe. Now you can choose to use the frontier LLMs, you can choose self-hosted LLMs. You can use the myriad of available harnesses, you can write something that works just for you. Previous generations of software engineering practices didn’t disappear because something new came out, they adapted to work with the best bits, and kept the rest optional.
This is a time of exciting and challenging opportunities: just as has happened before, we’re defining what the practice looks like for the coming decades. Start with something small, perhaps have a chat with your lead about what their view is, I promise they’re trying to figure out what it all means just as much as you are! Now is a good time to take care of technical debt: agents work best in a consistent environment, so cleaning up some of those old abstractions and interfaces will help increase the momentum. Keep learning: my years in this industry has taught me that nothing ever stays the same, there’s only one way to continue improving your craft.
Feed your curiosity.
Leave a Reply