Tutoriel de Vibe Coding pour débutants

Vibe Coding est un tout nouveau paradigme de programmation : au lieu d'écrire du code ligne par ligne, vous décrivez ce que vous voulez en langage naturel ; l'IA écrit le code, et nous sommes responsables de la relecture et de l'orientation de la direction.

Référence du tutoriel Vibe Coding :https://www.example.com/vibe-coding/vibe-coding-tutorial.html


Qu'est-ce que le Vibe Coding

Vibe CodingLe terme a été inventé pour la première fois par Andrej Karpathy, ancien directeur de l'IA chez Tesla et cofondateur d'OpenAI, en février 2025.

Il a résumé cette toute nouvelle approche de programmation en une phrase :

「Je vibre, c'est tout. Parfois, je ne touche même pas au clavier. Je parle simplement à l'IA, elle écrit le code, je le relis, et nous itérons.」

En d'autres termes : vous décrivez simplement votre « vibe », l'IA écrit le code, vous le relisez, puis vous itérez en aller-retour.

En termes simples, le Vibe Coding consiste à : vous dites à l'IA en langage naturel quelle fonctionnalité vous voulez, et l'IA écrit le code pour vous. Pas besoin de vous soucier des détails de syntaxe, pas besoin de mémoriser les paramètres d'API, pas besoin de déboguer manuellement chaque erreur — l'IA s'occupe de tout cela.

Notre rôle passe de « la personne qui écrit le code » à « la personne qui décrit les exigences » — ou plutôt, de programmeur à chef de produit + architecte.

Le Vibe Coding ne consiste pas à laisser l'IA remplacer votre réflexion ; il consiste à laisser l'IA gérer le travail répétitif à faible valeur, vous permettant de vous concentrer sur les parties plus créatives : comprendre les problèmes, concevoir l'architecture et vérifier les résultats.


Vibe Coding vs Programmation traditionnelle

Comprendre les différences entre le Vibe Coding et les approches de programmation traditionnelles vous aide à mieux l'utiliser.

Dimension Programmation traditionnelle Vibe Coding
Méthode de saisie Écrire le code ligne par ligne manuellement Décrire les exigences en langage naturel
Focus Syntaxe, API, détails d'implémentation Exigences, architecture, vérification
Méthode de débogage Débogage manuel par points d'arrêt/journaux Envoyer les messages d'erreur à l'IA et la laisser les corriger
Vitesse Dépend de la vitesse de frappe et du niveau de compétence Dépend de la clarté des descriptions des exigences
Scénarios applicables Toutes les tâches de programmation Développement de prototypes, CRUD, outils de script, pages UI
Compétences clés Maîtrise des langages de programmation Décomposition des exigences + capacité de vérification des résultats

Pourquoi le Vibe Coding est possible aujourd'hui

Le Vibe Coding est devenu possible en 2025 parce que plusieurs conditions clés sont arrivées à maturité.

Le bond des capacités de codage des grands modèles

Des modèles comme GPT-5.5, Claude 5 et Gemini ont considérablement amélioré la précision de la génération de code.

Ils peuvent non seulement écrire du code syntaxiquement correct, mais aussi comprendre le contexte du projet, suivre les bonnes pratiques et gérer les cas limites.

Plus important encore, ils peuvent gérer des contextes extrêmement longs — lire un projet entier d'un seul coup et comprendre la structure de votre base de code.

L'explosion des outils de programmation IA

Des outils comme Cursor, Claude Code, GitHub Copilot et Windsurf ont profondément intégré les capacités de l'IA dans le flux de travail de développement.

Ces outils peuvent non seulement compléter du code, mais aussi modifier directement des fichiers, exécuter des commandes de terminal et rechercher dans la base de code — en travaillant comme un vrai développeur.

L'émergence du mode Agent

Les outils en mode Agent peuvent exécuter de manière autonome des tâches à plusieurs étapes : lire des fichiers, écrire du code, exécuter des tests et corriger les erreurs en fonction des résultats des tests.

Il vous suffit de donner une instruction initiale, et l'Agent bouclera et itérera de lui-même jusqu'à ce que la tâche soit terminée.


Introduction aux outils courants

Voici les outils Vibe Coding les plus répandus actuellement disponibles, chacun avec sa propre spécialité.

Outil Type Fonctionnalités principales Scénarios adaptés
Qoder IDE Agent Compréhension approfondie de la base de code, tâches automatisées Quest, multi-Agent, Repo Wiki, mode dual CLI/IDE Projets de taille moyenne à grande, maintenance de projets à long terme
Trae IDE natif IA Développement piloté par la conversation, génération et modification automatiques de code Vibe Coding, scaffolding rapide de nouveaux projets
Cursor Éditeur IA Compréhension au niveau du projet, modification multi-fichiers, mode Agent Développement full-stack, grands projets
Claude Code Agent CLI Exécuter des tâches complexes dans le terminal, modifier automatiquement les projets Backend, développement automatisé
GitHub Copilot Assistant de codage IA Complétion intelligente, chat, Agent Assistance quotidienne au développement
Windsurf Éditeur IA Flux de travail Cascade, modification automatique de plusieurs fichiers Développement rapide, projets de petite et moyenne envergure
OpenAI Codex Agent de codage IA Comprendre les tâches et exécuter le flux de travail de développement complet Développement automatisé
Bolt.new Plateforme de développement IA en ligne Générer une application complète à partir d'une phrase MVP, prototype
v0 par Vercel Outil de génération d'UI Générer automatiquement des pages React Conception de pages, développement de composants
Replit Développement en ligne Développement cloud + collaboration IA Enseignement, tests
Lovable Générateur d'applications IA Générer directement à partir d'une description Startups, validation de produit
Firebase Studio Plateforme d'applications IA Intégration de l'IA + services backend Développement d'applications / Web

Si vous débutez avec le Vibe Coding, vous pouvez commencer avec un outil domestiqueQoderouTraeDémarrez ; il fonctionne de manière similaire à VS Code, a la courbe d'apprentissage la plus douce et ne modifiera pas l'environnement d'éditeur qui vous est familier.


Démarrage rapide

Ci-dessous, en utilisantClaude Code (CLI en terminal)comme exemple, nous allons démontrer un flux de travail Vibe Coding typique.

Pour le tutoriel complet sur Claude Code, voir :https://www.example.com/claude-code/claude-code-tutorial.html

Premier projet : Hello, Vibe World!

Objectif :En 5 minutes, utilisez du langage naturel pur pour permettre à Claude Code de vous aider à créer une page web de carte de visite personnelle.

Étape 1 : Créer un dossier de projet

mkdir my-card && cd my-card
claude

Étape 2 : Décrivez ce que vous voulez à Claude

Dans l'interface Claude Code, saisissez :

帮我创建一个个人名片网页,要求:
- 显示我的名字(张三)和职业(前端开发者)
- 有一个简短的个人简介区域
- 列出3个技能标签(React、Python、设计)
- 设计风格:简洁现代,深色背景,有轻微的渐变效果
- 单个 HTML 文件,不需要外部依赖

Étape 3 : Observez Claude travailler

Vous verrez Claude Code automatiquement :

分析你的需求
创建 index.html 文件
写入完整的 HTML、CSS 和少量 JavaScript

Étape 4 : Afficher le résultat

open index.html   # macOS
# 或
xdg-open index.html   # Linux

Étape 5 : Itérer et modifier

Si vous n'êtes pas satisfait, poursuivez la conversation :

把背景色改成深蓝色渐变,字体换成更现代的 sans-serif,
技能标签加上悬停动画效果

Claude Code modifiera directement les fichiers sans que vous ayez à toucher au code.


Flux de travail principal de Vibe Coding

Le flux de travail principal de Vibe Coding peut se résumer en quatre étapes : Décrire, Vérifier, Itérer, Livrer.

Schéma complet du flux de travail

描述需求
    ↓
AI 生成代码
    ↓
你审查 Diff
    ↓
  ┌─ 不满意 → 描述修改意见 → AI 重新生成
  │
  └─ 满意 → 运行测试
              ↓
            ┌─ 测试失败 → 把报错贴给 AI → 修复
            │
            └─ 测试通过 → 提交代码

Étape 1 : Décrire les exigences

Dites à Claude Code ce que vous voulez en langage naturel.

Il n’est pas nécessaire d’écrire du code ni de mentionner des détails techniques. Indiquez simplement clairement « ce qu’il faut faire ».

Un exemple simple de description d’exigence :

帮我创建一个 Python Flask 项目,有一个 /api/tasks 接口,
支持 GET 获取任务列表和 POST 创建新任务,
任务数据用 JSON 文件存储。

Après l’avoir reçu, Claude Code planifiera la structure des fichiers, générera le code, installera les dépendances et exécutera les tests par lui-même.

Étape 2 : Examiner le Diff

Après avoir généré le code, Claude Code affichera toutes les modifications (Diff) pour que vous puissiez les examiner.

C’est l’étape la plus importante du Vibe Coding——vous devez comprendre ce que l’IA a modifié.

Lors de l’examen, concentrez-vous sur :

Élément à vérifierCe qu’il faut examiner précisément
Exactitude logiqueSi la logique conditionnelle est raisonnable et si les cas limites sont traités
SécuritéS'il existe des vulnérabilités de sécurité telles que l'injection SQL et le XSS
Flux de donnéesSi l'entrée, le traitement et la sortie des données répondent aux attentes
Conventions de nommageSi les noms de variables et de fonctions sont clairs et faciles à comprendre
Code redondantS'il y a une duplication inutile ou des imports inutilisés

La revue de code ne consiste pas à pinailler, mais à s'assurer que vous comprenez ce que fait chaque ligne de code. Si vous ne comprenez pas un morceau de code, demandez simplement à Claude Code : « Que signifie ce code ? Pourquoi a-t-il été écrit ainsi ? »

Étape 3 : Itérer et modifier

Après avoir identifié des problèmes lors de la revue, décrivez les modifications souhaitées en langage naturel.

Exemples de commandes d'itération courantes :

把 JSON 文件存储改成 SQLite,用 SQLAlchemy 做 ORM。
给 POST 接口加个验证:title 必填,不能为空字符串。
报错了,看一下:
Traceback (most recent call last):
  File "app.py", line 42, in create_task
    db.session.add(task)
AttributeError: 'NoneType' object has no attribute 'session'

Après chaque itération, Claude Code régénérera le code et affichera le Diff, et vous ferez à nouveau la revue jusqu'à ce que vous soyez satisfait.

Étape 4 : Livrer

Une fois que toutes les fonctionnalités répondent aux attentes et que les tests passent, effectuez un commit du code.

Claude Code vous aidera à rédiger le message de commit et à effectuer le commit :

$ git log --oneline
a1b2c3d feat: add task CRUD API with SQLite storage

Démo pratique : construire une application Todo à partir de zéro avec Claude Code

Ci-dessous, nous utilisons un cas pratique complet pour démontrer l'ensemble du workflow Vibe Coding.

Nous utiliserons Claude Code pour construire une application Todo à partir de zéro, comprenant une page frontend et une API backend.

Objectif du projet

FonctionnalitéDescription
Ajouter une tâcheSaisissez le titre de la tâche et ajoutez-la à la liste
Terminer la tâcheCliquez sur la case à cocher pour marquer la tâche comme terminée
Supprimer la tâcheSupprimer les tâches inutiles
FilterFiltrer par Toutes / En cours / Terminées
PersistanceLes données sont enregistrées dans SQLite et ne sont pas perdues lors de l'actualisation.

Étape 1 : Initialiser le projet

Créez le répertoire du projet dans le terminal et lancez Claude Code :

$ mkdir vibe-todo && cd vibe-todo
$ claude

Ensuite, décrivez vos exigences à Claude Code :

帮我创建一个 Todo 应用,要求:
1. 后端用 Python Flask + SQLAlchemy + SQLite
2. 前端用纯 HTML/CSS/JS,风格简约现代
3. 支持添加、完成、删除、筛选任务
4. 所有 API 返回 JSON,前端用 fetch 调用
5. 代码注释用中文

Étape 2 : Ce que Claude Code a fait

Après avoir reçu les exigences, Claude Code a automatiquement complété les étapes suivantes :

Tout d'abord, il a créé la structure du projet :

vibe-todo/
├── app.py              # Flask 主应用
├── models.py           # 数据库模型
├── requirements.txt    # 依赖清单
├── static/
│   ├── style.css       # 样式文件
│   └── script.js       # 前端逻辑
└── templates/
    └── index.html      # 页面模板

Ensuite, il a généré le code backend. Voici le contenu principal de app.py :

Exemple

# Chemin du fichier : app.py
# Application principale Flask, définissant les routes de l'API et le point d'entrée de la page

from flask import Flask, render_template, request, jsonify
from models import db, Task

app = Flask(__name__)
# Configurer le chemin de la base de données SQLite
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///todo.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Initialiser les extensions de base de données
db.init_app(app)

# Créer automatiquement la structure des tables au démarrage de l'application
with app.app_context():
    db.create_all()

@app.route('/')
def index():
    """Renvoie la page principale"""
    return render_template('index.html')

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    """Récupère toutes les listes de tâches, prend en charge le filtrage par statut"""
    # Récupérer la condition de filtre à partir du paramètre de requête, par défaut 'all'
    status = request.args.get('status', 'all')
    # Filtrer les tâches en fonction du statut
    if status == 'completed':
        tasks = Task.query.filter_by(completed=True).all()
    elif status == 'active':
        tasks = Task.query.filter_by(completed=False).all()
    else:
        tasks = Task.query.all()
    # Convertir les objets tâche en une liste de dictionnaires pour une sérialisation JSON facile
    return jsonify([t.to_dict() for t in tasks])

@app.route('/api/tasks', methods=['POST'])
def create_task():
    """Créer une nouvelle tâche"""
    data = request.get_json()
    # Valider le champ obligatoire 'title'
    title = data.get('title', '').strip()
    if not title:
        return jsonify({'error': 'Le titre de la tâche ne peut pas être vide'}), 400
    # Créer un objet tâche et l'enregistrer dans la base de données
    task = Task(title=title)
    db.session.add(task)
    db.session.commit()
    return jsonify(task.to_dict()), 201

@app.route('/api/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    """Mettre à jour le statut de la tâche (terminée/incomplète)"""
    task = Task.query.get_or_404(task_id)
    data = request.get_json()
    # Si la requête contient le champ 'completed', mettre à jour le statut
    if 'completed' in data:
        task.completed = data['completed']
    db.session.commit()
    return jsonify(task.to_dict())

@app.route('/api/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    """Supprimer une tâche spécifiée"""
    task = Task.query.get_or_404(task_id)
    db.session.delete(task)
    db.session.commit()
    return jsonify({'message': 'Supprimé avec succès'}), 200

if __name__ == '__main__':
    app.run(debug=True)

Il y a aussi le modèle de base de données models.py :

Exemple

# Chemin du fichier : models.py
# Définitions du modèle de base de données, utilisant SQLAlchemy ORM

from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

# Créer l'instance de base de données, initialisée plus tard dans app.py
db = SQLAlchemy()

class Task(db.Model):
    """Modèle Task, correspondant à la table tasks dans la base de données"""
    __tablename__ = 'tasks'

    # Clé primaire, entier auto-incrémenté
    id = db.Column(db.Integer, primary_key=True)
    # Titre de la tâche, obligatoire, ne peut pas être vide
    title = db.Column(db.String(200), nullable=False)
    # Statut d'achèvement, par défaut False
    completed = db.Column(db.Boolean, default=False)
    # Heure de création, enregistrée automatiquement
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    def to_dict(self):
        """Convertir l'objet tâche en dictionnaire pour faciliter la sérialisation JSON"""
        return {
            'id': self.id,
            'title': self.title,
            'completed': self.completed,
            'created_at': self.created_at.isoformat()
        }

Étape 3 : Examiner le code

Après que Claude Code affiche le Diff, vous le passez en revue ligne par ligne.

Vous pourriez trouver certains problèmes et proposer des modifications.

Par exemple, vous remarquez que les routes de l'API n'ont pas de préfixe unifié et proposez une modification :

把所有 API 路由加上 /api/v1 前缀,方便以后版本管理。

Claude Code mettra automatiquement à jour toutes les routes, et après votre revue, elle est approuvée.

Étape 4 : Exécuter les tests

Une fois la revue validée, demandez à Claude Code de démarrer l'application et de la tester :

$ python app.py
 * Running on http://127.0.0.1:5000

Ouvrez un navigateur et visitez http://127.0.0.1:5000 pour voir l'interface complète de l'application Todo.

Testez la fonctionnalité d'ajout de tâche :

$ curl -X POST http://127.0.0.1:5000/api/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{"title": "学习 Vibe Coding"}'

Résultat renvoyé :

{
  "completed": false,
  "created_at": "2026-06-24T10:30:00",
  "id": 1,
  "title": "学习 Vibe Coding"
}

Étape 5 : Commiter le code

Une fois toutes les fonctionnalités vérifiées, commitez le code :

$ git add .
$ git commit -m "feat: 完成 Todo 应用基础功能"

Tout au long de ce processus pratique, vous n'avez pas écrit une seule ligne de code manuellement. Ce que vous avez fait : décrire les exigences, examiner le Diff, décrire les modifications, exécuter les tests et commiter le code. C'est l'expérience essentielle du Vibe Coding.


Conseils pour rédiger de bons prompts

L'efficacité du Vibe Coding dépend largement de la manière dont vous décrivez les exigences.

De bons prompts peuvent permettre à l'IA de générer du code proche des attentes en une seule fois, réduisant ainsi le nombre d'itérations.

Le modèle à quatre éléments

Un prompt de haute qualité doit inclure quatre éléments :

ÉlémentDescriptionExemple
Quoi faireDécrire clairement la fonctionnalité à implémenter"Créer une API d'inscription d'utilisateur"
Quoi utiliserSpécifier la stack technique et les outils"Utiliser Flask + SQLAlchemy + SQLite"
Comment contraindreFournir des contraintes et des limitesL'e-mail est requis et doit être validé au niveau du format
Format attenduDécrivez les préférences de sortie"Commentaires de code en chinois, ajouter une docstring à chaque fonction"

Bons prompts vs mauvais prompts

Mauvais promptBons prompts
Aidez-moi à créer une fonctionnalité de connexion.Aidez-moi à implémenter un point de terminaison de connexion avec Flask qui reçoit un e-mail et un mot de passe, chiffre le mot de passe avec bcrypt, et renvoie un jeton avec JWT, avec une validité de jeton de 24 heures. Renvoyez des messages d'erreur spécifiques en cas d'échec de connexion.
Ce bouton est trop moche.Modifiez ce bouton d'envoi pour qu'il ait des coins arrondis de 8px, un fond bleu #2563eb, un texte blanc, assombrissez la couleur de 10% au survol, et ajoutez une animation de transition de 0.2s.
Il y a une erreur, aidez-moi à la corriger.Lorsque j'exécute python app.py, j'obtiens une erreur : AttributeError: 'NoneType' object has no attribute 'session'. Cela ressemble à un problème d'initialisation de base de données. Aidez-moi à diagnostiquer et à le corriger.

Principe fondamental des prompts : plus la demande est spécifique, meilleurs sont les résultats. Des exigences vagues ne produisent que du code vague.


Idées fausses courantes et mises en garde

Idée fausse 1 : l'IA peut remplacer toutes les connaissances en programmation

Le Vibe Coding abaisse la barrière de la programmation, mais ne l'élimine pas.

Nous devons encore comprendre les concepts de base : variables, fonctions, API, bases de données, HTTP, async, etc. Sinon, nous ne pouvons pas juger si le code généré par l'IA est correct, ni décrire efficacement les exigences.

Idée fausse 2 : décrire toutes les fonctionnalités en une seule fois

Ne copiez pas l'intégralité du document PRD du produit à l'IA en espérant qu'elle génère du code parfait du premier coup.

L'attention de l'IA a une limite ; plus il y a d'exigences, plus il y a d'erreurs.

Une approche plus efficace consiste à : fonctionnalité principale → valider → ajouter une fonctionnalité → valider → continuer à itérer.

Idée fausse 3 : ne pas lire le code généré par l'IA

Certains développeurs fusionnent directement le code généré par l'IA sans le relire, ce qui est très dangereux.

L'IA peut introduire des vulnérabilités de sécurité, des problèmes de performance ou une architecture complètement déraisonnable.

Nous devons au moins examiner rapidement la logique clé pour nous assurer qu'il n'y a pas de problèmes évidents.

Notes

  • N'écrivez pas d'informations sensibles (clés API, mots de passe de base de données) directement dans la conversation — utilisez d'abord des espaces réservés pour les variables d'environnement dans le code, puis renseignez-les manuellement.
  • Faites un commit dans Git après chaque changement clé, ce qui facilite le retour en arrière en cas de problème.
  • Le code généré par l'IA peut ne pas respecter les normes de codage de votre équipe, des ajustements manuels sont donc nécessaires.
  • Pour le code qui exige une grande fiabilité (paiements, authentification, traitement de données), assurez-vous de l'examiner manuellement après la génération par l'IA.

Scénarios adaptés au Vibe Coding

Le Vibe Coding n'est pas une solution miracle ; savoir quels scénarios lui conviennent peut vous aider à mieux répartir votre énergie.

Scénario Adéquation Description
Développement de prototype/MVP Extrêmement élevé Valider rapidement des idées, obtenir une démo utilisable en quelques heures
API CRUD Extrêmement élevé Modèles répétitifs clairs, la qualité de complétion de l'IA est élevée
Pages/composants front-end Très élevé Composants HTML/CSS/React, l'IA est très bonne pour ceux-ci
Scripts/outils d'automatisation Très élevé Scripts ponctuels, traitement de données, opérations sur fichiers
Écriture de tests unitaires Très élevé Générer des cas de test à partir des signatures de fonctions
Implémentation d'algorithmes complexes Moyenne Nécessite une description claire de l'algorithme, et l'exactitude doit être vérifiée manuellement
Optimisation système de bas niveau Relativement faible Implique la disposition de la mémoire, les lignes de cache, les caractéristiques matérielles ; l'IA est sujette à des erreurs subtiles
Code avec des exigences de sécurité élevées Prudence Chiffrement, authentification, code de paiement ; la sortie générée par l'IA doit être revue par des experts
Autres extensions