Kimi Code : l'armée de développeurs — Guide complet

Par la rédaction iatoi -- 25 juillet 2026

Il y a un an, personne n'aurait misé un kopek sur Moonshot AI. Une boîte chinoise inconnue du grand public, un CLI en TypeScript, et la promesse de faire mieux que Claude Code pour trois fois moins cher. On a ricané. Puis K3 est sorti avec ses 2 800 milliards de paramètres. On ricane moins.

Kimi Code n'est pas un énième wrapper autour de l'API OpenAI. C'est un agent de codage en terminal qui tourne sur son propre modèle open-weight, accepte d'autres providers si vous insistez, et peut lancer jusqu'à 300 sous-agents en parallèle quand l'envie vous prend de vivre dangereusement. Le tout sous licence MIT.

Voici comment le dompter.

1. Positionnement : pourquoi Kimi Code, et pas Claude Code ou Codex ?

Le paysage des coding agents en 2026 ressemble à un oligopole mal dégrossi. D'un côté, Claude Code (Anthropic) : excellent, mais propriétaire, mono-provider, et facturé $20-$200/mois avec des modèles fermés. De l'autre, Codex (OpenAI) : puissant, intégré à GitHub, mais tout aussi verrouillé.

Kimi Code joue une partition différente :

Open-source (MIT). Vous pouvez forker, modifier, redistribuer. Pas de boîte noire.
Modèles open-weight. K3 (2.8T params, 1M tokens de contexte) sera intégralement publié le 27 juillet 2026. K2.7 Code (1T params, 32B activés) est déjà disponible sur Hugging Face.
Multi-provider. Le CLI accepte Anthropic, OpenAI, Google, DeepSeek. Si Moonshot décide de vous facturer votre rein gauche, vous migrez en changeant une ligne de config.
Agent Swarm. Jusqu'à 300 agents parallèles. Personne d'autre ne fait ça.
Prix agressif. Gratuit (Adagio) à $199/mois (Vivace). En API, K3 coûte $3/M input contre $10/M pour Claude Fable 5.

Le revers de la médaille : Moonshot est chinois, la confidentialité locale n'est pas le défaut, et le support client a la réactivité d'un paresseux sous sédatif. On y reviendra.

2. Installation : Linux, macOS, Windows

Linux et macOS

Le script officiel fait tout le sale boulot :

bash

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

Pas besoin de Node.js préinstallé. Le script télécharge la dernière release, vérifie le checksum, et place kimi dans votre PATH. Si vous préférez npm :

bash

node --version  # minimum 22.19.0
npm install -g @moonshot-ai/kimi-code

Vérification :

bash

kimi --version

Windows

PowerShell, une commande :

powershell

irm https://code.kimi.com/kimi-code/install.ps1 | iex

Attention : Kimi Code sous Windows exige Git Bash. Sans lui, rien ne marche. Si Git Bash est installé ailleurs que dans C:\Program Files\Git\bin\bash.exe, définissez :

powershell

$env:KIMI_SHELL_PATH = "D:\tools\git\bin\bash.exe"

Premier lancement

bash

cd votre-projet
kimi            # mode TUI interactif
kimi -p "Explique l'architecture de ce projet"  # mode one-shot
kimi -c         # reprend la session précédente

Au premier lancement, /login propose deux options : OAuth (device-code flow) ou clé API depuis platform.kimi.com. Choisissez selon votre plan.

Désinstallation

bash

npm uninstall -g @moonshot-ai/kimi-code

3. Configuration globale optimale

Tout vit dans ~/.kimi-code/ (déplaçable via KIMI_CODE_HOME). Le fichier central est config.toml.

config.toml commenté

toml

# --- Providers ---
[providers.kimi]
type = "kimi"
base_url = "https://api.moonshot.ai/v1"
api_key = "sk-xxxxx"

[providers.anthropic]
type = "anthropic"
api_key = "sk-ant-xxxxx"

[providers.openai]
type = "openai"
base_url = "https://api.openai.com/v1"
api_key = "sk-xxxxx"

# --- Modèles ---
[models."kimi-k3"]
provider = "kimi"
model = "kimi-k3"
max_context_size = 1048576

[models."kimi-k2.7-code"]
provider = "kimi"
model = "kimi-k2.7-code"
max_context_size = 262144

[models."claude-fable-5"]
provider = "anthropic"
model = "claude-fable-5"
max_context_size = 200000

# --- Dossiers d'agents supplémentaires ---
extra_agent_dirs = ["~/team-agents"]

# --- Hooks globaux ---
[[hooks]]
event = "PreToolUse"
matcher = "Bash"
command = "node ./hooks/check-bash.mjs"
timeout = 5

Variables d'environnement essentielles

Variable	Rôle
`KIMI_CODE_HOME`	Répertoire des données (défaut : `~/.kimi-code/`)
`KIMI_SHELL_PATH`	Chemin bash.exe (Windows uniquement)
`KIMI_API_KEY`	Clé API Kimi
`ANTHROPIC_API_KEY`	Clé API Anthropic (si provider externe)
`OPENAI_API_KEY`	Clé API OpenAI
`KIMI_CODE_EXPERIMENTAL_FLAG`	Active agents customs et SYSTEM.md
`KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL`	Active le modèle secondaire pour sous-agents

Les deux dernières sont critiques pour la section agents ci-dessous. Activez-les.

4. Skills : le couteau suisse sans la prise de tête

Un Skill est un document Markdown avec frontmatter YAML. Pas de code exécutable, pas de sandbox : juste des instructions que l'agent lit et applique.

Créer son premier skill

Créez ~/.kimi-code/skills/code-style/SKILL.md (format répertoire, recommandé) :

markdown

---
name: code-style
description: Guide de style de code du projet
type: prompt
whenToUse: Quand l'utilisateur demande d'écrire ou modifier du code
---

Utilisez les conventions suivantes :
- Indentation 2 espaces
- camelCase pour les variables, PascalCase pour les types
- Documentation TSDoc obligatoire sur les fonctions publiques
- Pas de `any` sans justification explicite

Le skill est découvert automatiquement au démarrage. Le modèle l'invoque quand whenToUse matche, ou vous le forcez avec /skill:code-style.

Bonnes pratiques

Format répertoire > format fichier plat. Ça permet d'ajouter des fichiers supports (références, exemples).
`whenToUse` précis. Pas « pour le code », mais « quand l'utilisateur modifie un fichier TypeScript dans /src/backend ».
Skills projet vs utilisateur. Mettez les skills dans .kimi-code/skills/ (projet) quand ils sont spécifiques à une codebase, dans ~/.kimi-code/skills/ quand ils sont transverses.
Ne pas abuser. Un skill de 30 pages qui liste toutes vos préférences personnelles, c'est un system prompt déguisé. Pour ça, il y a SYSTEM.md.

5. Plugins : quand les skills ne suffisent plus

Les plugins packagent skills, commandes slash, serveurs MCP et hooks dans une unité installable. Gestion via /plugins dans le TUI (4 onglets : Installed, Official, Third-party, Custom).

Installation

bash

/plugins                          # interface interactive
/plugins install https://github.com/user/mon-plugin
/plugins marketplace [source]     # catalogue marketplace
/plugins enable/disable <id>      # activer/désactiver

Le plugin Kimi Datasource

Le seul plugin officiel notable (v3.3.0 à ce jour). Données financières (Wind, S&P Capital IQ), macroéconomiques (IMF, World Bank), légales (SEC EDGAR) et académiques. Facturé par appel, crédits Kimi Code. Read-only -- vous n'achèterez pas d'actions par erreur.

Écrire un plugin

Un plugin est un dépôt avec kimi.plugin.json :

json

{
  "name": "kimi-finance",
  "version": "1.0.0",
  "description": "Finance data for Kimi Code",
  "skills": "./skills/",
  "mcpServers": {
    "finance": {
      "command": "uvx",
      "args": ["kimi-finance-mcp"]
    }
  },
  "hooks": [
    {
      "event": "PreToolUse",
      "matcher": "Bash",
      "command": "node ./hooks/check-bash.mjs",
      "timeout": 5
    }
  ],
  "commands": "./commands/"
}

Les commandes slash sont des fichiers Markdown avec frontmatter :

markdown

---
description: Résumé financier d'une action
---
Pull les données financières de $ARGUMENTS et résume.

Usage : /kimi-finance:report TSLA. $ARGUMENTS est remplacé automatiquement.

Sécurité

Badge de confiance : kimi-official, curated, third-party
Installation third-party demande confirmation explicite
Chemins confinés au répertoire racine du plugin
MCP démarre au reload ou nouvelle session, désactivable

6. Agents : l'armée de développeurs

Chaque session Kimi Code est pilotée par un agent principal. Il planifie, appelle des outils, et délègue à des sous-agents. Voici comment transformer cette mécanique en usine à code.

Les trois mousquetaires natifs

Agent	Rôle	Capacités
`coder`	Développement général	Lecture/écriture, shell, recherche, todo, sous-agents imbriqués
`explore`	Exploration de codebase	Read-only uniquement -- cartographie sans rien casser
`plan`	Planification	Aucune commande shell -- purement « comment faire »

Ces trois-là sont dispatchés automatiquement selon la complexité de la tâche. Chaque dispatch apparaît comme une demande d'approbation (sauf YOLO mode), et chaque sous-agent a son propre contexte isolé -- il ne voit que la description de tâche passée par l'agent principal.

Créer des agents customs

Le vrai pouvoir est dans les agents sur mesure. Fichier Markdown, frontmatter YAML, déposé dans un des emplacements de découverte.

Emplacements (par priorité) :

--agent-file (explicite, priorité maximale)
.kimi-code/agents/ (projet)
$KIMI_CODE_HOME/agents/ (utilisateur)
extra_agent_dirs dans config.toml

Agent principal custom : le chef d'orchestre K3

markdown

---
name: lead-dev
description: Développeur principal, supervise les sous-agents
whenToUse: Pour toute tâche de développement complexe
model_preference: primary
tools:
  - Read
  - Write
  - Edit
  - Bash
  - Grep
  - Glob
  - Task
  - TodoWrite
subagents:
  - coder
  - explore
  - plan
  - reviewer
  - tester
---

Tu es le développeur principal du projet. Tu supervises une équipe
d'agents spécialisés. Pour chaque tâche complexe :

1. Utilise l'agent `plan` pour concevoir l'approche
2. Délègue l'implémentation à `coder`
3. Fais réviser par `reviewer`
4. Lance les tests via `tester`

Ne code pas tout toi-même -- ton job est d'orchestrer.

Pour l'activer :

bash

KIMI_CODE_EXPERIMENTAL_FLAG=1 kimi -p --agent lead-dev "Implémente l'authentification"

Agents secondaires légers : le modèle économique

C'est ici que K2.7 Code brille. Grâce à model_preference: secondary, vous assignez un modèle moins cher aux sous-agents :

markdown

---
name: reviewer
description: Réviseur de code strict
whenToUse: Pour les code reviews et vérifications de PR
model_preference: secondary
tools:
  - Read
  - Grep
  - Glob
disallowedTools:
  - Bash
---

Tu es un réviseur de code strict. Lis le diff, puis rapporte
les problèmes groupés par sévérité (critical, major, minor).

Dans config.toml, définissez le modèle secondaire :

toml

[models."kimi-k2.7-code"]
provider = "kimi"
model = "kimi-k2.7-code"
max_context_size = 262144

# Ce modèle sera utilisé par les agents avec model_preference: secondary
secondary_model = "kimi-k2.7-code"

Lancez avec la variable d'environnement :

bash

KIMI_CODE_EXPERIMENTAL_FLAG=1 KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL=1 kimi

Résultat : l'agent principal (lead-dev) tourne sur K3 pour la réflexion stratégique, les sous-agents (reviewer, tester) tournent sur K2.7 Code pour le travail mécanique. Votre quota de tokens vous remercie.

SYSTEM.md : le system prompt permanent

Fichier $KIMI_CODE_HOME/SYSTEM.md. Supporte les placeholders :

plaintext

${skills}       -- liste des skills disponibles
${agents_md}    -- liste des agents customs
${cwd}          -- répertoire courant
${os}           -- système d'exploitation
${shell}        -- shell utilisé
${now}          -- date/heure actuelle
${base_prompt}  -- prompt de base Kimi Code

Exemple minimal :

markdown

${base_prompt}

Règles absolues du projet :
- Jamais de `console.log` dans le code de production.
- Toute fonction exportée doit avoir un test unitaire.
- Les commits suivent Conventional Commits.

${skills}
${agents_md}

Limitation : SYSTEM.md est ignoré dans le TUI interactif. Il ne fonctionne qu'en mode kimi -p.

Agent Swarm : 300 agents, un terminal

Le Swarm (K2.5+) est le système de collaboration à grande échelle. Jusqu'à 300 agents parallèles spawnés dynamiquement pour des tâches massives : recherche web, analyse de documents, agrégation de résultats.

Quotas :

Adagio (gratuit) : limité
Moderato ($19/mois) : 50 utilisations, 4 agents
Allegro ($99/mois) : 5x quota agents
Vivace ($199/mois) : quota maximal

Cas d'usage : exploration d'une codebase inconnue avec 50 agents explore en parallèle, chacun assigné à un module différent. Résultats fusionnés automatiquement. Le même travail prendrait une heure en série ; ici, trois minutes.

7. Workflow de développement optimal

Concrètement, voici comment organiser votre équipe d'agents :

Tâche	Agent principal	Sous-agents	Modèle head	Modèle secondaire
Nouvelle feature	`lead-dev`	`plan`, `coder`, `reviewer`, `tester`	K3	K2.7 Code
Exploration codebase	`explore`	`explore` × 10 (modules)	K3	K2.7 Code
Revue de PR	`reviewer`	--	K3	--
Refactoring	`lead-dev`	`explore` (audit), `coder` (refacto), `tester` (non-régression)	K3	K2.7 Code
Recherche + rapport	`plan` + Swarm	Agents de recherche web	K3	K2.7 Code
Bug hunting	`lead-dev`	`explore` (tracer), `coder` (fix), `reviewer` (vérif)	K3	K2.7 Code

Règle d'or : K3 pour tout ce qui demande de la réflexion (architecture, planification, décisions). K2.7 Code pour le code pur, les revues, les tests. L'écart de prix n'est pas négligeable sur une session de 5 heures.

Commande type pour un workflow complet

bash

KIMI_CODE_EXPERIMENTAL_FLAG=1 \
KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL=1 \
kimi -p --agent lead-dev \
  "Implémente le système d'authentification OAuth2 avec Google et GitHub.
   Planifie d'abord, puis code, puis fais réviser, puis teste."

L'agent principal orchestre tout : planification, dispatch aux sous-agents, révision, tests. Vous, vous allez prendre un café.

8. Modèles recommandés : le tableau comparatif

Modèle	Params	Contexte	Usage recommandé	Prix API (input/output)
Kimi K3	2 800B (MoE, 896 experts)	1M tokens	Agent principal, architecture, raisonnement	$3 / $15 par M tokens
Kimi K2.7 Code	1 000B (MoE, 32B actifs)	256K tokens	Agents secondaires, code, review, tests	Inférieur à K3
K2.7 Highspeed	Identique K2.7	256K	Tâches simples, haute fréquence	Inférieur à K2.7
K2.6 (legacy)	~1T (32B actifs)	256K	Fallback, gratuit en Chat	--

Verdict : Un binôme K3 (principal) + K2.7 Code (secondaire) couvre 95% des besoins. K2.7 Code suffit même en agent principal pour des tâches purement coding sans raisonnement complexe.

Les alternatives légères (DeepSeek V4, Qwen3-Coder-480B) peuvent être utilisées comme provider externe pour les sous-agents si vous voulez réduire encore la facture, mais vous perdez l'intégration native et les optimisations Moonshot.

9. Pièges et astuces

Ce qui va vous mordre

Le billing opaque. Des utilisateurs rapportent avoir vidé un mois de crédits Allegro ($99) en une semaine d'utilisation modérée. Les crédits disparaissent sans transparence. Vérifiez votre consommation toutes les deux sessions.

Windows = Git Bash obligatoire. Pas de PowerShell natif, pas de cmd. Si Git Bash n'est pas dans le PATH standard, c'est KIMI_SHELL_PATH ou rien.

Expérimental != stable. --agent, --agent-file, SYSTEM.md et model_preference sont derrière KIMI_CODE_EXPERIMENTAL_FLAG=1. Ils fonctionnent en kimi -p mais PAS dans le TUI. Ne vous attendez pas à ce que tout marche en interactif.

Pas de fallback automatique sur variables d'environnement. Vos clés API doivent être dans config.toml ou passées via /login. Exporter KIMI_API_KEY ne suffira pas si vous n'avez pas déclaré le provider.

Plugins per-user uniquement. Pas de scope projet. Si votre équipe utilise un plugin, chacun doit l'installer séparément.

Confidentialité. Tout passe par le cloud Moonshot par défaut. Si vous bossez sur du code sensible soumis au RGPD, configurez un provider local (Ollama, llama.cpp) en fallback.

Le support. « Horrendous support » est le terme exact utilisé sur le forum officiel. Acceptez l'idée que vous serez votre propre support.

Ce qui va vous sauver

Le mode print (`kimi -p`). Pour le CI/CD, les scripts, les commits hooks. Pas d'interface, juste du texte.

Fork de session. Une session qui part en vrille ? Forkez-la avant le point de rupture et continuez sur une branche propre.

Permissions granulaires. Activez le mode Plan (lecture seule pour la planification) avant de laisser l'agent toucher au code de production.

Modèle gratuit en Chat. K2.6 ne consomme pas de crédits quand vous l'utilisez dans le Chat Kimi. Pour explorer une codebase sans pression, c'est le bon plan.

Multi-provider. Si Moonshot a un outage ou que vos crédits sont à sec, basculez sur Anthropic ou OpenAI en changeant le modèle actif. /model dans le TUI, ou provider dans config.toml.

En bref

Kimi Code est le coding agent le plus agressif du marché en 2026. Gratuit en entrée de gamme, open-source, multi-provider, avec un modèle open-weight de 2 800 milliards de paramètres et une capacité à lancer 300 agents en parallèle. Les alternatives propriétaires (Claude Code, Codex) n'ont tout simplement pas cette flexibilité.

Le prix à payer : une documentation parfois en chantier, un support qui répond quand il répond, et un écosystème encore jeune côté plugins.

Si vous êtes développeur solo ou petite équipe prête à mettre les mains dans le cambouis, commencez avec Adagio (gratuit) + K3 en API OpenRouter. Si le multi-agent vous botte, passez sur Allegro ($99/mois) pour les quotas étendus. Dans tous les cas, configurez K2.7 Code comme modèle secondaire pour vos sous-agents -- votre facture vous remerciera.

Sources : documentation officielle kimi.com, dépôt GitHub MoonshotAI/kimi-code, OpenRouter, BenchLM, Artificial Analysis, NanoGPT, Decrypt, UsageBox, forums Moonshot. Données vérifiées le 25 juillet 2026.

Télécharger la configuration complète

La configuration ultime présentée dans ce tutoriel est disponible sur GitHub. Clonez le dépôt et copiez les fichiers dans votre projet :

bash

git clone https://github.com/HeRrKrUgEr/kimi-code-ultimate-config.git
cp -r kimi-code-ultimate-config/* .kimi/

Le dépôt contient :

config.toml — providers Kimi K3 + K2.7 Code + Haiku 4.5
agents/ — 4 agents prêts à l'emploi (architect, coder, reviewer, tester)
skills/ — 4 skills (code-review, test-generator, doc-writer, refactor)
README.md — documentation complète