Le Coding Agentique avec Devstral — Codestral et Devstral — Coding Assisté par IA

Qu’est-ce que le coding agentique ?

Le coding agentique change la nature de ce que vous demandez au modèle. Au lieu de solliciter un snippet, puis un autre, puis un troisième, en recollant vous-même les morceaux, vous confiez une tâche complète et le modèle la résout en enchaînant seul les étapes : exploration, planification, implémentation, vérification. Vous restez celui qui décide de ce qui doit être fait, mais vous cessez d’être celui qui pilote chaque geste.

Devstral est conçu pour ce mode de travail. Il ne répond pas à une question, il agit sur le codebase.

Le cycle agentique de Devstral

Phase 1 — Comprendre

L’agent commence toujours par se situer. Il lit la structure des dossiers et des fichiers, repère ceux qui touchent à la tâche demandée, remonte les dépendances entre modules pour savoir ce qu’un changement risque d’affecter, et relève les conventions en vigueur — nommage, organisation des tests, patterns récurrents. Cette phase paraît improductive puisqu’elle n’écrit aucune ligne ; elle détermine pourtant si le code produit ensuite ressemblera au vôtre ou à celui d’un inconnu.

Phase 2 — Planifier

Avant la première ligne, Devstral formule un plan. Il découpe la tâche en sous-tâches ordonnées, distingue les fichiers à modifier de ceux à créer, anticipe les effets de bord et les risques de régression, puis arrête une approche technique. C’est le moment où votre intervention coûte le moins cher : corriger un plan prend trente secondes, corriger dix fichiers déjà écrits en prend beaucoup plus.

Phase 3 — Exécuter

L’implémentation déroule le plan pas à pas. L’agent édite les fichiers existants, en crée de nouveaux quand la structure l’exige, met à jour les imports et les dépendances que ses modifications déplacent, et adapte les fichiers de configuration au passage. La cohérence entre ces changements est justement ce qu’un modèle de complétion ne peut pas garantir.

Phase 4 — Vérifier

Vient enfin la démonstration que le travail tient. Devstral exécute la suite de tests existante, en écrit de nouveaux pour le code qu’il vient d’ajouter, contrôle que le build passe, et relit son propre diff à la recherche d’erreurs ou de modifications parasites. Un agent qui saute cette phase produit du code plausible et non du code correct.

Exemple concret : corriger un bug

Supposons que vous signaliez à Devstral : « Les utilisateurs reçoivent une erreur 500 quand ils soumettent un formulaire avec un email contenant un ’+’ ». Le cycle prend alors cette forme :

1. COMPRENDRE
   -> Chercher les fichiers liés au formulaire (search "email" dans le code)
   -> Lire le controller qui traite la soumission
   -> Lire la fonction de validation d'email
   -> Identifier le regex qui rejette le '+'

2. PLANIFIER
   -> Modifier le regex de validation pour accepter '+'
   -> Ajouter un test unitaire pour les emails avec '+'
   -> Vérifier qu'aucun autre endroit du code ne filtre le '+'

3. EXÉCUTER
   -> Modifier src/validators/email.py : corriger le pattern regex
   -> Créer tests/test_email_validation.py : ajouter les cas avec '+'
   -> Modifier src/controllers/form.py : ajouter un log pour le debug

4. VÉRIFIER
   -> Exécuter pytest -> tous les tests passent
   -> Vérifier le diff -> changements cohérents et minimaux

Observez la troisième ligne du plan : l’agent ne se contente pas de corriger l’endroit où le bug se manifeste, il vérifie qu’aucun autre filtre ne rejette le caractère ailleurs. C’est cette recherche de la cause complète, plutôt que du symptôme, qui distingue une correction agentique d’un correctif ponctuel.

Le tool use en pratique

Devstral agit sur son environnement par des appels de fonctions. Vous déclarez les outils disponibles dans la requête, avec leur nom, leur description et le schéma de leurs paramètres ; le modèle choisit lesquels appeler et avec quels arguments.

# Exemple de conversation agentique avec Devstral
messages = [
    {
        "role": "user",
        "content": "Ajoute une validation de mot de passe fort dans le module auth."
    }
]

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Lire le contenu d'un fichier du projet",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "Chemin du fichier"}
                },
                "required": ["path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Écrire ou modifier un fichier du projet",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Exécuter une commande shell",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string"}
                },
                "required": ["command"]
            }
        }
    }
]

response = client.chat.complete(
    model="devstral-small-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

Sur cette demande, l’enchaînement typique commence par read_file("src/auth/validators.py") pour comprendre le code existant, se poursuit par read_file("tests/test_auth.py") afin de voir la forme des tests actuels, puis vient l’écriture : write_file("src/auth/validators.py", ...) avec la règle de validation ajoutée, write_file("tests/test_auth.py", ...) avec les nouveaux cas, et enfin run_command("pytest tests/test_auth.py") pour vérifier. L’ordre a son importance : en ouvrant les deux fichiers avant de toucher au moindre caractère, l’agent relève vos conventions et les reproduit, au lieu d’importer celles qu’il a vues ailleurs.

Boucle agentique multi-tours

Rien de tout cela ne se produit en un seul appel. Le cœur du coding agentique est la boucle multi-tours : le modèle propose une action, votre code l’exécute, puis vous lui renvoyez le résultat pour qu’il décide de la suivante. C’est vous qui gardez la main sur l’exécution réelle, ce qui est aussi votre garde-fou.

while not tache_terminee:
    # 1. Devstral analyse et propose une action
    response = client.chat.complete(
        model="devstral-small-latest",
        messages=messages,
        tools=tools,
    )

    # 2. On exécute l'outil demandé
    tool_call = response.choices[0].message.tool_calls[0]
    resultat = executer_outil(tool_call)

    # 3. On renvoie le résultat à Devstral
    messages.append(response.choices[0].message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": resultat
    })

Le détail à ne pas manquer se trouve dans les deux dernières lignes : le message de l’agent et le résultat de l’outil sont tous deux réinjectés dans l’historique, avec le tool_call_id qui les apparie. Omettez l’un des deux et l’agent perd le fil de ce qu’il vient de faire, rappelant les mêmes outils en boucle.

Points clés à retenir

Le coding agentique suit un cycle : comprendre, planifier, exécuter, vérifier
Devstral utilise le tool use pour interagir avec le codebase de manière autonome
La boucle multi-tours permet à l’agent d’itérer jusqu’à résolution complète
L’agent modifie plusieurs fichiers de manière cohérente en une seule tâche
La phase de vérification (tests, build) est essentielle pour la fiabilité