Codifying the Rules: Building the Platform Behind the Agentic SDLC - Unladen swallow - Olivier Wulveryck
Skip to content
owulveryck's blog
Codifying the Rules: Building the Platform Behind the Agentic SDLC
Olivier Wulveryck — 2026-07-02 — https://blog.owulveryck.info/2026/07/02/sdlc-team-topologies.html
Introduction
This article is a follow-up to our deep dive on Team Topologies. Building reliable software at an organizational scale—across multiple products and teams—requires a fundamental shift in how we operate.
In a modern, AI-driven Software Delivery Lifecycle (SDLC), the stream-aligned team should focus entirely on the solution, delegating the actual implementation to an AI system. This agentic loop is the engine of modern software, powered directly by a robust internal platform that provides the models and the inference engine.
But how do we kickstart this engine without it derailing?
Technology alone isn’t enough; we need the right human collaboration. To build applications that are functional, reliable, and trustworthy, product experts must initially team up with technical experts. This enabling team steps in to structure the AI, establish crucial guardrails, and define the enterprise standards.
Ultimately, this article is a story of loops. The enabling team gathers these technical guardrails and bakes them directly into the platform as automated governance rules. Once the platform absorbs this knowledge, the enabling team can vanish—leaving behind an agentic system capable of producing standard, trustworthy applications out-of-the-box. They will only reappear when a brand-new technical challenge emerges.
Let’s explore how to build and master these cycles, starting with a quick reminder of how the development engine works: the agentic loop.
tap to expand
The agentic loop
This part is not an innovation of any kind. It is a reminder of how the agentic loop works.<br>Nevertheless, it is important to understand this foundation as it is the central point of software delivery. For the rest of this article, I will heavily rely on these principles.
The agentic loop is how modern software delivery powered by AI works.<br>You start by expressing an intention for something you want to develop.
The LLM understands the intention, and then plans some actions. During the planning step, the system evaluates what tools it needs to call to fulfill the need.<br>If a simple task is “write hello in test.txt”, then the plan will produce something like:
Call the writer tool, have it open test.txt, and write “hello” in it.
Then the agent actually calls the tools and executes the action.
Once the action is executed, the agent analyzes the return of the tool’s execution to determine whether there has been an error or if the action was successful.
Self-Correction
One of the strengths of any agentic system is its ability to recover from errors. If a tool fails to reach its goal, the agent feeds the error output back into the planning phase, analyzes what went wrong, and generates a new plan.
For instance, imagine that in our previous example, the system cannot edit the file due to permission issues. The tool call returns an error like “permission denied”. The agent adapts by prepending a step to change the permissions using the chmod tool:
call tool chmod u+w test.txt
Call the writer tool, have it open test.txt, and write “hello” in it.
(While this is a simplistic example — a production-grade system would use more robust error handling rather than a blind chmod — it illustrates the mechanism.)
Once these new tool calls are executed, the loop returns to the observation phase. If the execution was successful, the AI evaluates the current state: is the final intention fulfilled, or was this just an intermediate step that provides new context for the next action?
Note: If the error is a transient error (such as a 429 error in an API call), the agent may decide to retry the tool call without replanning.
The true agentic loop
An agent goes beyond simply executing basic natural language commands; it can tackle complex, ambiguous tasks that require exploration. This is where the loop mechanism truly shines.
Imagine we give the agent a broad intent: “Translate all the files in this directory into English.”
Because the agent lacks context, it cannot translate anything right away. Its first plan must be purely investigative.<br>The first iteration looks like this:
List the files in the directory.
Open each file to detect its source language.
Once these tools are executed, the agent enters the observation phase . It analyzes the results (e.g., discovering two files, coucou.txt and salut.txt, both written in French) and uses this new context to automatically refine the intent into something actionable:
Translate the files coucou.txt and salut.txt from French to English, and save them as hi.txt and hello.txt.
Now equipped with a precise goal,...