Over the past year, something strange happened to a lot of senior engineers on my feed: they started writing less code. Not because they're slacking off or burning out—but because AI tools have quietly taken over the boilerplate grunt work that used to eat their afternoons. A recent DEV.to post from developer Marcosomma captures this shift perfectly, describing how they've shifted from churning out implementation details to spending more time on system design, code review, and debugging production issues.

The Traditional Developer Identity Is Shifting

For decades, "developer" has been synonymous with "someone who writes code." Our job interviews test algorithm skills. Our performance reviews measure lines written or features shipped. But if AI is handling the mechanical translation from design to implementation, what does that make us? Somma's reflection suggests we're becoming something closer to architects and quality gatekeepers—roles that were always part of the job but got buried under sprint deadlines and ticket backlogs.

What Senior Engineers Are Actually Doing Now

The developers reporting this shift aren't writing fewer features—they're refocusing their attention. System design conversations are getting longer because someone has to make the architectural calls that AI can't (yet) make reliably. Code reviews require more judgment when you're evaluating AI-generated implementations for edge cases and maintainability. Debugging production issues still needs human intuition, though AI assistants can now surface relevant logs and suggest hypotheses faster than manual grep ever could.

The Tools Driving This Shift

GitHub Copilot, Cursor, Claude, and their competitors have become the default pair programmer for teams that can afford the subscriptions. These tools excel at generating boilerplate, converting comments to code, explaining unfamiliar APIs, and refactoring repetitive patterns. The developers adapting fastest aren't fighting this—they're treating AI as a junior developer who works 24/7 but needs senior oversight.

Why This Might Be the Point

Here's where I think Somma lands it right: if we're honest about what we actually want from software systems—reliable, maintainable, well-designed code—then maybe less time writing implementation and more time on design thinking isn't a loss. It's the role finally matching the value we could always theoretically provide. The developers worried about "not coding enough" might be mourning a metric that never mattered as much as we thought.

Key Takeaways

  • AI coding assistants are handling increasing amounts of implementation work, letting engineers focus on architecture and review
  • Senior devs reporting this shift describe spending more time on system design and debugging production issues
  • The "lines of code written" metric may be becoming an outdated measure of developer productivity
  • Teams adapting fastest treat AI tools as junior collaborators requiring senior oversight

The Bottom Line

The developers who thrive in this new era won't be the ones writing the most code—they'll be the ones who know what to ask for, how to review it critically, and when human judgment still beats algorithmic generation. If you've been measuring your worth by keystrokes, it's time to find better metrics.