Le Coding Agentique avec Devstral

Qu’est-ce que le coding agentique ?

Le coding agentique représente un changement de paradigme dans le développement assisté par IA. Au lieu de demander au modèle de générer du code snippet par snippet, vous lui confiez une tâche complète et il la résout de manière autonome en enchaînant les étapes : exploration, planification, implémentation, vérification.

Devstral est spécifiquement conçu pour ce mode de travail. Il ne se contente pas de répondre à une question — il agit sur le codebase.

Le cycle agentique de Devstral

Un agent de code comme Devstral suit un cycle itératif en quatre phases :

Phase 1 — Comprendre

L’agent commence par explorer le codebase pour comprendre le contexte :

• Lire la structure des dossiers et fichiers
• Identifier les fichiers pertinents pour la tâche
• Comprendre les dépendances entre modules
• Repérer les conventions de code existantes (nommage, patterns)

Phase 2 — Planifier

Avant d’écrire une seule ligne de code, Devstral élabore un plan :

• Décomposer la tâche en sous-tâches ordonnées
• Identifier les fichiers à modifier et les fichiers à créer
• Anticiper les effets de bord et les risques de régression
• Choisir l’approche technique la plus adaptée

Phase 3 — Exécuter

L’agent implémente le plan étape par étape :

• Modifier les fichiers existants
• Créer de nouveaux fichiers si nécessaire
• Mettre à jour les imports et les dépendances
• Adapter les configurations

Phase 4 — Vérifier

Après l’implémentation, Devstral vérifie son travail :

• Exécuter les tests existants
• Écrire de nouveaux tests pour le code ajouté
• Vérifier que le build passe
• Relire le diff pour détecter les erreurs

Exemple concret : corriger un bug

Supposons que vous signalez à Devstral : “Les utilisateurs reçoivent une erreur 500 quand ils soumettent un formulaire avec un email contenant un ’+’”

Voici comment Devstral procède :

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

Le tool use en pratique

Devstral interagit avec son environnement via des appels de fonctions (tool calls). Voici les outils typiques d’un agent de code :

# 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",
)

Devstral va typiquement :

1. Appeler read_file("src/auth/validators.py") pour comprendre le code existant
2. Appeler read_file("tests/test_auth.py") pour voir les tests actuels
3. Appeler write_file("src/auth/validators.py", ...) avec le code modifié
4. Appeler write_file("tests/test_auth.py", ...) avec les nouveaux tests
5. Appeler run_command("pytest tests/test_auth.py") pour vérifier

Boucle agentique multi-tours

L’aspect crucial du coding agentique est la boucle multi-tours. L’agent ne fait pas tout en un seul appel — il itère :

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
    })

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é