---
title: "Manuel de Bonnes Pratiques de Vibe Coding avec VS Code, Codex et GitHub"
summary: "Un guide pratique pour conduire des projets avec des agents d'IA, AGENTS.md, planification incrémentale, validations et Git."
slug: "manuel-bonnes-pratiques-vibe-coding"
language: "fr"
publishedAt: "2026-05-20"
updatedAt: null
tags:
  - "guide"
  - "vscode"
  - "codex"
  - "github"
translationOf: "pt/manual-boas-praticas-vibe-coding"
translationStatus: "current"
---

Le vibe coding n'est pas demander du code et espérer.

C'est monter un environnement où un agent rapide peut travailler avec contexte, limites et validation.

## 1. La bonne mentalité

La pire manière de commencer est de demander quelque chose de générique :

```txt
Crée une app de finances.
```

La meilleure manière est de diriger le travail :

```txt
Lis AGENTS.md et PLANS.md.
Implémente seulement la première étape.
Avant d'éditer, dis quels fichiers tu comptes modifier.
Ensuite lance lint, tests et build.
```

L'agent a besoin de :

- contexte du projet ;
- règles claires ;
- critères de prêt ;
- commandes de validation ;
- limites de ce qu'il ne peut pas faire ;
- historique versionné dans Git.

Le `AGENTS.md` fonctionne comme un fichier d'instructions pour agents d'IA.

Il ressemble à un `README.md`, mais il indique comment l'agent doit naviguer, modifier, tester et documenter le projet.

## 2. Structure recommandée

Une structure initiale simple :

```txt
mon-projet/
├── AGENTS.md
├── README.md
├── PLANS.md
├── CHANGELOG.md
├── .gitignore
├── .env.example
├── explorationduprojet/
│   ├── idee.md
│   ├── references.md
│   ├── exigences.md
│   └── contraintes.md
├── docs/
│   ├── architecture.md
│   ├── base-de-donnees.md
│   └── backlog.md
├── src/
├── tests/
└── .vscode/
    ├── settings.json
    ├── tasks.json
    └── extensions.json
```

Cette division sépare trois couches :

- `AGENTS.md` : règles permanentes pour l'agent.
- `explorationduprojet/` : matériel brut d'idée, de référence et de contrainte.
- `docs/` : documentation propre, consolidée et révisable.

## 3. Flux recommandé

### Phase 0 : préparer le dépôt

Avant de demander une implémentation, créez la base :

```txt
AGENTS.md
README.md
PLANS.md
explorationduprojet/
docs/
.vscode/
```

Initialisez Git :

```bash
git init
git add .
git commit -m "chore: structure initiale du projet"
```

### Phase 1 : exploration

Ne demandez pas encore de code.

Demandez à l'agent :

```txt
Lis explorationduprojet/.
Comprends l'idée.
Produis un résumé critique avec périmètre, risques, questions et suggestions.
N'implémente rien.
```

Résultat attendu :

```txt
docs/vue-generale.md
docs/exigences.md
docs/risques.md
docs/decisions-initiales.md
```

### Phase 2 : planification

Ensuite, dans une nouvelle tâche :

```txt
À partir de AGENTS.md, README.md et des documents dans docs/,
crée un plan d'implémentation incrémental dans PLANS.md.
Ne modifie pas encore le code.
```

### Phase 3 : implémentation incrémentale

Maintenant oui :

```txt
Implémente seulement l'étape 1 de PLANS.md.
Avant d'éditer, explique quels fichiers tu comptes modifier.
Ensuite implémente, lance les validations et mets la documentation à jour si nécessaire.
```

La règle d'or est une étape à la fois.

Évitez :

```txt
Crée tout le système.
```

Préférez :

```txt
Implémente une authentification locale simple.
Maintenant implémente le CRUD de clients.
Maintenant ajoute des tests.
Maintenant refactore la couche de services.
```

### Phase 4 : validation

À chaque étape, demandez :

```txt
1. Lance lint.
2. Lance les tests.
3. Lance le build.
4. Liste les fichiers modifiés.
5. Explique les risques restants.
6. Suggère le prochain commit.
```

### Phase 5 : commit et synchronisation

Seulement après validation :

```bash
git status
git add .
git commit -m "feat: implementa cadastro de clientes"
git push origin main
```

## 4. Modèle de AGENTS.md

```md
# AGENTS.md

## Objectif du projet

Ce projet a pour objectif de construire une application [décrivez ici l'idée centrale].

L'agent doit aider au développement incrémental, en privilégiant clarté, sécurité, testabilité et simplicité.

## Comment travailler dans ce projet

Avant d'implémenter quoi que ce soit :

1. Lis ce AGENTS.md.
2. Lis le README.md.
3. Lis les fichiers pertinents dans docs/.
4. Consulte PLANS.md s'il existe.
5. Fais un bref plan avant de modifier des fichiers.

## Règles d'implémentation

- Travaille par petites étapes.
- Préfère un code simple, lisible et testable.
- Évite les abstractions prématurées.
- Ne remplace pas les changements manuels de l'utilisateur.
- Mets la documentation à jour quand le comportement change.

## Critères de prêt

Une tâche n'est prête que quand :

1. le code a été implémenté ;
2. les tests pertinents ont été créés ou mis à jour ;
3. les validations ont été exécutées ou justifiées ;
4. les docs ont été mises à jour si nécessaire ;
5. les risques ou pendances ont été listés.
```

## 5. Prompts utiles

### Exploration

```txt
Lis AGENTS.md et tous les fichiers dans explorationduprojet/.
N'implémente rien.

Produis :
1. résumé de l'idée ;
2. exigences fonctionnelles ;
3. exigences non fonctionnelles ;
4. risques techniques ;
5. questions importantes ;
6. suggestion de stack ;
7. périmètre suggéré pour le MVP.
```

### Planification

```txt
À partir de AGENTS.md, README.md et docs/,
crée un plan incrémental dans PLANS.md.

Le plan doit diviser le projet en étapes petites, testables et committables.
Ne modifie pas encore le code source.
```