Intent is the new source code
Unaddressed questions while writing Beyond Code-Centric
➡️ I wrote and released a nine page white paper “Beyond Code-Centric” that you can download + read on my website. It lays the ground work for why I believe intent is the new source code.
It makes the case that since agents generate code on demand the bottleneck has shifted from implementation speed to specification clarity.
Writing Beyond Code-Centric raised a swarm of unaddressed questions. Maybe reading it will for you too. This meditation digs into some of them… how the abstraction shift rewires our work, reshapes the skills that matter, and redefines what it means to build software.
Forewarning: I don’t have all the answers.
What This Means for Developers
Some welcome this change. They can focus on designing systems instead of debugging syntax errors. They spend time thinking about what users need. Writing clear specifications becomes the new skill that matters.
Other feel like they're losing something important. They miss the satisfaction of solving coding problems directly. Writing specifications feels like management work, not creation. They worry that giving up hands-on coding means giving up the heart of their profession.
Both reactions make sense. Every major technology shift eliminates some skills while creating demand for others. My learning and meta-reflection is that adaptation is the greatest skill.
Everything transitory—the knower and the known. — IV. 35
AI Code Feels Different
AI-generated code works and passes tests, but experienced developers often notice something off. The code might be more verbose than necessary or miss subtle optimizations a human would include. It follows instructions literally without applying deeper knowledge about the problem domain.
This creates a trust problem. Developers must learn to work with code that feels unfamiliar while building confidence in AI output through testing and review.
How Teams Will Change
This shift redistributes power within development teams. Product managers and designers might gain influence because they can better communicate requirements to AI systems. Junior developers might advance faster by focusing on high-level problems instead of basic coding tasks.
Senior engineers face uncertainty. Their years of coding experience might become less valuable if AI can generate equivalent code. However, their knowledge of system architecture, security, and design trade-offs remains crucial. Their role will likely evolve toward mentoring and system design rather than direct coding.
The traditional code review process will also change. Instead of discussing implementation details, teams will focus more on architectural decisions and whether the agents correctly interpreted requirements.
Understanding What We Build
A critical question emerges: if AI writes the code, do developers still understand their systems?
One view says yes: developers will understand systems better because they must write clear text based specifications and comprehensive tests. They'll focus on what the system does and why, rather than getting lost in implementation details.
The opposite view warns that we'll lose deep technical knowledge. When systems break, nobody will understand the AI-generated code well enough to fix complex problems quickly.
The reality is that modern software already involves many layers that individual developers don't fully understand. The challenge is maintaining enough knowledge to troubleshoot problems while working at higher levels of abstraction.
New Risks
AI generated code introduces many new failure modes. Unlike humans who might cut corners under pressure, agents optimize in unexpected ways. They could generate code that passes all tests but violates security practices or performance requirements that weren't explicitly specified. This is one of these reasons I make the case “not to let AI specify your tests”.
Teams will need to invest in stronger verification methods (and perhaps invent some new ones, too).
Some (additional) thoughts on the future
This trend toward abstraction will continue. We’re starting to need AI to write specifications for other AI systems to execute (e.g. prompt engineering).
You might be wondering (like me) about a market for "artisan software". Hand-coded programs that become luxury items, like craft beer or handmade furniture.
More likely, we'll see hybrid approaches where humans handle creative and intuitive parts while AI generates routine code.
Software development is changing form like Andrej Karpathy brilliantly (and better than I do) lays out below. The LLM is a new OS.
Creativity shifts from writing clever code to designing clear systems. The most valuable skills become writing precise specifications, understanding user needs, and making good architectural decisions.
Success in this new environment requires adapting quickly (more-so than most of us comfortably can). Those who learn to work effectively with agents will thrive.
The future belongs to those who can think clearly about problems and communicate those thoughts precisely to both humans and machines.