IA et code dans le terminal : OpenCode vs Continue.dev vs Aider vs Zed vs Void

Le paysage du codage assisté par IA a explosé en 2026. Mais si vous êtes un développeur qui privilégie l’open source, la confidentialité et les workflows orientés terminal, les options se réduisent rapidement. J’ai testé cinq outils gratuits et open source qui fonctionnent à la fois sur macOS et Linux (Arch) pour trouver la meilleure configuration pour un vrai travail quotidien.

Ceci n’est pas une simple liste de fonctionnalités de surface. J’ai utilisé les cinq outils sur des projets en production — modification de code, commits, revues et déploiements. Voici ce que chaque outil donne réellement en main, où chacun pêche, et comment construire une configuration multi-fournisseur rentable.

Les cinq prétendants

Les cinq sont gratuits, open source et fonctionnent sur macOS + Linux. Aucun abonnement SaaS requis — vous fournissez vos propres clés API (Anthropic, OpenAI, Mistral, Google, ou modèles locaux via Ollama).

1. OpenCode — L’orchestrateur IA

OpenCode est une interface terminal complète pour le développement assisté par IA. Mais l’appeler « un chat dans le terminal » passe complètement à côté. OpenCode est une plateforme d’orchestration avec des workflows multi-agents, un système de compétences et de la délégation de tâches en parallèle.

Ce qu’il fait bien

Architecture multi-agent. C’est la fonctionnalité phare d’OpenCode et rien d’autre ne s’en approche. Vous définissez des agents (Atlas pour l’orchestration, Sisyphus pour l’exécution, Oracle pour les consultations d’architecture, Explorer pour la recherche dans le code) qui travaillent en parallèle. Quand vous demandez à OpenCode d’« ajouter des analytics à 20 dépôts », il répartit des agents vers chaque dépôt simultanément — édition, commit et vérification en parallèle.

Compétences et plugins. OpenCode possède un système de compétences où vous chargez des workflows spécialisés — audits SEO, rédaction, design frontend, revues de sécurité. Les compétences injectent des instructions spécifiques au domaine et un accès aux outils dans les agents. Cela signifie que votre IA ne sait pas seulement « coder » — elle sait faire des audits SEO, rédiger du contenu marketing, ou examiner une interface selon les guidelines d’accessibilité.

Agents en arrière-plan. Vous pouvez lancer des tâches d’exploration en arrière-plan (run_in_background=true) et continuer à travailler. Le système vous notifie à l’arrivée des résultats. Pour les grandes bases de code, c’est transformateur — vous pouvez avoir 5 agents cherchant simultanément dans différentes parties de votre code.

Continuité de session. Chaque session d’agent possède un identifiant de continuation. Si un agent échoue, vous reprenez exactement là où il s’est arrêté avec tout le contexte préservé. Pas besoin de relire les fichiers, pas de répétition de la configuration.

Natif Git. Commits conventionnels, création de PR via gh, gestion de branches — tout est intégré. OpenCode ne fight pas votre workflow git.

Ses faiblesses

Pas de GUI. Si vous voulez des diffs visuels inline, de la coloration syntaxique des changements proposés, ou un arbre de fichiers, vous êtes dans un terminal. C’est parfait pour les développeurs terminaux-native, mais ça peut désorienter si vous êtes habitué à l’expérience IA de VS Code.

Courbe d’apprentissage. Le système d’agents, les catégories (quick, deep, ultrabrain, visual-engineering), les compétences, les MCP et les patterns de délégation prennent du temps à intégrer. Prévoyez 2–3 jours de confusion avant que ça ne clique.

Lourd en configuration. Entre opencode.json, les fichiers de compétences, les définitions d’agents et les configs de serveur MCP, il y a beaucoup de JSON/YAML à gérer. La flexibilité en vaut la peine, mais la configuration initiale n’est pas triviale.

Idéal pour

Les développeurs qui veulent des workflows multi-agents autonomes et vivent dans le terminal. Si vous travaillez sur plusieurs dépôts, jonglez avec des tâches en parallèle, ou voulez une IA capable de se déléguer du travail à elle-même — c’est le seul outil qui le fait.

2. Continue.dev — L’IA dans votre IDE

Continue est une extension pour VS Code et JetBrains qui apporte le chat IA, les modifications inline et l’autocomplétion par tabulation directement dans votre éditeur. Considérez-le comme un GitHub Copilot open source qui fonctionne avec n’importe quel LLM.

Ce qu’il fait bien

Autocomplétion par tabulation. C’est la fonctionnalité la plus forte de Continue. Pendant que vous tapez, Continue suggère des complétions inline — exactement comme Copilot. La différence : vous pouvez le pointer vers n’importe quel modèle (Codestral, DeepSeek, CodeLlama, ou un modèle local via Ollama). L’autocomplétion est rapide, sensible au contexte et s’améliore avec l’usage.

Barre latérale de chat + modifications inline. Sélectionnez du code, appuyez sur un raccourci, et Continue ouvre un chat avec ce code comme contexte. Demandez-lui de refactorer, d’expliquer ou d’écrire des tests. La réponse apparaît inline — vous acceptez ou rejetez d’une seule touche. Ce workflow est fluide et ne casse pas votre rythme.

Indexation du code. Continue crée des embeddings de votre base de code pour que l’IA ait un contexte au-delà du simple fichier ouvert. Cela signifie de meilleures réponses sur la façon dont les différentes parties de votre projet s’articulent.

N’importe quel fournisseur. Continue fonctionne avec tous les principaux fournisseurs de LLM et les modèles locaux. Votre config est un ensemble de fichiers JSON (.continue/config.json) que vous pouvez versionner et partager en équipe.

Ses faiblesses

Requiert VS Code ou JetBrains. Continue n’est pas un outil autonome — c’est une extension. Si votre éditeur n’est pas VS Code ou un IDE JetBrains, vous êtes coincé. Cela implique aussi une consommation RAM de niveau Electron.

L’autocomplétion peut être bruyante. Parfois les suggestions sont fausses ou distrayantes. Vous pouvez ajuster le modèle et le contexte, mais trouver le bon équilibre demande des efforts.

Agent unique uniquement. Pas de travail en parallèle, pas de tâches en arrière-plan, pas de délégation d’agent. Continue est une seule IA menant une seule conversation à la fois.

Idéal pour

Les développeurs qui veulent l’IA dans leur IDE existant avec une autocomplétion style Copilot. Si vous vivez déjà dans VS Code et voulez simplement remplacer Copilot par une alternative open source fonctionnant avec n’importe quel modèle — Continue est la réponse.

3. Aider — Le binôme CLI

Aider est un outil en ligne de commande qui vous permet de discuter avec une IA pour modifier du code dans votre dépôt git local. C’est l’outil le plus simple et le plus ciblé de cette liste. Vous lancez aider, lui indiquez quels fichiers modifier, et vous avez une conversation.

Ce qu’il fait bien

Ultra simple à démarrer. Installez avec pip install aider-chat, lancez aider main.py, et commencez à parler. Pas de fichiers de config, pas de système d’agent, pas de plugins. Juste vous et l’IA.

Intégration Git de meilleure qualité. Chaque modification effectuée par Aider est automatiquement commitée avec un message descriptif. Vous voulez annuler ? git reset HEAD~1. C’est un détail que tous les autres outils ratent — Aider le fait bien. L’historique de votre code raconte toujours l’histoire de ce que l’IA a changé.

Carte du dépôt. Aider construit un arbre de votre base de code (fonctions, classes, imports) et l’envoie comme contexte. Cela lui permet de raisonner sur des changements multi-fichiers sans que vous ayez à spécifier manuellement chaque fichier.

Édition multi-fichiers. Aider peut modifier plusieurs fichiers en une seule requête. « Déplace la logique d’authentification de server.ts vers auth.ts et mets à jour tous les imports » — il gère l’ensemble.

Mode architecte. Avant d’effectuer des modifications, vous pouvez demander à Aider de proposer un plan. Examinez le plan, puis demandez-lui de l’exécuter. Ce workflow en deux étapes évite les modifications indésirables.

Ses faiblesses

Agent unique uniquement. Une seule conversation, un seul modèle, une seule tâche à la fois. Pas de travail en parallèle, pas d’agents en arrière-plan, pas de délégation.

Modifications agressives. Aider modifie parfois plus de code que prévu. Les commits git facilitent le retour en arrière, mais la surprise initiale peut être frustrante.

Pas de système de plugins. Ce que vous voyez est ce que vous avez. Il n’y a aucun moyen d’ajouter des workflows spécifiques à un domaine, des compétences ou des outils personnalisés.

Coûts en tokens sur les gros dépôts. La carte du dépôt est utile mais peut consommer beaucoup de tokens sur les grandes bases de code. Surveillez votre utilisation API.

Idéal pour

Les développeurs qui veulent le plus simple binôme IA possible dans le terminal. Si « discussion → code → commit » est votre workflow préféré et que vous n’avez pas besoin d’orchestration multi-agent, Aider est parfait.

4. Zed — L’éditeur rapide avec IA

Zed est un éditeur de code natif en Rust (pas un fork de VS Code) conçu pour la vitesse. Il intègre un panneau IA qui fonctionne avec les modèles Anthropic, OpenAI, Ollama et Google.

Ce qu’il fait bien

Rapide comme l’éclair. Ça ne peut pas être surestimé. Zed s’ouvre instantanément, fait défiler des fichiers de 10 000 lignes sans saccader et utilise ~50 Mo de RAM. Comparé aux ~500 Mo+ de VS Code, la différence est frappante. Si la lenteur d’Electron vous a déjà frustré, Zed est le remède.

Belle expérience d’édition. Curseurs multiples, recherche dans tout le projet, terminal intégré, intégration git — Zé fait bien tous les fondamentaux de l’éditeur. La typographie est nette, les raccourcis sont intuitifs et tout semble natif parce que ça l’est.

Panneau IA intégré. Pas besoin d’extension. Ouvrez le panneau assistant, choisissez votre modèle et discutez. Vous pouvez joindre des fichiers, sélectionner du code pour le contexte et éditer inline directement. L’expérience IA est légère mais fonctionnelle.

Édition collaborative. Édition collaborative en temps réel comme Google Docs. Partagez un lien et vos collaborateurs peuvent modifier le même fichier simultanément. Unique parmi les éditeurs de cette liste.

Ses faiblesses

IA basique. Pas d’agents, pas de workflows multi-étapes, pas de système de compétences. Le panneau IA est un chat — posez une question, obtenez une réponse, appliquez les modifications. C’est tout. Si vous êtes habitué à l’orchestration d’agents d’OpenCode ou au raisonnement multi-fichiers de Cursor, l’IA de Zed semble limitée.

Pas d’autocomplétion inline (encore). Zed travaille sur la complétion par tabulation style Copilot, mais au moment où j’écris ces lignes, elle n’est pas prête pour la production. C’est la plus grande lacune face à Continue ou Void.

Écosystème d’extensions limité. Zed est jeune. Le système d’extensions existe mais compte beaucoup moins d’extensions que VS Code. Vous manquerez certains serveurs de langage, thèmes et outils de niche.

Le support Linux est plus récent. Zed a commencé sur Mac. Le support Linux fonctionne mais présente parfois des cas limites avec Wayland, la saisie IME et certains raccourcis.

Idéal pour

Les développeurs qui veulent un éditeur rapide et natif avec une légère assistance IA. Si vous privilégiez la vitesse d’édition au détriment des fonctionnalités IA, et que vous voulez juste un panneau de chat pour des questions occasionnelles, Zed est idéal.

5. Void — Cursor open source

Void est un fork de VS Code avec des fonctionnalités IA intégrées — autocomplétion, chat et modifications inline. Considérez-le comme Cursor, mais entièrement open source.

Ce qu’il fait bien

Expérience VS Code familière. Puisque Void est un fork de VS Code, tout ce que vous connaissez de VS Code fonctionne. Extensions, paramètres, raccourcis, thèmes — tout est conservé. La courbe d’apprentissage est nulle si vous êtes utilisateur de VS Code.

IA intégrée, pas besoin d’extension. Void est livré avec autocomplétion, chat et édition inline. Pas besoin d’installer Continue ou Copilot — ça fonctionne dès le départ.

Orienté confidentialité. Void est conçu pour être local-first. Les données restent sur votre machine par défaut. C’est une différence significative par rapport à Cursor, qui envoie de la télémétrie.

Open source. Base de code entièrement auditable. Vous pouvez voir exactement ce qui arrive à votre code et à vos données.

Ses faiblesses

En retard sur Cursor en fonctionnalités. Cursor dispose d’un mode agent, d’un raisonnement multi-fichiers, d’une sélection automatique de contexte et d’une polish qui vient d’une équipe bien financée. Void manque la plupart de ces éléments. C’est un fork solide de VS Code avec une IA basique, pas un clone de Cursor.

Petite communauté. Moins de contributeurs, moins de mises à jour, moins de tests sur les cas limites. Si vous rencontrez un bug, vous pourriez être livré à vous-même.

Bagage Electron. Puisque c’est un fork de VS Code, il hérite de tous les défauts d’Electron — forte consommation RAM, démarrage plus lent, sensation non-native sur macOS.

Documentation légère. Démarrer est facile, mais configurer des workflows avancés ou résoudre des problèmes nécessite de fouiller dans les issues GitHub.

Idéal pour

Les développeurs qui veulent une alternative open source à Cursor sans abonnement. Si vous aimez l’expérience IA de VS Code mais que vous la voulez open source et respectueuse de la vie privée, Void est la correspondance la plus proche.

Matrice de comparaison

La configuration que je recommande : OpenCode + routage multi-fournisseur

Après des mois de tests, voici la configuration qui vous donne une capacité IA maximale à un coût minimal. La stratégie : utiliser le modèle le moins cher capable de gérer la tâche, réserver les modèles onéreux aux problèmes difficiles.

Mix de fournisseurs

┌─────────────────────────────────────────────────────┐
│                 MIX DE FOURNISSEURS                   │
│                                                      │
│  ┌─────────────┐  ┌──────────┐  ┌───────────────┐  │
│  │  Anthropic   │  │ Mistral  │  │  Ollama (local)│  │
│  │  (budget min)│  │ (quotidien)│ │  (gratuit/offline)│
│  └──────┬──────┘  └────┬─────┘  └───────┬───────┘  │
│         │              │                │           │
│  Claude Sonnet    Mistral Large    DeepSeek-Coder   │
│  (complexe seul)  Codestral        Qwen 2.5 Coder  │
│                   (daily driver)    (offline)       │
└─────────────────────────────────────────────────────┘

opencode.json complet

{
  "provider": {
    "anthropic": {
      "apiKey": "sk-ant-YOUR_KEY",
      "models": {
        "claude-sonnet-4-20250514": {
          "thinking": true,
          "contextWindow": 200000
        }
      }
    },
    "mistral": {
      "apiKey": "YOUR_MISTRAL_KEY",
      "models": {
        "mistral-large-latest": {},
        "mistral-medium-latest": {},
        "codestral-latest": {}
      }
    },
    "ollama": {
      "models": {
        "deepseek-coder-v2:16b": {},
        "qwen2.5-coder:7b": {}
      }
    }
  },
  "agents": {
    "atlas": {
      "model": "anthropic:claude-sonnet-4-20250514"
    },
    "quick": {
      "model": "mistral:codestral-latest"
    },
    "writing": {
      "model": "mistral:mistral-large-latest"
    },
    "visual-engineering": {
      "model": "mistral:mistral-large-latest"
    },
    "deep": {
      "model": "anthropic:claude-sonnet-4-20250514"
    },
    "ultrabrain": {
      "model": "anthropic:claude-sonnet-4-20250514"
    },
    "unspecified-low": {
      "model": "mistral:codestral-latest"
    },
    "unspecified-high": {
      "model": "mistral:mistral-large-latest"
    },
    "explore": {
      "model": "mistral:codestral-latest"
    },
    "librarian": {
      "model": "mistral:mistral-large-latest"
    },
    "oracle": {
      "model": "anthropic:claude-sonnet-4-20250514"
    }
  }
}

Quand utiliser quoi

Règles d’optimisation des coûts

1. Mistral est votre outil quotidien — routez 80 % des tâches vers lui.
2. Anthropic uniquement pour l’orchestration, les décisions d’architecture et les bugs coriaces que Mistral ne peut pas résoudre.
3. Ollama en secours — quand vous atteignez les limites de taux, voulez de la confidentialité ou êtes hors ligne.
4. Utilisez category="quick" dans OpenCode — cela route automatiquement vers le modèle le moins cher.
5. Évitez ultrabrain/deep sauf nécessité — ceux-ci consomment toujours vos crédits les plus chers.

Passer 100 % local : configuration Ollama

Si vous voulez du codage IA sans aucune dépendance cloud — pour la confidentialité, le coût ou le travail hors ligne — Ollama exécute des modèles localement sur votre machine.

Configuration matérielle requise

Recommandation : 16 Go de RAM est le sweet spot. DeepSeek Coder V2 à 16 milliards de paramètres vous offre une assistance de code de qualité production en local. Si vous avez 8 Go de RAM, utilisez Qwen 2.5 Coder 7B.

Installation

macOS :

brew install ollama

Arch Linux :

yay -S ollama

Télécharger et exécuter des modèles

# Démarrer le serveur Ollama
ollama serve

# Télécharger les modèles souhaités
ollama pull deepseek-coder-v2:16b
ollama pull qwen2.5-coder:7b
ollama pull llama3.1:8b

# Tester
ollama run deepseek-coder-v2:16b "Write a Python function that validates email addresses"

Configurer Ollama comme service systemd (Arch)

# Créer un service systemd utilisateur
mkdir -p ~/.config/systemd/user

cat > ~/.config/systemd/user/ollama.service << 'EOF'
[Unit]
Description=Ollama AI Server
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/ollama serve
Restart=always
RestartSec=3

[Install]
WantedBy=default.target
EOF

# Activer et démarrer
systemctl --user daemon-reload
systemctl --user enable --now ollama

Utiliser les modèles locaux avec chaque outil

Démarrage rapide : commandes d’installation Arch Linux

# OpenCode
yay -S opencode

# Aider (Python)
pip install aider-chat

# Zed
yay -S zed-editor

# Continue (dans VS Code)
code --install-extension continue.continue

# Void
yay -S void-editor

# Ollama (modèles locaux)
yay -S ollama
ollama pull deepseek-coder-v2:16b

Guide de décision

Vous voulez…

Une autonomie IA maximale avec des workflows multi-agents : → OpenCode. Rien d’autre ne fait de la délégation d’agents en parallèle, l’injection de compétences et les tâches en arrière-plan. Si vous travaillez sur plusieurs dépôts et voulez que l’IA gère des workflows entiers (pas seulement modifier des fichiers), c’est ça.

L’IA dans votre IDE existant avec autocomplétion par tabulation : → Continue.dev. Autocomplétion de qualité Copilot, fonctionne avec n’importe quel modèle, vit dans VS Code ou JetBrains. L’intégration IDE la plus fluide de cette liste.

Le plus simple en terminal IA — modifier, commit, c’est fait : → Aider. pip install, aider file.py, discuter. Chaque modification est un commit git. Zéro config. Concentration maximale.

L’éditeur le plus rapide avec une IA légère : → Zed. Vitesse native Rust, édition magnifique, panneau IA intégré. Pour les développeurs qui privilégient les performances de l’éditeur aux fonctionnalités IA.

Cursor open source sans l’abonnement : → Void. Fork de VS Code avec IA intégrée, orienté confidentialité, zéro config. La transition la plus facile si vous venez de Cursor.

100 % local, zéro cloud : → OpenCode ou Aider + Ollama. Codage IA hors ligne complet sans clés API, sans données quittant votre machine.

En conclusion

Il n’y a pas d’outil unique « meilleur ». Le bon choix dépend de votre workflow :

• Si vous voulez que l’IA travaille pour vous de manière autonome sur plusieurs projets — OpenCode.
• Si vous voulez Copilot dans votre IDE avec vos propres modèles — Continue.
• Si vous voulez du codage IA simple, rapide et intégré à git — Aider.
• Si vous voulez un éditeur ultra-rapide avec une aide IA occasionnelle — Zed.
• Si vous voulez Cursor sans l’abonnement — Void.

Ma configuration : OpenCode pour l’orchestration (les workflows multi-agents sont inégalés), Aider pour les modifications ponctuelles rapides (l’intégration git est parfaite) et Ollama pour le codage hors ligne (gratuit, privé, tourne sur mon laptop). Trois outils, trois cas d’usage, zéro abonnement.