Ton premier projet Claude Code

Cinq minutes. C'est tout ce qu'il te faut pour livrer ta première app fonctionnelle avec Claude Code. On oublie Hello World. On va construire un gestionnaire de tâches personnel que tu lanceras vraiment tous les jours.

Gain rapide : colle ça pour commencer :

mkdir smart-todos && cd smart-todos && claude

Ton workspace existe. Claude Code est actif dedans. Regarde ce qui se passe ensuite.

Dis à Claude ce que tu veux, simplement :

Le prompt : "Create a CLI task manager where I can add tasks, mark them done, and see my list. Make it save to a file so tasks persist."

Un plan complet revient. Tu vas voir Claude raisonner à travers :

• La structure de fichiers (une seule app Node.js)
• Le comportement principal (ajouter, compléter, lister)
• La persistance (un fichier JSON sur disque)
• L'interface (sortie terminal propre)

Ce que Claude fait sous le capot

Ce prompt n'est pas un générateur de texte qui te crache un paragraphe. Une chaîne d'outils tourne. Claude lit d'abord ton répertoire actuel, voit que rien n'est là, et construit un plan : quoi écrire, dans quel ordre, quelles dépendances tirer. Puis il prend l'outil Write pour chaque fichier, l'outil Bash pour lancer npm init -y et installer les packages, et parfois l'outil Read pour vérifier ce qu'il vient d'écrire. Chaque appel d'outil s'affiche dans la conversation au fur et à mesure.

Un chatbot balance du code dans une boîte de réponse. Claude Code modifie vraiment ton filesystem et lance des commandes dans ton terminal. Les fichiers sur disque sont réels. Le dossier node_modules qui apparaît est réel aussi.

Claude crée des fichiers fonctionnels directement :

// Claude creates tasks.js automatically
#!/usr/bin/env node
import fs from 'fs';
import path from 'path';

const TASKS_FILE = path.join(process.cwd(), 'tasks.json');
// ... complete working code appears

Teste ton nouveau gestionnaire de tâches immédiatement :

node tasks.js add "Learn Claude Code"
node tasks.js add "Build something amazing"
node tasks.js list

Sortie attendue :

✓ Added: Learn Claude Code
✓ Added: Build something amazing

Your Tasks:
□ 1. Learn Claude Code
□ 2. Build something amazing

Deux minutes. La persistance de fichiers, la gestion des erreurs, et un formatage de sortie soigné fonctionnent tous, dans une vraie app CLI.

Maintenant la partie fun. Tu affines par conversation. Essaie ça :

Ajouter des couleurs : "Make completed tasks show in green and pending in yellow"

Système de priorité : "Let me add priority levels - high, medium, low"

Dates d'échéance : "Allow setting due dates and show overdue tasks in red"

Fonction de recherche : "Add ability to search tasks by keyword"

Chaque requête arrive presque instantanément. Pas d'onglets Stack Overflow. Pas de terriers de config. Décris le comportement, regarde-le apparaître.

L'ancienne façon t'obligeait à tout savoir avant de commencer :

• Quelles bibliothèques choisir
• Comment les fichiers devraient être organisés
• Le parsing des arguments de ligne de commande
• Les opérations d'E/S de fichiers
• Les patterns de gestion des erreurs

Claude Code élimine toutes ces frictions. Tu décris le résultat. Claude gère la plomberie.

Ce que tu as vraiment construit :

• Opérations de fichiers cross-platform
• Persistance de données JSON
• Parsing d'arguments
• Sortie terminal colorisée
• Gestion des erreurs correcte
• Messages d'aide user-friendly

Un projet comme ça bouffe habituellement du vrai temps de setup et de chasse aux dépendances. Ici, un prompt a tout couvert.

Déjà bloqué ? Le guide d'installation a le walkthrough de setup détaillé.

"Permission denied" quand tu lances tasks.js sur Mac ou Linux :

chmod +x tasks.js

Erreurs "Module not found" :

npm init -y && npm install commander chalk

Tu veux le lancer de n'importe où ? Ajoute ça dans package.json :

{
  "bin": {
    "todo": "./tasks.js"
  }
}

Puis lance npm link. Maintenant todo add "anything" fonctionne depuis n'importe quel dossier de ton système.

Parfois la première tentative rate ce que tu avais en tête. C'est normal. Le développement conversationnel s'y attend.

Claude a écrit du code mais ça génère des erreurs quand tu le lances. Colle l'erreur directement dans Claude Code. Dis : "I got this error when running the app" et balance la stack trace complète. L'erreur est lue, la cause identifiée, le fichier corrigé. La plupart des problèmes au premier lancement sont des dépendances manquantes ou un décalage de version Node.js.

L'app tourne mais ne fait pas ce que tu avais décrit. Sois plus précis dans le prochain prompt. Saute "c'est pas bon" et dis exactement ce que tu attendais et ce que tu as vu. "The list command shows tasks in the order they were added, but I want them sorted by priority" donne à Claude une cible concrète. Un feedback vague produit des corrections vagues.

Claude a construit trop de fichiers ou a sur-ingénié ça. Les prompts larges causent ça. Pour Claude, "task manager" peut impliquer une base de données, un système de config, et plusieurs modules. Au prochain passage, délimite le scope : "a single-file Node.js script, no database, store tasks in a JSON file." Un scope serré produit du code serré.

Claude continue de demander la permission avant de lancer des commandes. C'est le système de permissions qui protège ta machine. Il fait une pause sur les commandes shell, les installations de packages, et les écritures en dehors de ton projet. Tape "y" pour approuver chacune, ou configure l'auto-approbation pour les commandes en lesquelles tu as confiance.

Ce qui vient de se passer :

• Tu as décrit une idée en anglais simple
• Claude a construit une app complète et fonctionnelle
• Tu la lances en moins de cinq minutes

C'est la programmation conversationnelle. Pense en problèmes et solutions. Saute la syntaxe et les APIs.

Ton gestionnaire de tâches fonctionne. Essaie ça ensuite :

Prochain prompt : "Add a web interface so I can manage tasks from my browser. Keep the CLI working too."

Un serveur Express apparaît. Ainsi que l'interface HTML. Ton CLI tourne toujours, intact. Une app full-stack en quelques minutes.

Ou prends une autre direction :

• Parcours de vrais exemples de projets pour des idées
• Configure Claude Code pour correspondre à ton workflow
• Dépanne les problèmes courants quand quelque chose plante

Les tutoriels traditionnels enseignent la syntaxe. Ce que tu viens de saisir est le pattern de développement Claude Code. Le même loop à cinq étapes fonctionne sur un outil CLI et sur un SaaS full-stack.

1. Décris le résultat que tu veux. Concentre-toi sur ce que le produit fini fait, pas sur comment tu le construirais. "A task manager where I can add, complete, and list tasks" bat "create a Node.js script using Commander.js with a JSON file store." Les détails d'implémentation sont le problème de Claude. Le pilotage vient après.

2. Laisse Claude architecturer la solution. Ta description est découpée en structure de fichiers, dépendances, et ordre de construction. Les bibliothèques sont choisies. Les patterns sont sélectionnés. Des centaines de petites décisions qui te coûteraient une heure de recherche sont prises pour toi. Tu n'es pas d'accord avec certaines ? Dis juste "use sqlite instead of JSON files" et passe à la suite.

3. Teste immédiatement. Dès que Claude arrête d'écrire, lance la sortie. Ne lis pas ligne par ligne d'abord. Les vrais problèmes (dépendances manquantes, erreurs runtime) apparaissent vite quand tu lances la chose. N'importe quelle erreur collée dans Claude Code devient une correction instantanée.

4. Améliore de façon conversationnelle. Chaque prompt de suivi ajoute une feature ou ajuste un comportement. "Add due dates." "Make the output prettier." "Add a search command." Le code existant est modifié en place, et ce qui fonctionne déjà reste fonctionnel. Ce loop est plus rapide que planifier à l'avance parce que chaque décision est prise contre un prototype qui tourne.

5. Déploie avec confiance. Le temps d'avoir fait trois ou quatre cycles d'amélioration, ton app a été testée à chaque étape. Les cas limites ont émergé pendant le développement conversationnel. Push sur Git. Livre-la.

Le pattern tient à n'importe quelle taille. Des devs solo construisent des apps SaaS complètes avec lui. Des équipes l'utilisent pour prototyper des features avant le sprint planning.

Tu as construit quelque chose de réel. L'étape suivante est de faire en sorte que Claude Code se comporte comme tu penses. Deux guides sont là pour ça :

Configure Claude Code couvre les paramètres, les permissions, et la sélection du modèle. C'est là que tu actives l'auto-approbation pour les commandes de confiance, tu choisis entre Sonnet et Opus par tâche, et tu ajustes l'expérience terminal.

Le guide CLAUDE.md te guide à travers le fichier qui contrôle comment Claude se comporte sur chaque projet. De tout ce que tu peux faire après ton premier projet, celui-là rapporte le plus. Un CLAUDE.md solide signifie que tes standards de code sont suivis, tes patterns préférés sont utilisés, et les décisions sont prises comme tu les ferais.

Au-delà de la configuration :

• Lis le guide des skills pour donner à Claude une expertise profonde dans un domaine
• Explore les fondamentaux des agents pour lancer plusieurs agents parallèles sur de grosses tâches
• Plonge dans le dépannage quand les choses cassent