The four patterns of AI-native development, presented at TechRocks Paris. This version covers the full framework plus an extended Q&A on how AI changes developer culture, the cost of agent swarms, and why documentation matters more than ever.
The transformation is the same
Every technology transformation — DevOps, cloud, agile — follows the same adoption arc: find enthusiasts, nurture one team, remove their bottlenecks, synthesize learnings, scale across the organization. AI is no different. The tooling is new, the transformation process isn’t.
1. From Producer to Manager
AI coding tools generate 10, 50 files at a time. The real problem isn’t production — it’s review. The cognitive load of reviewing AI-generated code is the new bottleneck. Emerging approaches include summary-style diffs, diagram-based change visualization, AI-annotated code reviews, and even podcast-style summaries of what agents did overnight. The IDE is evolving from a code-writing tool into an agent management interface.
Some tools are inverting the model entirely: auto-commit by default, roll back if you don’t like it. Management by exception rather than review-before-merge.
The DevOps parallel is direct. Developers used to throw code over the wall to ops. Now AI throws code to developers. We’re all ops.
2. From Implementation to Intent
The shift from continuous prompting to reusable specifications. Developers write markdown files with technical and business requirements, and agents implement against them. GitHub calls this intent-based coding — you specify what you want, the agent builds it, you verify the result.
This resurfaces good engineering practices: modular codebases, up-to-date documentation, consistent patterns. These were always best practices, but AI makes them load-bearing — if your docs are bad, your agents produce bad results.
The progression: prompt engineering (tricks to make AI respond better) → context engineering (making sure AI knows what it needs to know) → intent engineering (expressing clearly what you actually want).
3. From Delivery to Discovery
Product owners can prototype without waiting a month for developer attention. Tools like Lovable let them explore variations cheaply — dark theme, light theme, different layouts — learning what they actually want through the act of building.
The parallelism extends to technical implementations too. Multiple agents, multiple Git checkouts, multiple approaches running simultaneously. But coordination becomes the problem — how do you keep agents from tripping over each other? The same challenge product owners face when breaking work into independent pieces.
Agents are leaving the laptop. Headless, running in the cloud, asynchronous. The IDE becomes a dashboard for managing agent flow, not just a place to write code.
4. From Data to Knowledge
The ultimate pattern: capturing what you learn while building. Documentation optimized not just for humans but for agents — like SEO, but for AI consumption. Tools that behave differently when they detect an agent is calling them.
Knowledge capture happens inline, while coding. The agent notices something important and asks: should we save this? When documentation is being used constantly by agents, there’s finally a forcing function to keep it current.
The multiplier: if one agent learns a convention, why not share it with all agents working on the same codebase? A knowledge backbone that prevents the same mistake from being repeated across parallel sessions.
The senior developer was always doing this
These four patterns — managing, specifying, discovering, curating knowledge — are exactly what senior developers have always done. AI isn’t replacing the craft. It’s pushing everyone toward the parts of the craft that always mattered most.
We can code faster. All the other pieces still need a lot of love.
Q&A highlights
On documentation overload — Won’t we drown in documentation? The difference now is that agents can help maintain docs inline, during coding, rather than as an afterthought. But the fundamental problem remains: you still have to understand the system to know if the documentation is right.
On changing developer culture — The energy required to specify intent is different from the energy of writing code. It’s the same shift that happens when an IC moves up the ladder to principal engineer. For developers who love the craft of writing code: that skill doesn’t disappear. When things fail, you still need someone who can go deep. But the day-to-day shifts toward supervision and specification.
On costs — Agent swarms are expensive, but the ROI question isn’t just about compute cost. It’s about time saved and capability gained. Can you level up an intern faster? Can a solo developer move at team speed? The technology cost is going down year over year. Don’t let cost block you from learning.
This summary was generated using AI based on the auto-generated transcript.