A few days ago I wrote about imposter syndrome and the evolution of what it means to be a developer, where I talked about the importance of shifting our focus from the process of writing code to the results we deliver. That advice is sound and prudent, especially in this new world of AI-assisted tooling where the ability to architect solutions and orchestrate AI agents matters more than the raw act of typing out functions and classes. But as I've sat with that idea, a question keeps bubbling up. What about those of us who simply loved the process?

I know these people exist because I'm one of them. There is a particular satisfaction in the craft of writing code that goes beyond the final product. It's the feeling of a clean abstraction clicking into place. The moment when a complex problem dissolves into elegant simplicity. The rhythm of keystrokes as thoughts transform into working systems. For some developers, this isn't just a means to an end. It's the thing itself.

If teams continue to encourage deeper adoption of AI tooling for velocity's sake, and indeed there are gains to be made here that I've witnessed firsthand, that does isolate away slower developers. Or maybe even reasonably quick developers who simply enjoy the process more than the outcome. Some people hate reviewing code. They do it because they have to, to review the work of peers, but it's the worst part of the job for them. This new world shifts all of us into becoming AI orchestrators and ostensibly full-time code review agents ourselves. The human in the loop. I do wonder about how these software engineering purists, I'll call them SEPs, fit into the equation.

As AI continues to adapt and improve, are even the best SEPs going to be forced to adapt or be left behind? As more organizations push AI adoption for speed, how do we software engineers come to peace with our new role in the lifecycle? These new roles and responsibilities are being dropped into our laps in real time and we're all working to figure out how to best reconcile things. How do we find the balance?

I've seen the benefits of AI firsthand and I know what it can do from a very deep technical level. It's astonishing. The speed at which I can now prototype ideas, the breadth of problems I can tackle without getting bogged down in implementation details, the sheer throughput of what becomes possible when you partner with these tools effectively. I get it. I really do.

But I also understand the loss. There's something meditative about the deep focus of writing code, something that connects us to decades of engineering tradition, to the craftspeople who built this industry one function at a time. When we outsource that to AI, even partially, we gain capability but we risk losing something human in the exchange.

So how do we balance it? How do we embrace these tools without becoming ghosts in the machine ourselves? I don't have clean answers yet. Maybe the answer is in being intentional about when we use AI and when we don't, carving out space for the craft even as we leverage the speed. Maybe it's about finding new forms of satisfaction in the higher-level work of architecture and system design. Or maybe we need to accept that the profession is evolving and find our joy in what comes next rather than what we're leaving behind.

What I do know is that this transition is happening whether we're ready for it or not. The question isn't whether AI will change how we work. It's whether we can change with it while still honoring what drew us to this craft in the first place. For the SEPs out there, and for myself, I hope the answer is yes.