Vibe Coding : Créer une API REST avec l'IA

Le backend est traditionnellement le territoire des développeurs confirmés. Configurer un serveur, gérer les routes, sécuriser les endpoints, connecter une base de données — chaque étape exige des compétences techniques pointues. Le Vibe Coding bouleverse cette réalité en permettant à quiconque de générer du code backend fonctionnel via des prompts en langage naturel.

Une API REST (Representational State Transfer) est le standard de communication entre applications. Chaque fois que votre app mobile récupère des données, qu'un formulaire envoie des informations ou qu'un paiement est traité, une API REST est impliquée. En 2026, 83 % des applications SaaS reposent sur des API REST pour leur architecture backend.

Voici pourquoi le Vibe Coding est particulièrement adapté à la création d'API :

• Rapidité : une API complète en 2-4 heures vs 2-3 semaines en développement classique
• Structure cohérente : l'IA applique systématiquement les bonnes pratiques RESTful (naming, status codes, pagination)
• Code documenté : Claude génère des commentaires clairs et une documentation Swagger automatique
• Intégration DB native : Prisma, Drizzle ou TypeORM sont générés avec les bons schémas relationnels

Le backend IA n'est pas réservé aux prototypes. Des entreprises comme Vercel, Supabase et Railway ont optimisé leurs plateformes pour accueillir des API générées par IA, avec des pipelines de déploiement en un clic. Le Vibe Coding dépasse désormais le développement traditionnel en termes de vélocité sur les projets de taille moyenne.

Avant de lancer votre premier prompt, vous devez assembler le bon stack technique. L'efficacité de votre API dépend directement de la qualité de vos outils. Voici le setup recommandé pour créer une API REST en Vibe Coding en 2026 :

Prérequis techniques minimaux : Pour tirer le meilleur parti de ce tutoriel, assurez-vous d'avoir Node.js 20+ installé, un compte Cursor Pro (20 $/mois), et une base de données PostgreSQL accessible (gratuit avec Supabase ou Neon). Consultez notre guide sur les meilleurs outils de Vibe Coding pour une comparaison détaillée.

Prérequis conceptuels : Comprenez les verbes HTTP (GET = lire, POST = créer, PUT = modifier, DELETE = supprimer), les codes de statut (200 OK, 201 Created, 400 Bad Request, 401 Unauthorized, 404 Not Found, 500 Server Error) et le format JSON. Ces concepts vous permettront de valider le code généré et de rédiger des prompts précis.

Passons à la pratique. Ce tutoriel vous guide pas à pas pour générer une API REST complète de gestion de tâches (todo API) — un cas d'usage suffisamment simple pour être clair, mais avec tous les patterns réutilisables pour un projet réel. Pour maîtriser les fondamentaux, consultez notre guide Vibe Coding avec Cursor et Claude.

Étape 1 : Initialiser le projet

Ouvrez Cursor et utilisez le prompt suivant dans le chat IA (Cmd+L) :

Initialise un projet Node.js + TypeScript pour une API REST.
Stack : Express.js, Prisma ORM, PostgreSQL, Zod pour la validation.
Structure de dossiers :
- src/routes/ (un fichier par ressource)
- src/middleware/ (auth, validation, error-handler)
- src/schemas/ (schémas Zod)
- src/lib/ (prisma client, utils)
- prisma/schema.prisma

Configure tsconfig.json strict, les scripts npm (dev, build, start, migrate),
et un fichier .env.example avec DATABASE_URL et JWT_SECRET.

Claude génère l'arborescence complète, le package.json avec toutes les dépendances, et la configuration TypeScript. Vérifiez toujours le fichier tsconfig.json : assurez-vous que strict: true est activé.

Étape 2 : Générer le schéma de base de données

Génère le schéma Prisma pour une API de gestion de tâches avec :
- User : id, email (unique), passwordHash, name, createdAt, updatedAt
- Task : id, title, description (optionnel), status (enum: PENDING, IN_PROGRESS, DONE),
  priority (enum: LOW, MEDIUM, HIGH), dueDate (optionnel), createdAt, updatedAt
- Relation : un User a plusieurs Tasks (cascade delete)
- Utilise UUID pour les IDs
- Ajoute les index nécessaires pour les performances

Génère aussi les types TypeScript correspondants avec Zod pour :
- CreateUserSchema, LoginSchema
- CreateTaskSchema, UpdateTaskSchema, TaskQuerySchema (filtres + pagination)

Ce prompt est stratégique : en générant le schéma DB et les types Zod ensemble, vous créez une source de vérité unique. Chaque endpoint que vous générerez ensuite héritera de cette structure. C'est la technique la plus efficace en prompt engineering pour le Vibe Coding.

Étape 3 : Générer les endpoints CRUD

En utilisant le schéma Prisma et les schémas Zod déjà créés,
génère les routes Express pour la ressource Task :

GET    /api/tasks      → Liste paginée avec filtres (status, priority, search)
GET    /api/tasks/:id  → Détail d'une tâche
POST   /api/tasks      → Créer une tâche (validée par Zod)
PUT    /api/tasks/:id  → Modifier une tâche (validée par Zod)
DELETE /api/tasks/:id  → Supprimer une tâche

Chaque route doit :
- Utiliser le middleware d'authentification JWT
- Vérifier que la tâche appartient à l'utilisateur connecté
- Retourner un format cohérent : { status: "success"|"error", data, message }
- Gérer les erreurs avec try/catch et le middleware error-handler
- Inclure la pagination : { data, meta: { page, limit, total, totalPages } }

Claude génère environ 200 lignes de code pour ces 5 endpoints, avec la validation Zod intégrée, les requêtes Prisma optimisées et la gestion d'erreurs complète. Le code inclut automatiquement la vérification de propriété (task.userId === req.user.id).

Étape 4 : Générer les tests

Génère les tests d'intégration avec Vitest + Supertest pour toutes les routes Task.
Teste les cas suivants pour chaque endpoint :
- Cas nominal (succès)
- Requête sans token JWT (401)
- Données invalides (400 avec détails Zod)
- Ressource inexistante (404)
- Tentative d'accès à une tâche d'un autre utilisateur (403)

Utilise un helper pour créer un utilisateur de test et générer un JWT valide.
Configure une base de test séparée avec beforeAll/afterAll pour le cleanup.

Les tests sont la vérification essentielle du code généré par IA. Lancez npm test et corrigez les éventuelles erreurs en copiant l'output dans le chat Cursor. L'IA corrige ses propres erreurs en 1-2 itérations dans 90 % des cas. Pour approfondir le débogage, consultez notre guide sur le débogage en Vibe Coding.

La sécurité est le point le plus critique du code généré par IA. Un endpoint CRUD fonctionne visuellement, mais sans audit, il peut contenir des failles exploitables. Voici le prompt pour générer un système d'authentification robuste, suivi des vérifications manuelles indispensables. Notre guide complet sur la sécurité en Vibe Coding détaille chaque point.

Génère le système d'authentification complet pour mon API :

Routes :
- POST /api/auth/register → inscription avec validation email + mot de passe fort
- POST /api/auth/login → connexion retournant un JWT (access token 15min + refresh token 7j)
- POST /api/auth/refresh → renouveler l'access token avec le refresh token
- POST /api/auth/logout → invalider le refresh token

Sécurité obligatoire :
- Hashage bcrypt (12 rounds) pour les mots de passe
- JWT signé avec RS256 (pas HS256)
- Refresh tokens stockés en DB avec expiration
- Rate limiting : 5 tentatives de login par IP par 15 minutes
- Validation mot de passe : min 8 chars, 1 majuscule, 1 chiffre, 1 caractère spécial
- Headers de sécurité : helmet.js
- CORS configuré avec whitelist de domaines

Middleware auth qui :
- Vérifie le JWT dans le header Authorization: Bearer <token>
- Attache req.user avec id et email
- Retourne 401 avec message clair si token invalide/expiré

Vérifications manuelles post-génération : même avec un prompt détaillé, vérifiez systématiquement ces points dans le code généré :

Une API en local ne sert à rien. Le déploiement est l'étape qui transforme votre code en produit réel. En 2026, les plateformes cloud ont tellement simplifié le processus qu'un déploiement complet prend moins de 20 minutes.

Option A : Railway (recommandé pour débuter)

Option B : Docker + VPS (pour plus de contrôle)

Demandez à Claude de générer un Dockerfile optimisé :

Génère un Dockerfile multi-stage optimisé pour mon API Express + TypeScript + Prisma :
- Stage 1 : build (compilation TS + génération Prisma client)
- Stage 2 : production (image minimale, node:20-alpine, utilisateur non-root)
- Healthcheck endpoint /health
- Fichier docker-compose.yml avec l'API + PostgreSQL + Redis (pour le rate limiting)
- Taille finale de l'image < 150MB

Configuration essentielle pour la production : générez aussi avec Cursor un endpoint GET /health qui retourne le statut de la DB et de l'API, un middleware de logging structuré (Winston ou Pino), et la gestion graceful shutdown pour fermer proprement les connexions DB lors d'un redéploiement.

Le vrai pouvoir du Vibe Coding backend apparaît quand vous l'appliquez à un projet concret. Voici comment structurer l'API d'un Micro-SaaS créé avec le Vibe Coding, avec les prompts spécifiques pour chaque module.

Exemple : SaaS de gestion de factures

Imaginons une application de facturation pour freelances. Voici l'architecture API que vous pouvez générer intégralement en Vibe Coding :

Le Vibe Coding accélère considérablement la création d'API, mais il comporte des limites qu'il faut connaître pour les anticiper. Si vous débutez, notre article sur les 7 erreurs à éviter en Vibe Coding débutant complète parfaitement cette section.

❌ Les limites à connaître

✅ Les bonnes pratiques indispensables

Avant de déployer votre API en production, passez en revue chaque point de cette checklist. Chaque item peut être généré ou vérifié avec un prompt Cursor dédié. Copiez cette checklist et utilisez-la comme référence pour chaque projet.

🏗️ Architecture

🔒 Sécurité

🧪 Tests et qualité

🚀 Production

Questions fréquentes