Aller au contenu principal

Agents de codage locaux (et comment ils s'associent à Claude)

Intermédiaire

Un agent de codage local est un programme qui s'exécute sur votre propre machine, lit votre dépôt et modifie vos fichiers à votre place. Vous décrivez une modification en langage naturel ; l'agent la planifie, écrit du code réparti sur plusieurs fichiers, exécute vos tests, lit les échecs et réessaie — une boucle, pas une réponse unique. L'assistant conversationnel dans un onglet de navigateur vous remet un extrait à coller ; un agent de codage fait lui-même le collage, l'exécution et la correction, à l'intérieur de votre dépôt.

L'idée clé qui rend cette page digne d'être lue : presque tous ces outils sont agnostiques au modèle. L'agent (la boucle qui touche à vos fichiers) est distinct du modèle (le cerveau qui décide quoi écrire). Ainsi, le même outil peut être pointé vers Claude pour la meilleure qualité de code, ou vers un modèle local à poids ouverts via Ollama pour que votre code ne quitte jamais votre ordinateur portable. Vous choisissez l'agent en fonction de son adéquation avec votre flux de travail, et le modèle en fonction du compromis qualité-vs-confidentialité — indépendamment.

What you'll learn
  • Comprendre l'archétype de l'agent de codage : une boucle d'agent qui lit votre dépôt, planifie, modifie les fichiers, exécute les tests et itère
  • Connaître les véritables outils ouverts — Aider, Cline, Continue, OpenHands — et la place qu'occupe Claude Code, l'agent propre à Anthropic
  • Saisir pourquoi « agnostique au modèle » importe : pointer un même agent vers Claude pour la qualité OU vers un modèle local pour la confidentialité
  • Comprendre l'angle de la confidentialité — un modèle local signifie que votre code ne quitte jamais votre machine
  • Choisir selon deux axes : intégré à l'IDE vs CLI vs autonome, et propulsé par Claude vs entièrement local

L'archétype : une boucle d'agent, pas une zone de discussion​

Chaque outil de cette page est une variation autour de la même boucle. Une fois que vous avez saisi la boucle, chaque outil n'est qu'une forme différente construite autour d'elle :

  1. Lire — l'agent rassemble le contexte : les fichiers que vous lui indiquez, la structure du dépôt, parfois la sortie des tests ou les journaux d'erreurs.
  2. Planifier — il décide quoi modifier et dans quels fichiers, en proposant souvent un plan avant de toucher à quoi que ce soit.
  3. Modifier — il écrit les changements dans de vrais fichiers sur le disque (généralement présentés sous forme de diff que vous approuvez).
  4. Exécuter — il lance des commandes : votre suite de tests, une compilation, un linter, un script.
  5. Observer et itérer — il lit ce qui s'est passé (les tests ont-ils réussi ? une trace de pile ?) et revient à l'étape 2 jusqu'à ce que la tâche soit terminée ou qu'il vous rende le contrôle.

C'est la même forme que l'utilisation d'outils agentique : on donne des outils au modèle (lire un fichier, modifier un fichier, exécuter une commande) et il décide quand les appeler. La différence entre les outils tient surtout à la quantité d'autonomie dont dispose la boucle et à l'endroit où elle vit — votre terminal, votre éditeur ou un environnement en bac à sable fonctionnant de manière autonome.

Le modèle au cœur de cette boucle est interchangeable. C'est toute la raison pour laquelle un seul agent peut servir deux utilisateurs très différents : celui qui veut le code le plus solide possible (le pointer vers Claude) et celui qui, légalement, ne peut pas laisser son code sortir de son réseau (le pointer vers un modèle local).

Pourquoi l'agnosticisme au modèle est la fonctionnalité phare​

L'agent et le modèle sont des pièces distinctes. L'agent possède la boucle — lire les fichiers, appliquer les diffs, exécuter les tests. Le modèle possède le jugement — quoi écrire, pourquoi, et quand s'arrêter. Les découpler vous donne deux molettes indépendantes :

  • Molette de qualité → Claude. Pour le raisonnement difficile, les refactorisations multi-fichiers et le travail à long contexte, un modèle de pointe comme Claude produit des modifications nettement meilleures et se remet des échecs de manière plus fiable. La plupart de ces outils documentent Claude comme un choix recommandé ou par défaut. (Quel palier de Claude choisir est une décision à part entière — voir Choisir un modèle.)
  • Molette de confidentialité → un modèle local. Pointez le même agent vers un modèle à poids ouverts fonctionnant sous Ollama et votre code, vos prompts et vos diffs ne quittent jamais votre machine — aucun appel d'API, aucun tiers, rien qui transite sur le réseau. C'est le facteur décisif pour les bases de code réglementées, isolées du réseau (air-gapped) ou confidentielles. Le compromis, en toute honnêteté : un modèle assez petit pour tourner sur un ordinateur portable ne joue pas dans la même cour qu'un modèle de pointe sur les tâches les plus difficiles. Vous échangez une part de capacité contre un contrôle total des données.
What you'll learn
  • Agnostique au modèle ne signifie pas que tous les modèles se valent. La boucle s'exécute de la même façon, mais un modèle faible fait de moins bonnes modifications, interprète mal les échecs de tests et itère sans résultat. Confidentialité et capacité s'échangent réellement l'une contre l'autre — choisissez par tâche, pas une fois pour toutes.

Les véritables outils (vérifiés)​

Cinq outils à connaître. Les quatre premiers sont open source et agnostiques au modèle ; le cinquième est l'agent propre à Anthropic, inclus pour que vous voyiez où se situe une expérience native Claude.

Aider — le partenaire de programmation en CLI​

Aider s'exécute dans votre terminal et est construit autour de git : il modifie les fichiers de votre dépôt et committe automatiquement chaque modification avec un message pertinent, de sorte que chaque modification par l'IA est un diff que vous pouvez relire, annuler ou révoquer. Il est agnostique au modèle — il fonctionne le mieux avec des modèles de pointe comme Claude, et il se connecte aussi à des modèles locaux via Ollama (aider --model ollama_chat/<model>). Si vous vivez dans le terminal et voulez une hygiène git rigoureuse, Aider est le choix CLI canonique.

Cline — l'agent à l'intérieur de votre IDE​

Cline est un agent de codage open source qui vit dans votre éditeur (VS Code et JetBrains) et propose aussi une surface terminal/CLI. Il crée des fichiers, exécute des commandes et utilise des outils avec approbation humaine dans la boucle — vous voyez et approuvez chaque étape. Il est agnostique au modèle et prend explicitement en charge Claude ainsi que les modèles locaux via Ollama ou LM Studio. Optez pour Cline lorsque vous voulez un agent quasi autonome sans quitter votre éditeur.

Roo Code est un fork bien connu de Cline qui a ajouté des « modes » personnalisés (par exemple un mode Architect pour la planification, un mode Coder pour les modifications). Il était lui aussi agnostique au modèle. Notez son statut ci-dessous — ce n'est plus le choix par défaut sûr qu'il fut autrefois.

Continue — l'assistant IDE ouvert​

Continue est un assistant open source pour VS Code et JetBrains (plus une CLI) couvrant le chat, l'édition, l'autocomplétion et un mode agent. Il est profondément agnostique au modèle : sa documentation liste Anthropic (Claude), Ollama pour les modèles locaux, et de nombreux autres fournisseurs, avec la possibilité d'assigner différents modèles à différents rôles (chat, édition, autocomplétion). C'est un choix solide si vous voulez un seul assistant configurable où vous câblez précisément quel modèle fait quoi.

OpenHands — l'agent autonome​

OpenHands (anciennement OpenDevin) est le plus autonome des quatre : une plateforme d'agents de développement logiciel par IA qui travaillent dans un environnement en bac à sable, décomposent une tâche (par exemple une issue GitHub) et la mènent à bien de bout en bout avec moins d'approbations étape par étape. Il est agnostique au modèle — « à utiliser avec n'importe quel LLM », Claude compris — et peut être auto-hébergé. Choisissez OpenHands lorsque vous voulez déléguer une tâche entière et revenir la vérifier, plutôt que d'approuver chaque modification.

Claude Code — l'agent propre à Anthropic​

Claude Code est l'outil de codage agentique officiel d'Anthropic : il lit votre base de code, modifie les fichiers, exécute des commandes et des tests, et fonctionne à travers votre terminal, votre IDE, l'application de bureau et le web. Contrairement aux quatre outils ci-dessus, il ne se « pointe pas vers n'importe quel modèle » — il est construit autour de Claude et réglé pour lui, ce qui explique précisément pourquoi la boucle est plus serrée et que les modifications aboutissent plus souvent sur les tâches difficiles. Si votre priorité est la meilleure expérience de codage propulsée par Claude plutôt qu'une interchangeabilité maximale des modèles, c'est la voie native. Tous les détails dans Qu'est-ce que Claude Code.

Comment choisir​

Deux axes décident de presque tout :

Axe 1 — où vit l'agent :

  • CLI / terminal (Aider, Claude Code) — scriptable, compatible git, chaînable avec d'autres outils. Idéal si vous vivez dans le shell.
  • Intégré à l'IDE (Cline, Continue, la surface éditeur de Claude Code) — diffs et approbations à l'intérieur de votre éditeur, avec votre code juste là. Idéal pour l'édition quotidienne.
  • Autonome / en bac à sable (OpenHands) — déléguer une tâche entière et en relire le résultat. Idéal pour le travail par lots ou sans intervention.

Axe 2 — propulsé par Claude vs entièrement local :

  • Propulsé par Claude — meilleure qualité, en particulier sur les tâches difficiles multi-fichiers ou à long contexte. Votre code est envoyé à l'API du modèle. À choisir lorsque la qualité prime le plus et que votre code peut être envoyé à un fournisseur.
  • Entièrement local (Ollama) — votre code ne quitte jamais la machine ; gratuit à exécuter ; fonctionne hors ligne. À choisir lorsque la confidentialité, la réglementation ou l'isolation réseau est non négociable — en acceptant qu'un modèle de la taille d'un ordinateur portable soit plus faible sur les tâches les plus difficiles.

Le geste durable : choisissez l'agent pour la surface qui correspond à votre flux de travail, puis choisissez le modèle par tâche. Rien ne vous empêche d'exécuter un agent IDE sur un modèle local pour le dépôt confidentiel et le même agent sur Claude pour tout le reste.

Choisir et configurer un agent de codage​

Guided walkthrough1 of 5
  1. CLI (Aider, Claude Code), intégré à l'IDE (Cline, Continue) ou autonome (OpenHands). Adaptez-la à l'endroit où vous travaillez déjà — terminal vs éditeur vs déléguer-et-relire.

Une première exécution concrète avec Aider pointé vers un modèle local (privé, gratuit, hors ligne) — téléchargez d'abord le modèle avec Ollama, puis :

Exécuter Aider sur un modèle local Ollama (le code reste sur votre machine)

aider --model ollama_chat/qwen3

Pour pointer le même outil vers Claude à la place (meilleure qualité, code envoyé à l'API), vous renseignez votre clé Anthropic et sélectionnez un modèle Claude — la boucle de l'agent est identique ; seul le cerveau change :

export ANTHROPIC_API_KEY=sk-ant-...
aider --model sonnet

Cette bascule — un seul drapeau, deux profils confidentialité/qualité complètement différents, même agent — est tout l'enjeu de cette page.

Vérifiez vos acquis

0/4
  1. Que signifie « agnostique au modèle » pour un agent de codage comme Aider ou Cline ?
  2. Votre base de code ne peut légalement pas quitter votre réseau. Quelle configuration convient ?
  3. En quoi Claude Code diffère-t-il d'Aider, Cline, Continue et OpenHands ?
  4. Quel outil est le plus autonome — conçu pour prendre une tâche entière et l'exécuter dans un bac à sable avec moins d'approbations étape par étape ?
Appuyez sur Entrée ou Espace pour retourner la carte. Utilisez les flèches gauche et droite pour naviguer entre les cartes.Terme affiché.
1 / 8
Key takeaways
  • Un agent de codage exécute une boucle sur votre machine — lire le dépôt, planifier, modifier les fichiers, exécuter les tests, itérer — au lieu de vous remettre des extraits à coller.
  • Presque tous ces outils sont agnostiques au modèle : l'agent et le modèle sont distincts, vous échangez donc le cerveau sans changer la boucle.
  • Deux molettes : Claude pour la meilleure qualité de code, ou un modèle local à poids ouverts via Ollama pour une confidentialité totale — votre code ne quitte jamais la machine.
  • Aider = CLI/git ; Cline = agent dans votre IDE ; Continue = assistant IDE configurable ; OpenHands = autonome/bac à sable ; Claude Code = l'agent natif Claude d'Anthropic.
  • Choisissez selon deux axes — où vit l'agent (CLI vs IDE vs autonome) et propulsé par Claude vs entièrement local — et choisissez le modèle par tâche, pas une fois pour toutes.

Sources et lectures complémentaires​