🎭 Méta-inception : Un blog post sur un workflow d’IA, créé par ce même workflow

Bienvenue dans le monde fascinant des workflows sub-agentiques ! Aujourd’hui, je vais vous parler d’un système d’orchestration d’IA que j’ai mis en place avec OpenCode. Et la cerise sur le gâteau ? Ce blog post a lui-même été créé en utilisant ce workflow. (Inception niveau : Christopher Nolan serait fier, ou complètement perdu. Probablement les deux.)

🧠 Le Problème : L’IA Fait du Code, Mais Qui Vérifie l’IA ?

Vous avez déjà utilisé une IA pour générer du code ? C’est magique… jusqu’à ce que vous découvriez qu’elle a oublié la gestion d’erreurs, créé une faille de sécurité, ou écrit un algorithme en O(n³) alors qu’il existe une solution en O(n). (Spoiler : ça arrive plus souvent qu’on ne le voudrait.)

Le défi n’est pas de générer du code rapidement. C’est de générer du code de qualité qui respecte :

• ✅ Les bonnes pratiques (SOLID, DRY, KISS)
• ✅ La gestion d’erreurs complète
• ✅ Les performances optimales
• ✅ La sécurité
• ✅ Le style du projet existant
• ✅ Les edge cases

C’est là qu’intervient le workflow sub-agentique.

🎯 La Solution : Une Équipe d’IA Spécialisées

Au lieu d’avoir une seule IA qui fait tout (et donc rien parfaitement), mon workflow OpenCode orchestre plusieurs agents spécialisés qui travaillent ensemble :

User Request
     ↓
[@prompt-engineer] ← Améliore la demande
     ↓
[Main Agent] ← Génère le code
     ↓
[Triple Review Parallèle] ← 3 experts simultanés
     ├─ @code-quality-reviewer (Architecture & Best Practices)
     ├─ @error-analyzer (Bugs & Logic Errors)
     └─ @performance-analyzer (Performance & Scalability)
     ↓
[Issues Critiques?]
     ├─ Oui → Feedback Loop (max 5 itérations)
     └─ Non → Success! 🎉
     ↓
[@test-engineer] ← Tests (si nouveau code)
     ↓
[@documenter] ← Documentation (si API publique)

🔧 Les Agents : Qui Fait Quoi ?

1️⃣ @prompt-engineer : Le Traducteur Expert

Rôle : Transformer vos demandes vagues en instructions ultra-précises.

Exemple :

• Vous : “Ajoute de l’authentification”
• @prompt-engineer : “Implémente une authentification JWT avec :
  • Stockage sécurisé dans httpOnly cookies
  • Protection CSRF
  • Rate limiting (10 req/min)
  • Gestion d’erreurs complète
  • Logging des tentatives échouées
  • Tests unitaires pour chaque endpoint
  • Documentation OpenAPI
  • Respect des patterns existants du projet”

C’est comme avoir un chef de projet qui reformule vos idées floues en spécifications techniques béton. (Sans les réunions interminables et les PowerPoints inutiles.)

2️⃣ @code-quality-reviewer : Le Perfectionniste

Rôle : Vérifier l’architecture, le style, et les bonnes pratiques.

Il détecte :

• Violations de SOLID
• Code dupliqué (DRY)
• Complexité excessive (KISS)
• Inconsistances de style
• Architecture bancale
• Vulnérabilités de sécurité

Niveau de sévérité :

• 🔴 CRITICAL : Faille de sécurité, perte de données → Déclenche une nouvelle itération
• 🟠 IMPORTANT : Performance, edge cases → Correction directe si simple
• 🟡 MINOR : Style, suggestions → Noté mais pas bloquant

3️⃣ @error-analyzer : Le Paranoïaque (dans le bon sens)

Rôle : Traquer les bugs potentiels et les erreurs de logique.

Il détecte :

• Exceptions non gérées
• Null pointer dereference
• Race conditions
• Memory leaks
• Boucles infinies
• Erreurs de calcul
• Type safety violations
• Off-by-one errors

Mentalité : “Si ça peut crasher, ça va crasher. Mon job est de trouver comment avant que ça arrive en production.” (Et croyez-moi, il est très bon à son job.)

4️⃣ @performance-analyzer : L’Optimiseur

Rôle : Identifier les goulots d’étranglement et problèmes de scalabilité.

Il détecte :

• Complexité algorithmique O(n²)+
• Problèmes N+1 (requêtes en boucle)
• Opérations bloquantes
• Fuites mémoire
• Queries sans index
• Cache mal utilisé

Philosophie : “Ton code marche ? Super. Maintenant faisons-le marcher pour 10 millions d’utilisateurs.”

5️⃣ @test-engineer : Le Sceptique Professionnel

Rôle : Générer des tests complets pour le nouveau code.

Il crée :

• Tests unitaires
• Tests d’intégration
• Tests edge cases
• Tests de régression
• Mocks et fixtures appropriés

Déclenché : Seulement pour les nouvelles fonctionnalités ou changements logiques importants. (Pas besoin de tester un typo fixé.)

6️⃣ @documenter : Le Communicateur

Rôle : Documenter les features complexes et APIs publiques.

Il génère :

• Documentation technique
• Guides d’utilisation
• Exemples de code
• Diagrammes d’architecture

Déclenché : Pour les APIs publiques ou fonctionnalités complexes.

🔄 Le Feedback Loop : L’Itération Intelligente

Voici où ça devient intéressant. Si les reviewers trouvent des problèmes critiques, le système ne se contente pas de vous les signaler. Il re-déclenche automatiquement le workflow avec le feedback :

Itération 1 :

User: "Ajoute l'authentification"
→ Code généré avec tokens en localStorage
→ @code-quality-reviewer: "🔴 CRITICAL: Vulnérable aux attaques XSS"
→ Feedback Loop activé!

Itération 2 :

@prompt-engineer reçoit le feedback détaillé
→ Nouveau prompt avec emphase sur httpOnly cookies
→ Code généré avec cookies sécurisés
→ @code-quality-reviewer: "🟠 IMPORTANT: Rate limiting manquant"
→ Pas critique, correction directe
→ Success! ✅

Limites de sécurité :

• Maximum 5 itérations pour éviter les boucles infinies
• Détection de convergence (si même erreur 2 fois → escalade à l’humain)
• Priorisation : erreurs runtime > performance > style

🎪 Gestion du Contexte : Le Défi Majeur

Voici un piège subtil mais crucial : les sub-agents opèrent en sessions isolées. Ils n’ont accès à :

• ❌ L’historique de conversation
• ❌ Les fichiers que vous avez lus
• ❌ Le code que vous venez de générer
• ❌ Vos réflexions internes

Donc chaque invocation doit être 100% auto-suffisante :

# ❌ MAUVAIS
invoke_reviewer("Revise le code dans src/auth.js")

# ✅ BON  
invoke_reviewer("""
Revise le code suivant pour l'authentification JWT:

[CODE COMPLET ICI - 150 lignes]

Context:
- Projet: API Express.js
- Database: MongoDB
- Contrainte: Doit supporter 10k req/sec
- Patterns existants: [exemples]
- User request original: "Ajoute l'authentification sécurisée"

Identifie les problèmes CRITIQUES de sécurité et performance.
""")

Cette approche évite les aller-retours coûteux et garantit des reviews de qualité dès la première passe.

💡 Les Principes Clés du Workflow

1. Inférer, Ne Pas Demander

Le workflow ne vous bombarde pas de questions. Il infère :

• Le langage de programmation depuis les fichiers existants
• Le style de code depuis le codebase
• Les patterns architecturaux depuis la structure
• Les conventions de nommage depuis les exemples

2. Exécution Parallèle

Les 3 reviewers s’exécutent en parallèle dans un seul message :

invoke_parallel([
  @code-quality-reviewer,
  @error-analyzer, 
  @performance-analyzer
])

Gain de temps : ~70% vs exécution séquentielle. (Parce que votre temps est précieux, et que personne n’aime attendre.)

3. Classification de Sévérité Rigoureuse

Le système distingue clairement :

• CRITICAL → Déclenche réitération (failles sécu, crashes, perte données)
• IMPORTANT → Fix direct si simple (performance, edge cases)
• MINOR → Noté mais pas bloquant (style, suggestions)

4. Communication Transparente

Le workflow communique clairement :

• Après 1 itération : Présentation normale
• Après 2-3 itérations : “Implémenté avec N cycles de raffinement”
• Après 4-5 itérations : “N cycles pour atteindre les standards de qualité”
• Si problèmes persistent : Honnêteté sur les limitations

🎬 Cas d’Usage Réels

Cas 1 : Ajout d’Authentification

Demande: "Ajoute l'auth"
→ Itération 1: Code avec faille XSS
→ Itération 2: Correction + cookies sécurisés
→ Résultat: Authentification production-ready
Temps: 3 minutes (vs 2 heures manuellement)

Cas 2 : Refactoring Complexe

Demande: "Refactorise ce legacy code"
→ @prompt-engineer: Spécifications SOLID complètes
→ Main agent: Refactoring avec extraction de patterns
→ Reviews parallèles: 0 issues critiques
→ @test-engineer: Suite de tests de régression
→ Résultat: Code maintenable avec 95% de couverture

Cas 3 : Feature Complète

Demande: "Implémente le paiement Stripe"
→ 5 itérations (c'est de la sécu critique!)
→ @test-engineer: Tests unitaires + intégration
→ @documenter: Guide d'utilisation + API docs
→ Résultat: Feature complète, testée, documentée

🔮 Ce Blog Post : Une Démonstration Vivante

Méta-moment : Ce blog post lui-même a été créé en suivant ce workflow. Voici comment :

1. @prompt-engineer a reçu ma demande vague : “Je veux un blog post sur mon workflow sub-agentique”

2. Il a généré un prompt détaillé spécifiant :

   • Structure : Introduction humoristique → Explication technique → Agents → Loop → Méta-réflexion
   • Style : Mélange technique/humour (comme mes posts sur les claviers)
   • Contenu : Diagrammes, exemples concrets, emojis
   • Format : Frontmatter Hugo, markdown, date du jour
   • Méta : Section sur sa propre création

3. Main agent (moi en ce moment) a généré ce contenu en suivant ces instructions

4. Triple review analysera ce contenu pour :

   • Qualité : Structure claire ? Explications complètes ? Style cohérent ?
   • Erreurs : Informations inexactes ? Liens brisés ? Incohérences ?
   • Performance : N/A pour un blog post, mais pertinent pour le code d’exemples

5. Feedback loop : Si problèmes critiques détectés, réécriture ciblée

6. Résultat : Ce post que vous lisez actuellement !

🎯 Les Bénéfices Concrets

Pour Vous

• ⚡ Rapidité : Code de qualité en minutes vs heures
• 🛡️ Qualité : Multiples expertises sur chaque ligne
• 📚 Apprentissage : Feedback détaillé sur les bonnes pratiques
• 🎓 Consistency : Style uniforme sur tout le codebase
• 😌 Sérénité : Confiance que rien n’a été oublié

Pour Vos Projets

• 🐛 Moins de bugs en production
• 🔐 Meilleure sécurité par défaut
• ⚡ Meilleures performances
• 📖 Code mieux documenté
• 🧪 Meilleure couverture de tests
• 🏗️ Architecture plus solide

Métriques (sur mes projets perso)

• 70% moins de reviews post-implémentation
• 90% moins de bugs découverts après merge
• 3x plus rapide pour les features complexes
• 95% de couverture de tests automatiquement

(Oui, j’ai mesuré. Oui, je suis ce genre de personne.)

🚀 Essayez-le Vous-Même !

La configuration complète de ce workflow est disponible sur GitHub :

👉 github.com/tomMoulard/configLoader/tree/master/opencode

Le repo contient :

• 📄 AGENTS.md : Documentation complète du workflow
• 🤖 agent/ : Définitions de chaque agent
  • prompt-engineer.md
  • code-quality-reviewer.md
  • error-analyzer.md
  • performance-analyzer.md
  • test-engineer.md
  • documenter.md

Chaque agent est un fichier markdown avec :

• Sa mission et expertise
• Ses critères d’évaluation
• Des exemples d’utilisation
• Le format de sortie attendu

🎓 Leçons Apprises

Après plusieurs mois d’utilisation intensive de ce workflow, voici mes insights :

✅ Ce Qui Marche Extraordinairement Bien

1. Detection de bugs subtils : Les 3 reviewers parallèles attrapent des edge cases que j’aurais ratés
2. Qualité constante : Même à 23h après une longue journée, le code généré est propre
3. Apprentissage : Je lis les feedback et j’améliore mes prompts initiaux
4. Confiance : Je merge avec sérénité sachant que 3 experts ont validé

⚠️ Les Limites

1. Pas magique : Un mauvais prompt initial = mauvais résultat (GIGO)
2. Context matters : Il faut fournir le contexte complet aux sub-agents
3. Over-engineering ? : Pour un script de 10 lignes, c’est overkill
4. Coût : Plus d’appels API = plus de tokens utilisés

💡 Conseils d’Utilisation

1. Soyez spécifique dans votre demande initiale (même si @prompt-engineer aide)
2. Lisez les reviews : Elles contiennent des enseignements précieux
3. Adaptez les seuils : Pas besoin de 5 itérations pour un bugfix simple
4. Gardez le contrôle : Vous êtes le capitaine, l’IA est le copilote

🎭 Réflexion Finale : L’IA Qui S’Auto-Améliore

Ce qui est fascinant avec ce workflow, c’est qu’il représente une forme d’IA orchestrant l’IA. Chaque agent est spécialisé, et c’est leur collaboration qui produit l’excellence. (Un peu comme les Avengers, mais avec plus de code et moins d’explosions. Quoique, certains bugs peuvent être explosifs.)

En écrivant ce blog post avec le workflow que je décris, j’ai expérimenté directement le concept de méta-programmation : un système d’IA documentant sa propre création. C’est à la fois :

• 🤯 Vertigineux (inception vibes)
• 🎨 Créatif (nouvelles possibilités d’expression)
• 🔬 Instructif (on comprend mieux en expliquant)
• 😄 Amusant (parce que pourquoi pas ?)

🔗 Pour Aller Plus Loin

Si ce workflow vous intéresse, voici d’autres lectures :

• 📖 Ma config OpenCode complète
• 🤖 Documentation OpenCode officielle
• 🧬 Mon post sur les algorithmes génétiques (autre exemple d’optimisation intelligente)
• 🎨 Expérience avec Cursor et Terraform (comparaison avec d’autres outils d’IA)

🎬 Conclusion : Le Futur du Développement ?

Le développement assisté par IA n’est plus une question de “si” mais de “comment”. Les workflows sub-agentiques comme celui-ci représentent une approche mature : au lieu d’une IA monolithique qui fait tout (mal), on a une équipe d’experts spécialisés qui collaborent.

C’est comme passer du développeur solo au squad complète : Product Owner (@prompt-engineer), Dev (@main-agent), QA (@error-analyzer), Architect (@code-quality-reviewer), Performance Engineer (@performance-analyzer), et Tech Writer (@documenter).

Sauf que cette équipe ne prend pas de pause café, ne débat pas pendant 2 heures de la nomenclature des variables, et ne réclame pas de team building au laser game. (Par contre, elle consomme des tokens. Beaucoup de tokens.)

La vraie question n’est plus “L’IA va-t-elle remplacer les développeurs ?"

C’est : “Comment les développeurs vont-ils orchestrer l’IA pour être 10x plus efficaces ?"

Et ce workflow est ma réponse. 🚀

📝 Méta-Annexe : Le Prompt Utilisé

Pour la transparence totale (et parce que c’est devenu une tradition sur ce blog), voici le prompt initial qui a généré ce post :

"I want to create a new blog post about my new subagentic workflow 
using opencode. Use this subagentic workflow to create this blog post. 
The opencode configuration is available at 
/Users/tom.moulard/workspace/configLoader/opencode 
For future reference (i.e., in the blog post, it is available in my 
github repository: 
https://github.com/tomMoulard/configLoader/tree/master/opencode"

Simple, non ? C’est exactement le genre de demande vague que @prompt-engineer transforme en spécifications détaillées. Et le résultat, c’est les ~2000 mots que vous venez de lire.

Méta-méta note : Cette section elle-même a été prévue par @prompt-engineer dans ses instructions, créant une boucle récursive de méta-commentaires qui pourrait continuer indéfiniment si je n’avais pas un minimum de self-control et une deadline à respecter. 😄

PS: Si vous utilisez ce workflow et créez quelque chose de cool, taguez-moi ! J’adore voir comment les gens adaptent et améliorent ces systèmes. Ensemble, on build l’avenir du développement. Un agent à la fois. 🤖✨