No one on the platform team can clearly tell whether that change respects ownership boundaries, the domain map or the system’s real blast radius. The practices that brought us this far — CI, tests and CODEOWNERS — were experiments that worked and became part of the DevOps tradition. The problem is that they were designed for human development, not for code generated by agents.
Imagine the scene: an agent creates a PR that modifies a microservice, touches a pipeline and changes a Dockerfile. Everything compiles. The tests pass. The speed is real.
Control? Not always.
5 practices that remain essential
| Traditional practice | What it solved in the pre-AI era | Why it is still needed with AI agents |
|---|---|---|
| CODEOWNERS + branch protection | Defined ownership and who could merge. | The volume of agent PRs dilutes responsibility. Without clear ownership, there are no clear boundaries. The agent does not know what it can touch… and when something fails, you are still responsible. |
| Linters + static analysis (including side effects) | Filtered style, conventions and obvious errors. | AI can generate syntactically correct code that violates conventions or introduces unwanted side effects. |
| Unit tests + PR verifies (CI) | Ensured a change did not break the build or existing logic. | It does not matter who wrote the code. If it does not pass CI, it does not move forward. CI remains the first objective quality filter. |
| Docker images + CD pipelines | Ensured reproducibility and deployment control. | An agent can modify Dockerfiles or deployment configuration. CD is what prevents those changes from reaching production without validation. |
| Human code review | Added context, intent and business knowledge. | AI lacks tacit domain knowledge and the team’s social context. Human review remains the final sense check. |
The bottleneck is no longer writing code
The problem is no longer failing tests. The code has to live within a map of domains, systems, dependencies and ownership. This is where guardrails come in: explicit, encoded and actionable limits that control what an agent can do when generating code. Three elements make them real:
- An explicit map of the organisation (Domains → Systems → Components → Teams + ownership).
- Reusable Features: standardised capabilities (builds, pipelines, releases…) applied to each component. The standard stops living in people’s heads and becomes encoded.
- Limits on actions based on risk level, with visibility into the origin of a change (human or agent) and the same validations for everyone.
When the map is clear and Features are defined, guardrails stop being abstract rules. The agent operates on known components, with standardised capabilities and explicit ownership.
Traditional practices are still necessary. But without guardrails, AI speed becomes instant technical debt. The goal is not to slow agents down. It is to keep the organisation’s map intact as software scales.
Are you seeing this same bottleneck in your team?
