Claude Code × Obsidian : Guide complet pour créer 15 alter ego « cerveau externe » IA

Actuellement, nous avons 15 employés IA qui travaillent de manière autonome. Pour les rendre encore plus efficaces, j'ai créé 15 alter ego, chacun avec une personnalité spécifique, héritant de mes connaissances et de mes schémas de pensée. Je ne leur donne pas d'instructions détaillées ; ils comprennent déjà ma façon de penser, donc il n'y a pas besoin de communication inutile.

Ces dernières années, l'évolution de l'IA a été remarquable, révolutionnant nos styles de travail et nos processus de réflexion. Cependant, la plupart des utilisations de l'IA restent bloquées dans un format de questions-réponses « ponctuel », sans parvenir à libérer le véritable potentiel de la technologie. Pour utiliser l'IA non pas comme un simple outil passif, mais comme un « collaborateur » qui pense, agit et apprend de manière autonome, il est essentiel de construire un système où l'IA peut « boucler ».

Cet article fournit un guide pratique sur la façon de construire un « Cerveau Externe IA » en combinant Claude Code et Obsidian. Nous explorerons le concept de la « Boucle IA » — où l'IA parcourt en continu le cycle « Planifier → Exécuter → Vérifier → Corriger » — et fournirons des méthodes d'implémentation spécifiques avec des exemples de code pratiques. De la configuration de l'infrastructure à la théorie de conception de la Boucle IA, en passant par l'automatisation des workflows avec les Skills, la gestion de projet autonome avec le PM Layer, et l'automatisation avancée avec la gestion des coûts, ce guide couvre tout ce dont vous avez besoin pour faire de l'IA un véritable partenaire.

Partie 1 : Construction du Cerveau Externe IA

Le fondement de la « Boucle IA » est le « Cerveau Externe IA », qui agrège et gère les connaissances personnelles et les informations des projets. En reliant Claude Code, Obsidian et Git, nous construisons une infrastructure robuste pour que l'IA puisse référencer, apprendre et agir. Ce chapitre explique les étapes de configuration spécifiques et la structure de répertoires recommandée.

1.1 Le concept du Cerveau Externe IA

Un Cerveau Externe IA est une base de connaissances structurée qui externalise les fonctions de mémoire, d'apprentissage et de réflexion humaines afin que l'IA puisse y accéder et les utiliser. Cela permet à l'IA de prendre des décisions avancées et de résoudre des problèmes en se référant aux expériences et connaissances passées.

・Base de connaissances : Une collection de notes Markdown gérées dans Obsidian, comprenant des idées, des projets, des notes de réunion et des informations techniques.

・Agent IA : Programmes centrés sur Claude Code qui exécutent des processus automatisés.

・Contrôle de version : Gestion et synchronisation de la base de connaissances à l'aide de Git et GitHub.

・Couche d'automatisation : Exécution périodique de tâches et traitement piloté par les événements à l'aide de GitHub Actions.

1.2 Préparation de l'environnement de développement

1. Obsidian : Un outil de gestion des connaissances pour les notes Markdown locales.
2. Git : Un système de contrôle de version pour gérer les notes dans un dépôt GitHub.
3. Claude Code : L'environnement d'exécution de l'agent IA utilisant l'API Claude d'Anthropic.
4. Compte GitHub : Requis pour le stockage distant et l'automatisation via GitHub Actions.

1.3 Structure de répertoires recommandée

1.claude/          # Commandes et configuration Claude Code
2  commands/       # Scripts de commandes personnalisées
3  config.yaml     # Paramètres Claude Code
400_Inbox/         # Notes temporaires et informations non organisées
510_Projects/      # Répertoires pour les projets en cours
6  ProjectA/
7    README.md
8    tasks.md
920_Areas/         # Domaines continus (ex. Développement, Marketing)
1030_Resources/     # Documents de référence et ressources d'apprentissage
1140_Archives/      # Projets terminés et anciennes informations
12README.md         # Aperçu du cerveau externe

1.4 Synchronisation Git et GitHub

La synchronisation des notes Obsidian avec GitHub assure la sécurité des données, le suivi des modifications, la synchronisation entre plusieurs appareils et permet à Claude Code de lire/écrire dans la base de connaissances.

1.5 Configuration de Claude Code

Claude Code est un agent IA de codage qui effectue des opérations sur les fichiers, génère du code et exécute des commandes à partir d'instructions en langage naturel. Il sert de « mains et pieds » du Cerveau Externe IA.

Utilisation de base :
``bash
claude "Veuillez décrire l'objectif et l'aperçu de ce projet dans README.md."
``

Partie 2 : Implémentation des Portes de Vérification

Ce chapitre se concentre sur la théorie de la « Boucle IA » et l'implémentation des « Portes de Vérification » (VERIFY Gate), qui déterminent le succès ou l'échec des opérations autonomes.

2.1 Les 5 étapes de la Boucle IA

1. DÉCOUVRIR : Identifier les problèmes et rassembler les informations.
2. PLANIFIER : Créer un plan d'action.
3. EXÉCUTER : Effectuer le travail.
4. VÉRIFIER : Évaluer objectivement les résultats.
5. ITÉRER : Corriger et réessayer en fonction de la vérification.

2.2 Importance de la Porte de Vérification

Sans une porte de vérification stricte, l'IA peut tomber dans l'autosatisfaction, en supposant à tort qu'une tâche est terminée alors qu'elle ne l'est pas. La porte garantit que l'IA comprend ce qui constitue un succès.

2.3 Implémentation du code de la Porte de Vérification

Voici un script Python qui vérifie automatiquement la qualité du code à l'aide de mypy et pytest :

1# verify_code_quality.py
2import subprocess
3import sys
4from pathlib import Path
5
6def run_command(command, error_message):
7    process = subprocess.run(command, capture_output=True, text=True, check=False)
8    if process.returncode != 0:
9        return False, f"{error_message}\n{process.stdout}\n{process.stderr}"
10    return True, process.stdout
11
12def verify_implementation():
13    print("--- Starting Code Verification ---")
14    # Run mypy and pytest...
15    return True, "All code quality checks passed."
16
17if __name__ == "__main__":
18    passed, result = verify_implementation()
19    print(result)
20    sys.exit(0 if passed else 1)

2.5 Conception des conditions d'arrêt

Pour éviter les boucles infinies et les pics de coûts, vous devez définir des conditions d'arrêt telles que des critères de succès, un nombre maximum d'itérations, des limites budgétaires et des limites de temps.

Partie 3 : Skills et Couche PM

3.1 Conception des Skills

Dans Claude Code, vous pouvez définir des « Skills » personnalisées pour transformer des opérations complexes en commandes uniques comme /decompose ou /work.

3.2 Introduction de la Couche PM

Pour atteindre une véritable autonomie, l'IA a besoin d'une « couche de jugement » pour comprendre le contexte du projet (Quoi, Pourquoi, Comment, Quand). Nous utilisons un fichier pm_brief.md dans chaque répertoire de projet pour fournir ce contexte.

Partie 4 : Automatisation Toujours Active

En utilisant GitHub Actions, nous pouvons faire travailler l'IA périodiquement sans intervention humaine.

4.1.1 Nettoyage matinal de la boîte de réception

Un workflow qui s'exécute chaque matin à 9h00 pour organiser le dossier 00_Inbox/.

4.2 Surveillance et gestion des coûts

L'automatisation toujours active est puissante mais nécessite une surveillance des coûts. Utilisez --max-budget-usd et --max-turns pour limiter les dépenses par exécution.

Conclusion : Concevoir la Boucle

La clé pour maximiser l'IA n'est pas seulement un prompt ingénieux, mais la conception d'une Boucle dans laquelle l'IA peut planifier, exécuter, vérifier et se corriger elle-même. En combinant Claude Code et Obsidian, vous transformez l'IA d'un simple outil en un collaborateur continu.