Guide

Agentic Engineering

Delegating the writing of code, keeping control of the project

The sudden rise of AI in our lives obviously raises many challenges, which our societies will need to address quickly.

But whatever one thinks of it, it is now a reality we need to adapt to in order to make the most of it: the productivity gain it brings is such that turning back seems impossible.


For the software engineer, AI radically changes the way one approaches development.

Some are reluctant, as AI seems to strip away the craft by making manual coding obsolete. For my part, my architectural and organizational skills find their place more than ever.

By taking over the mechanical writing of code, AI lets me devote most of my time to high-value conceptual tasks.

What actually changes

By agentic engineering, I mean two levels of AI usage: informal coding ("vibe coding"), where you tweak a prompt back and forth until you get the desired result, and agentic engineering[1] [4] proper, which structures the work through instructions, tools and tests, and in which the developer, like a conductor, directs, frames and validates the agents' output.

Both approaches are complementary: the first suits quick, precise adjustments (for example fine-tuning a UI), the second lets you steer the project as a whole. It is this second level that the rest of this article focuses on.

For the developer

  • Immediate access to cross-cutting knowledge and skills. Knowing how to operate a tool now matters less than knowing what you want to get out of it and showing creativity.
  • Time freed up for design: while the agent implements the tasks I hand it, I check the work produced (code and tests) and plan the next steps. My time is thus split almost entirely between the architect and product owner hats.

For the project

  • An unmatched implementation speed: an agent produces code much faster than a human, especially for repetitive or clearly specified tasks (though this never removes the need for proper framing and validation of the result).
  • A more polished product: you can quickly prototype and compare several approaches before deciding, then refine the features for a more thoughtful, more ergonomic result.
  • What used to be neglected becomes the norm: tests, documentation, architecture, conventions and code consistency — too often sacrificed for lack of time — can now be put in place and kept up to date continuously.
  • A more accessible codebase: an agent reads documentation and grasps existing code far faster than a new developer, who needs time to get up to speed before working efficiently. Newcomers become productive faster, and the project depends less on "pillar" senior developers, whose knowledge was rarely formalized until now.
To me, this is the main benefit: freed from writing code, you can finally focus on what really drives the quality and reliability of the product.

Points of caution

These gains obviously come with trade-offs: AI also brings its own share of new problems and a new kind of complexity.

Keeping control of the project

Delegating the writing of code does not mean losing interest in it. Leaving agents entirely free means losing sight of what the codebase is becoming — and finding out too late that it rests on poor choices or a shaky architecture.

You therefore need to keep hold of the reins: understand what the AI is doing, know the general workings and organization of the code, to keep the project from drifting over successive iterations. Control then applies less to every single line of code than to the goals, the architecture and the rules of the project.

Someone still needs to review the code produced and fix it if necessary, yet an exhaustive review is long and tedious: the challenge is finding the right balance between speed and rigor.

Results that depend on instructions...

The quality of the code produced remains very dependent on the instructions given: you need to craft your prompts carefully, as well as the project's guidelines, so that the agent follows the expected best practices and code structure.

AI tends, for instance, to reinvent ad hoc solutions instead of reusing or adapting what already exists. You therefore need to explicitly ask for it if you want to keep a consistent codebase.

... and on technical debt

It will also follow the style or practices it finds in the codebase, so if it contains legacy or low-quality code, it will reproduce and amplify those flaws!

It therefore needs to be framed with explicit guidelines and the necessary guardrails to guarantee the quality of the generated code.

Developer: from execution to steering

Philosopher Bernard Stiegler used the term "proletarianization"[2] for the loss of a form of knowledge when it is transferred from a human to a machine or a technical system. It affects not only the know-how of the craftsman turned worker, but also the knowledge of how to design held by engineers and decision-makers, when they defer to systems they no longer understand — reduced to mere executants, stripped of decision-making and methodological responsibility.

The developer is not (yet) replaced by the machine, but to avoid being stripped of their conceptual knowledge, they must radically change the way they work: the point now is to build the framework and workflow that let you steer and control the agents. It is precisely this framework that addresses the points of caution raised above.

A reinforced safety harness

In this way of working, you barely write code yourself anymore: you need to precisely define what the agents must do, with clear specifications and rigorous tests, so as not to have to constantly rework the code produced. TDD (test-driven development) truly comes into its own here: the tests, validated by the developer, describe the expected behavior before implementation, then verify it automatically.

Strict typing, static analysis, linters, continuous integration... these tools already equipped the most mature projects, but they become essential because they significantly reduce the amount of human review needed — and are now quick to set up (with an agent!).

Precise instructions

You also need to work on your prompts to increase the precision of your requests, and above all formalize the project's guidelines: code architecture, conventions and best practices to follow, reuse of what already exists...

Versioned like the code itself, they avoid having to re-explain the context or the approach with every request — and form valuable documentation, just as useful to developers as to agents.

A readable architecture

A well-structured codebase — cohesive modules, clearly delimited layers, explicit dependencies — gives the agent a narrow, easy-to-grasp and easy-to-reproduce context, which makes its work more reliable.

AI actually acts as an amplifier: it lifts up a well-structured project, but accelerates the decay of one that isn't.

The principles presented in my guide Understanding Software Architecture apply here just as well.

Review proportionate to the stakes

To find this balance, not all code deserves the same level of attention:

  • skim trivial or mechanical code already covered by tests;
  • review in detail what is critical: business domain, security, structuring decisions;
  • supplement with regular audits (quality, security, consistency).

More autonomous agents

The goal is to make agents as autonomous as possible, by reducing their questions and the corrections needed on their work. The more precise the framework, the less the agent will need to involve the developer.

This autonomy paves the way for genuine teams of agents with distinct roles: one implements, another reviews, a third audits security or code consistency... Part of the review can thus be delegated, as long as the developer sets the rules and keeps a hand on the critical points.

My experience

Agentic engineering fits well with the way I like to work: I enjoy confronting my ideas and doubts with other points of view to enrich my thinking and make the best decisions for the project. But a fellow developer or architect isn't always available to talk things through at the right moment.

AI thus offers an ideal partner for discussing design choices, much like a "rubber duck" — that rubber duck you explain your problem to in order to better understand it — except this one actually talks back.


It acts as a catalyst: by reducing the friction caused by hesitation, it speeds up decision-making.

Conclusion

The profession isn't disappearing, it's shifting: from writing code towards design, defining the framework, and validation. Skills in architecture and project management are no longer secondary — they become central.

Stiegler saw in every technique a pharmakon[3], both poison and remedy depending on how it is used. AI is no exception: poison if the developer also delegates design and decisions to it, remedy if it frees them from mechanical writing so they can focus on what makes software quality.


One question remains open, however, for junior developers and students: how do you learn the basics of a craft whose most visible part is now handled by AI?

Knowing how to read and evaluate code remains essential to keep control over the code produced, but it is crucial to understand that the profession has changed, in order to steer one's growth from now on towards architecture, design and project steering — where a developer's value now lies.

References

  • [1] 🔗 Simon Willison — What is agentic engineering?, in Agentic Engineering Patterns (2026) — the distinction between vibe coding and agentic engineering
  • [2] 📔 Bernard Stiegler — Pour une nouvelle critique de l'économie politique (Galilée, 2009) — proletarianization extended to the loss of knowledge, up to the knowledge of how to design
  • [3] 📔 Bernard Stiegler — La Société automatique, 1. L'avenir du travail (Fayard, 2015) — the automation of work and technique as pharmakon
  • [4] 🔗 NxCode — Agentic Engineering: The Complete Guide to AI-First Software Development Beyond Vibe Coding (🇫🇷, 2026) — a detailed practical guide