Like a lot of people in software development, I've been thinking about what it means to work in this field now that LLMs are part of it. I managed teams of engineers for a long time and worked as a developer before that. Around 2015, I moved away from active coding and became more involved in architecture decisions, team structure, and project management. Because I was already no longer coding every day, I didn't feel like I was losing something when AI started writing the code. For me, it had almost the opposite effect. Instead of asking a team to fix something or build a feature, I could do it myself with AI, using the knowledge I had accumulated over 23 years.
Over the past two years, we started looking more closely at what was happening with LLMs, seeing changes and wondering where they would lead. I remember conversations with developers when our CEO at the time was experimenting with Devin. They wondered whether they would be replaced, which seemed unlikely then. By late 2026, we're in a different place. I'm seeing companies reduce their staff and people rebuild entire applications using AI, sometimes in a fraction of the time and with one person doing work that previously involved a team, quarterly planning, sprints, and spikes to explore new technology. The world is changing around us, and I feel it's becoming easier to lose sight of what we should do or where we fit.
When keeping up becomes part of the job
For years, our companies and our field pushed us to keep learning. We read blogs and news sites, followed training, read books, or listened to them. Continuous learning became part of how we worked, but so did the pressure we put on ourselves to stay current. We want to perform well at work, understand the latest technology or framework, and know the patterns people are talking about. As experienced engineers, I think we also feel a need to explain these things and help more junior developers understand them.
Those learning habits seemed to help when LLMs first became part of our work. But as the pace increased, the amount we felt we needed to know increased with it. New terms, tools, and ways of working appeared every week, and the pace we were used to learning at no longer seemed enough. So many of us started doing more: reading more, testing more, learning more. I worry about the burnout that can come from that pressure. When things change this quickly, keeping up can start to feel like part of what it means to perform well, while what we expect ourselves to know keeps changing.
Where experience still matters
These tools can now generate code faster than we can, and much of that code works. I've heard plenty of concerns about whether it scales, is well architected, or is secure, and I think some of those concerns still hold.
Those concerns also point toward where experienced developers can bring value. Understanding architecture, design patterns, DevOps, and how systems connect gives us a way to guide what gets built. Anyone can ask an LLM to build a website, but as you add to it, I think you'll eventually run into a wall without a clear structure, guardrails, and tests. I'm thinking here about software you expect to grow over time. Starting small to keep costs down, while leaving room to grow, still matters.
Building a better vocabulary
This became much more concrete for me recently. I left my management role to join a startup where four of us, all friends, are building new software developed entirely with AI. That brings a different kind of challenge, and I want to give it its own article later. What it changed right away was the kind of questions I ask every day. They are less about how a team should work and more about what the system should be.
That's where I've been putting my energy lately. I've been reopening old books on design patterns, watching architecture videos, and focusing on improving my vocabulary and understanding of how everything connects. I let AI write the code, but I try to focus my questions on the bigger picture of what we want to build: the cloud stack we need, the architecture we should support, and the tooling that will help us see how the system behaves. I'm spending more time looking at how the system works as a whole and less time looking only at the code it wrote.
What I didn't fully expect is how much of this comes down to communication. Developers are not usually recognized for their communication skills, and our field has rarely treated communication as a core part of the craft. Working with AI is exactly that, though. The quality of what I get back is closely tied to how clearly I can describe my intention, and that depends on having the right words.
Asking for "a service that handles notifications" gives me something generic. Asking for an event-driven design with an outbox, idempotent consumers, and a dead-letter queue gives me something I can actually reason about. The same is true beyond architecture: knowing the language of security, testing, infrastructure, product, or the business domain we're building for changes the conversation I can have with the tool.
I'm sure there are plenty of other ways people are learning to navigate these changes. For me, this is what has helped me stay relevant and given my learning a clearer focus. I don't need to know every new tool the week it comes out. Expanding my vocabulary, and the understanding that comes with it, is how I'm learning to communicate better with the tools I now have.
- Patrick