A pioneer in the DevOps field, Patrick Debois anticipates another significant transformation with the rise of native AI. Developers will no longer write code in the traditional sense; instead, they will manage agents.
Scientists confirm: This is the most effective way to get your cat’s attention, according to new research
Elderly Couple Refuses Reserved Seats—Viral Train Standoff Sparks Fiery Debate on Courtesy
From Code Producer to Agent Manager: A Structural Shift
Patrick Debois, a Belgian and a seminal figure in DevOps credited with coining the term, co-authoring the DevOps Handbook, and initiating the first DevOpsDays, shared his insights at the “AI Native Development — rethinking our workflow” conference during the Tech.Rocks Summit. He believes AI is not just a productivity tool but a complete overhaul of the development workflow.
Debois points out a clear evolution in developers’ roles: “They might still produce code, but their primary role will shift towards managing agents.” With AI, the generation of code becomes secondary to the review and orchestration of the work AI performs. The challenge now is managing the sheer volume and complexity of AI-generated outputs, which traditional practices can’t adequately address.
For instance, he mentions the endless ‘diffs’ (a Unix command for comparing files) that become overwhelming with AI-generated content: “The traditional diff view… it’s a lot of text. With AI, it’s not just three lines; it’s a massive amount of text.” Discussions within the Integrated Development Environment (IDE) become similarly unmanageable: “There’s even more text. I don’t have time to read all that!”
Debois proposes not simply summarizing AI with another AI, but rethinking the review process itself, incorporating intelligent annotations, contextual summaries, graphical visualizations of changes, and even more novel formats like Google’s NotebookLM, which can generate a podcast summarizing the work done. “You listen to the podcast in the morning, and you know what the agents have achieved.” This positions the IDE as a hub for managing agents, not just a code editor.
AI Replays the Early Tensions of DevOps
Debois draws parallels between this shift and the early days of DevOps, where developers would “throw code over the wall” without ever running it themselves, leaving Ops to handle the aftermath. With AI, he observes a similar pattern: “It’s exactly what we feel with AI. AI generates the code. We don’t think about the generation process anymore. But we are still responsible when it runs, and when it fails. In this sense, we are all Ops.”
He continues with the traditional DevOps logic: move fast with solid testing (“if you want to go faster, you need better brakes”), monitor, observe the unknown, and engage in “chaos engineering.” None of these practices disappear with AI; rather, they become even more crucial as systems are generated rapidly, placing greater responsibility on humans. Debois briefly critiques the notion of optimizing Return on Investment (ROI) by cutting staff with AI: “Those who think they can optimize developer ROI by downsizing are mistaken. They need to be there when things go wrong.” AI speeds things up, but the risks remain human.
From Prompts to Specifications: A Forced Return to Best Practices
Debois describes a clear transition in how agents are directed, moving from ephemeral prompting to persistent specifications. “People are starting to write specifications. They create a markdown file and tell the AI, ‘Read this file, and when I modify it, apply the changes.'” GitHub refers to this as ‘intent-based coding’: the intent is described, and the agent implements it.
This shift brings fundamental development practices such as modularity, clean segmentation, up-to-date documentation, naming conventions, and reliable testing back to the forefront. “If your documentation isn’t up-to-date, the AI will yield poor results,” Debois simply states.
Why You Should Never Reheat These Foods in the Microwave – The Hidden Dangers Experts Warn About
I tried the top 5 guard dogs—here’s what makes these breeds the ultimate protectors
He recalls a moment after presenting this theme when a team approached him saying, “We should do this for our codebase,” to which he replied, “Why weren’t you doing it already?” He concludes that AI doesn’t replace good practices; it makes them more essential than ever.
The Product Owner Becomes an Explorer: Prototyping Without Delay
One of the most striking observations involves product owners. With tools like Lovable, they can now create functional prototypes themselves: “If I asked our IT department, it would take a month before a developer responded. Now, I can do it myself.”
By generating multiple variations (dark, light, version A, version B, etc.), they quickly learn what they want. The prototype becomes a tool for reflection, not just illustration. “And because the prototype is relatively inexpensive, they can ask for options.”
Debois also notes the emergence of parallel agents capable of exploring multiple technical paths simultaneously, and the rise of tools that run directly in the cloud, in headless mode, to multiply low-cost runs.
Managing Agents Like Teams: A New Backlog
According to Debois, organizations are beginning to create new dedicated backlogs for orchestrating this work: “We need a backlog system for agents: ‘Agent, do this.'”
In this model, the IDE is no longer just a place to edit files. It becomes the dashboard for managing a collection of agents, each with its task, scope, permissions, and associated costs. “The IDE is used to manage multiple agents simultaneously and review their various outputs.”
As with humans, it’s essential to define what agents are allowed to modify: “AI, you are not allowed to touch our tests,” illustrates Debois. This marks the emergence of a new form of software governance.
Knowledge Becomes Infrastructure: Towards ‘Continuous Re-architecting’
For Debois, knowledge is now a continuous flow between humans and agents. “The acquisition of knowledge becomes an integral part of code agents.” Documentation must also be designed for agents: “Is your documentation optimized to be consumed by agents? It’s almost like SEO.”
Some tools already automatically record important decisions throughout development: “While agents code with us… all this knowledge is saved in the agents, by the agents.”
This knowledge can be shared among agents to prevent them from repeating the same mistakes: “If one agent learns something, why wouldn’t it pass that knowledge on to others?” This leads to a broader vision: “It’s not just continuous integration or continuous delivery. It’s continuous re-architecting.”
Debois suggests that the real question is how easily an organization can replace a coding tool, a cloud, a technology, a piece of architecture. AI makes this possible, provided that practices, tests, and shared knowledge are well-managed. He concludes humorously: “We’ll always have ‘what the fuck’ moments, but AI will always assure us we’re right.”
Similar Posts
- OpenAI Unveils Codex: Revolutionizing Automated Coding with ChatGPT AI Agent
- GitHub Unveils New AI Code Agent: Discover How It Works!
- AI Revolution in Coding: Claude Deploys AI Agents to Review Your Pull Requests!
- Study Reveals: How Developers Will Use AI in 2025!
- OpenAI Unveils Frontier: New AI Management Platform Revolutionizes Business Operations!
Jordan Park writes in-depth reviews and editorial opinion pieces for Touch Reviews. With a background in UI/UX design, Jordan offers a unique perspective on device usability and user experience across smartphones, tablets, and mobile software.