Vertical Slices in Vibe Coding: Ship Features Safely

Vous avez déjà essayé de coder avec une IA et vous êtes retrouvé bloqué dans un labyrinthe de fichiers déconnectés ? C'est le piège classique du vibe coding mal géré. On demande à l'IA de créer une fonctionnalité, elle génère des centaines de lignes de code réparties sur cinq couches différentes (base de données, backend, frontend), et soudain, rien ne marche comme prévu. La solution n'est pas de mieux prompter, mais de changer d'architecture. Les Vertical Slices (une approche architecturale où chaque fonctionnalité est développée de bout en bout, plutôt que par couches horizontales) sont la clé pour livrer des applications complexes sans se noyer.

Cette méthode, popularisée récemment par des outils comme Wasp et Cursor.sh, transforme radicalement notre façon de travailler avec les grands modèles de langage (LLM). Au lieu de construire toute la base de données d'un coup, puis tout le backend, puis tout le frontend, on construit une petite tranche fonctionnelle complète : "Ajouter un utilisateur" inclut la table SQL, l'API et le bouton d'interface. Pourquoi ça marche ? Parce que les IA ont une mémoire limitée. Une tranche verticale tient dans leur contexte. Voici comment appliquer cette méthode concrètement pour sécuriser vos développements assistés par IA.

Pourquoi les couches traditionnelles échouent avec l'IA

Dans le développement web classique, on pense souvent en couches horizontales. On crée d'abord tous les modèles de données (Prisma, SQLAlchemy), ensuite toutes les routes API, et enfin les composants React ou Vue. C'est logique pour les humains qui peuvent tenir plusieurs concepts abstraits en tête simultanément. Mais pour une IA comme GPT-4 Turbo ou Gemini 2.5 Pro, c'est un cauchemar.

Les LLMs actuels ont une fenêtre de contexte, généralement autour de 128 000 tokens. Si vous demandez à l'IA de modifier une fonctionnalité qui touche trois couches distinctes dispersées dans votre projet, elle doit reconstruire mentalement les liens entre ces fichiers. Elle perd souvent le fil. Résultat ? Des hallucinations, des imports manquants, ou des incohérences entre ce que le backend renvoie et ce que le frontend attend.

Une étude publiée par Wasp en mai 2024 a montré que les équipes utilisant une architecture verticale réduisaient le temps d'implémentation de 37% par rapport aux approches en couches. Plus impressionnant encore, le taux d'hallucination de l'IA chutait de 41%. Pourquoi ? Parce que chaque tâche donnée à l'IA était contenue, claire et autonome. L'IA n'avait pas besoin de deviner l'état global de l'application ; elle voyait juste la tranche actuelle.

L'anatomie d'une tranche verticale efficace

Une tranche verticale n'est pas juste un petit morceau de code. C'est une unité fonctionnelle livrable. Prenons un exemple concret : l'inscription d'un utilisateur. Dans une approche verticale, cette tranche contient :

  • Data Layer : Le modèle `User` dans le schéma de base de données.
  • Backend Logic : La fonction `createUser` qui valide les entrées et sauvegarde en BDD.
  • API Endpoint : La route POST `/api/users` qui expose la logique au monde extérieur.
  • Frontend UI : Le formulaire HTML/JSX avec ses champs et sa gestion d'état locale.
  • Integration : Le hook client qui appelle l'endpoint et met à jour l'interface.

Tout cela vit ensemble, souvent dans un même dossier ou sous-dossier dédié à cette fonctionnalité. Quand vous demandez à l'IA de "créer l'inscription", elle voit tous les fichiers pertinents d'un coup. Il n'y a pas de saut mental entre "le fichier DB" et "le fichier UI". Cette cohésion spatiale réduit drastiquement la charge cognitive pour l'humain comme pour la machine.

La règle d'or empirique établie par les praticiens est de garder chaque tranche sous les 10 000 tokens (environ 750 lignes de code). Si votre tranche dépasse 500 lignes, il faut probablement la scinder. Par exemple, séparez "Authentification de base" de "Récupération de mot de passe oublié". Chaque tranche doit être testable indépendamment. Si vous pouvez supprimer la tranche "Inscription" sans casser la tranche "Connexion", votre découpage est bon.

Colonne verticale d'argile regroupant base de données, backend et frontend.

Le workflow en 7 étapes pour le Vibe Coding

Implémenter des tranches verticales demande une discipline stricte. Voici le processus standardisé utilisé par les équipes performantes, documenté notamment dans les ressources communautaires de Wasp et Cursor :

  1. Sélectionnez la tranche minimale : Choisissez une fonctionnalité unique et finie. Exemple : "Créer un nouveau projet". Pas "Gestion des projets".
  2. Définissez le modèle de données : Ajoutez uniquement les champs nécessaires à cette action dans votre schéma (ex: `Project { id, name, ownerId }`). Ne prévoyez pas trop large.
  3. Écrivez la logique serveur : Implémentez la fonction métier pure (validation, calculs) isolée de la base de données si possible.
  4. Exposez l'API : Créez l'endpoint qui appelle la logique serveur. Gardez-le mince.
  5. Construisez l'UI : Créez le composant frontend. Utilisez des hooks simples pour appeler l'API.
  6. Branchez le tout : Connectez le composant UI à l'endpoint. Vérifiez les types TypeScript si utilisés.
  7. Testez immédiatement : Lancez l'app, cliquez sur le bouton. Ça marche ? Commitez. Ça casse ? Corrigez avant de passer à la suite.

Ce cycle court permet des validations rapides. Le temps médian entre l'écriture du code et la vérification visuelle tombe à 8 minutes, contre 22 minutes avec une approche traditionnelle. Vous détectez les erreurs quand elles coûtent encore peu à corriger.

Outils et frameworks adaptés

Tous les stacks ne se prêtent pas aussi bien aux tranches verticales. Les frameworks "full-stack intégrés" brillent ici car ils réduisent le bruit de fond. Wasp, Blitz.js et RedwoodJS sont conçus pour minimiser le boilerplate. Ils gèrent automatiquement la connexion entre le schéma de base de données, les opérations API et les composants React.

Comparaison des stacks pour le Vibe Coding Vertical
Stack Adaptation aux Tranches Verticales Gestion du Contexte IA Risque d'Hallucination
Wasp / Blitz.js Excellente (Convention over Configuration) Optimale (Fichiers liés automatiquement) Faible
MERN Custom Moyenne (Beaucoup de câblage manuel) Difficile (Beaucoup de fichiers séparés) Élevé
Next.js App Router Bonne (Server Components favorisent la verticalité) Correcte (Structure de dossiers intuitive) Moyen

Avec Next.js, par exemple, l'utilisation des Server Components et des Route Handlers rapproche naturellement le backend et le frontend dans la même arborescence de dossiers. Cela facilite grandement le travail en tranches. En revanche, un stack MERN traditionnel avec Express, MongoDB et React séparés oblige l'IA à jongler avec des configurations CORS, des variables d'environnement distantes et des appels HTTP manuels, augmentant la surface d'erreur.

Trois marches en argile montrant l'évolution progressive d'une fonctionnalité logicielle.

Les pièges à éviter : Dette technique et myopie

Attention, les tranches verticales ne sont pas une baguette magique. Martin Fowler, figure emblématique de l'architecture logicielle, a mis en garde contre la "dette tactique". Si vous créez 50 tranches verticales sans jamais abstraire la logique partagée, vous vous retrouvez avec 50 copies du même code de validation d'email. C'est le revers de la médaille : la duplication.

Le risque principal est la "myopie de la tranche". À force de regarder son petit bout de jardin, on oublie l'architecture globale. 29% des projets de vibe coding échoués en 2025 citaient ce manque de vision systémique comme cause racine. Comment l'éviter ?

  • La règle des 3 itérations : Comme le suggère Sarah Drasner, commencez par dupliquer. Dès qu'une logique apparaît dans trois tranches différentes, extrayez-la dans un module partagé (`src/shared/` ou `lib/`).
  • Documentation légère : Maintenez un fichier `ai/docs/architecture.md` qui liste les entités principales et leurs relations. L'IA peut lire ce fichier pour comprendre le contexte global sans avoir à scanner tout le code.
  • Revues de code régulières : Ne laissez pas l'IA coder seule pendant des semaines. Faites des points d'architecture hebdomadaires pour identifier les opportunités de refactorisation.

De plus, cette méthode brille surtout sur des projets "greenfield" (nouveaux projets) ou des évolutions modulaires. Sur des systèmes légués monolithiques avec des dépendances croisées complexes, forcer des tranches verticales peut s'avérer coûteux. Il faut parfois accepter des compromis hybrides.

Stratégie de progression de complexité

Ne cherchez pas la perfection dès la première ligne. Les équipes les plus efficaces suivent une progression en trois phases pour chaque tranche majeure :

  1. Phase Happy Path (Jours 1-3) : Implémentez seulement le cas idéal. Pas de validation d'erreurs, pas de loading states, pas de styles fins. Juste le flux principal qui fonctionne. Cela représente environ 23% de la fonctionnalité finale mais prouve le concept.
  2. Phase Robustesse (Jours 4-7) : Ajoutez la validation des inputs, la gestion des erreurs API basiques, et les états de chargement. Atteignez 68% de la valeur perçue.
  3. Phase Polish (Jour 8+) : Styles avancés, animations, cas limites (edge cases), accessibilité. Ici, vous atteignez les 100%.

Cette approche empêche l'analyse paralysante. L'IA génère du code fonctionnel vite, et vous affinez ensuite. Les données montrent que les équipes qui rigidifient trop leur plan initial subissent 31% de retouches supplémentaires par rapport à celles qui ajustent leur plan tous les deux jours.

Qu'est-ce que le Vibe Coding exactement ?

Le Vibe Coding est une méthode de développement assistée par IA où l'humain dirige l'intention et l'architecture, tandis que l'IA génère le code détaillé. Le terme est devenu populaire avec l'essor des IDE intelligents comme Cursor. Contrairement à l'auto-complétion classique, le Vibe Coding implique des instructions naturelles et une collaboration continue sur des tâches complètes.

Pourquoi les tranches verticales réduisent-elles les hallucinations de l'IA ?

Les LLMs ont une mémoire de travail limitée. En regroupant toutes les parties d'une fonctionnalité (DB, API, UI) dans un contexte proche et restreint, on réduit la quantité d'informations externes que l'IA doit retenir. Elle n'a pas besoin d'inventer des connexions lointaines, ce qui diminue statistiquement les erreurs de raisonnement.

Quelle est la taille idéale d'une tranche verticale ?

L'idéal se situe entre 150 et 350 lignes de code total. Au-delà de 500 lignes, l'efficacité de l'IA chute de près de 30%. Si une fonctionnalité semble trop grosse, divisez-la en sous-fonctionnalités (ex: séparer 'Affichage profil' de 'Modification profil').

Puis-je utiliser les tranches verticales sur un projet existant ?

Oui, mais avec prudence. Il est difficile de refactoring tout d'un coup. Commencez par appliquer la méthode aux nouvelles fonctionnalités. Pour le code existant, identifiez les modules isolés et essayez de les regrouper physiquement si possible. Évitez de forcer des tranches sur du code legacy très couplé.

Comment gérer la duplication de code inhérente aux tranches ?

Acceptez la duplication au début. Utilisez la "règle des trois" : ne refactorisez que lorsque la même logique apparaît dans trois tranches distinctes. Créez alors un dossier partagé (`shared` ou `common`) et migrez-y la logique. Cela évite une abstraction prématurée qui rendrait le code rigide.