Objectif du système

Le but est de transformer Claude Cowork en hub IA personnel capable de :

• centraliser vos informations ;
• produire un briefing quotidien ;
• suivre vos projets ;
• créer des tableaux de bord ;
• exécuter des tâches récurrentes ;
• construire automatiquement de nouveaux projets à partir d’un PRD Product Requirements Document (document d’exigences produit ou document de cadrage produit.);
• documenter ce qu’il fait pour éviter la perte de contexte.

Le système ne repose pas sur une simple conversation avec Claude. Il repose sur une logique d’architecture : instructions, dossiers, mémoire, données, tableaux de bord, automatisations.

Vue d’ensemble des étapes

Le système se construit en cinq grandes phases :

1. configurer les instructions de Claude Cowork ;
2. rédiger un PRD initial ;
3. créer les dossiers et le projet Cowork ;
4. exécuter le plan de construction ;
5. ajouter un constructeur autonome.

La logique est simple : avant de construire des outils, il faut d’abord construire le cadre dans lequel ces outils vont fonctionner.

Étape 1 : configurer les paramètres de Claude Cowork

But de l’étape

Claude Cowork doit recevoir des instructions de fonctionnement avant de commencer à travailler.

Ces instructions déterminent :

• comment il réfléchit ;
• quand il doit poser des questions ;
• comment il construit ;
• comment il documente ;
• quand il doit s’arrêter avant une action risquée.

Sans ces instructions, Cowork risque d’agir comme un simple assistant exécutant. Avec ces instructions, il devient un système de travail structuré.

Action à faire

Dans Claude Cowork :

1. ouvrir Claude Hub ;
2. aller dans Claude Settings ;
3. cliquer sur Cowork ;
4. coller les « Operating Instructions » ;
5. sauvegarder les paramètres.

Contenu des instructions

Les instructions doivent être divisées en quatre blocs.

Bloc 1 : PRD first, always

Avant toute construction, Claude Cowork doit rédiger un PRD.

Un PRD signifie Product Requirements Document. C’est un document de cadrage.

Il doit préciser :

• le problème à résoudre ;
• le résultat attendu ;
• les critères de réussite ;
• le périmètre exact ;
• les limites ;
• les contraintes ;
• les étapes de construction ;
• les questions ouvertes ;
• les points à valider.

Pourquoi c’est important

Sans PRD, Claude peut construire trop vite, mais construire le mauvais outil.

Le PRD évite ce problème. Il force Claude à définir clairement ce qu’il va faire avant de commencer.

Règle à appliquer

Claude Cowork ne doit jamais construire directement.
Il doit d’abord :

1. rédiger le PRD ;
2. poser les questions ouvertes ;
3. attendre une validation explicite ;
4. commencer seulement après accord.

Bloc 2 : contradiction et clarification

Claude Cowork doit avoir le droit de contredire l’utilisateur.

Il doit signaler :

• une incohérence stratégique ;
• une erreur technique ;
• une contradiction avec une décision précédente ;
• une solution trop fragile ;
• un compromis non anticipé ;
• une mauvaise priorité.

Pourquoi c’est important

Un assistant IA trop obéissant peut exécuter une mauvaise idée sans la questionner.

Le but ici est d’obtenir un assistant critique, capable de dire :

• “ce choix est risqué” ;
• “ce plan n’est pas cohérent” ;
• “il manque une contrainte” ;
• “cette solution va créer un problème plus tard”.

Bloc 3 : prise de notes agressive

Claude Cowork doit documenter tout ce qu’il fait.

Il doit garder une trace :

• des décisions ;
• des fichiers créés ;
• des modifications ;
• des erreurs ;
• des validations ;
• des tâches terminées ;
• des tâches restantes ;
• des dépendances ;
• des changements importants.

Pourquoi c’est important

Plus le système grandit, plus la mémoire devient importante.

Si Claude construit plusieurs projets, tableaux de bord, automatisations et skills, il doit conserver une mémoire claire de ce qui existe déjà.

Sinon, il risque de :

• répéter des tâches ;
• oublier des choix ;
• casser une structure existante ;
• reconstruire une fonctionnalité déjà présente ;
• perdre la logique globale du système.

Bloc 4 : réversibilité

Claude Cowork doit demander confirmation avant toute action difficile à annuler.

Exemples :

• supprimer un fichier ;
• déplacer un dossier important ;
• modifier une architecture ;
• écraser un document ;
• lancer une migration ;
• refactoriser du code ;
• modifier une tâche automatisée.

Principe

Si l’action est difficile à inverser, Claude doit s’arrêter et demander validation.

La logique est claire :
une question interrompt le travail quelques secondes ; une suppression non contrôlée peut détruire plusieurs heures de travail.

Étape 2 : rédiger le PRD initial

But de l’étape

Le PRD initial est le plan général de tout le système Cowork.

Il joue le rôle d’un plan d’architecte.

Avant de créer les dossiers, tableaux de bord, automatisations ou skills, il faut définir précisément ce que le système doit devenir.

Ce que le PRD doit contenir

Le PRD initial doit inclure :

• les projets à construire ;
• les sources de données ;
• l’architecture des dossiers ;
• la logique de mémoire ;
• les tableaux de bord ;
• les skills ;
• les automatisations ;
• le plan d’exécution ;
• l’ordre de construction ;
• les critères de réussite.

Étape 2.1 : choisir les projets de départ

Quatre exemples de projets initiaux.

Projet 1 : tableau de bord d’investissement

Objectif : suivre les investissements.

Fonctions possibles :

• afficher le portefeuille ;
• suivre les performances ;
• intégrer des actualités ;
• produire des analyses ;
• donner des conseils selon une philosophie d’investissement ;
• mettre à jour les données.

Ce projet transforme des données financières dispersées en tableau de bord exploitable.

Projet 2 : briefing quotidien

Objectif : produire chaque matin une synthèse utile de la journée.

Le briefing peut intégrer :

• les événements du calendrier ;
• les emails importants ;
• les messages Slack ;
• les tâches à suivre ;
• les actualités ;
• les informations d’investissement ;
• les priorités du jour.

Dans l’exemple, le briefing est envoyé dans Apple Notes.

Le format peut être adapté selon le besoin.

Projet 3 : suite de skills

Les skills sont des commandes ou instructions spécialisées permettant à Claude de réaliser une tâche précise à la demande.

Trois skills sont décrites.

Today Skill

Fonction : afficher ou mettre à jour le briefing du matin.

Usage : relancer rapidement la synthèse de la journée sans reconstruire tout le système.

Research Skill

Fonction : analyser un titre financier précis.

Usage : taper une commande du type /research [ticker] pour obtenir une analyse détaillée d’une action.

Les résultats peuvent ensuite alimenter le tableau de bord d’investissement.

Prep Skill

Fonction : préparer une réunion.

Usage : donner à Claude une réunion à analyser pour qu’il récupère le contexte disponible :

• participants ;
• sujet ;
• informations associées ;
• éléments de préparation.

Ce skill est utile lorsque le calendrier contient des réunions ajoutées par d’autres personnes.

Projet 4 : constructeur autonome

Objectif : permettre à Claude Cowork de construire des projets sans supervision permanente.

Fonctionnement général :

1. l’utilisateur dépose un brief ou un PRD ;
2. Claude lit le PRD ;
3. Claude construit le projet ;
4. le projet est classé selon son état ;
5. un tableau de bord permet de suivre l’avancement.

C’est la partie la plus avancée du système.

Étape 2.2 : définir l’architecture

But de l’architecture

Claude Cowork fonctionne localement sur la machine de l’utilisateur.

Il doit donc travailler dans une structure de dossiers claire.

Cette structure permet de savoir :

• où sont les projets ;
• où sont les données ;
• où sont les instructions ;
• où sont les logs ;
• où sont les tâches en attente ;
• où sont les projets terminés ;
• où sont les erreurs.

Exemple d’organisation

Le système peut partir d’un dossier principal nommé :

cowork

À l’intérieur, on peut avoir :

• projects/
• memory/
• dashboards/
• skills/
• data/
• tasks/
• logs/
• pending/
• in-progress/
• done/
• failed/

Le nom exact des dossiers peut varier. L’important est d’avoir une logique stable.

Étape 2.3 : construire selon la logique du “data lake”

Le contenu source utilise l’analogie du lac artificiel.

Principe

Avant de construire des outils, il faut remplir le système avec des données.

• Le lac représente l’environnement Cowork (le « trou du lac »).
• L’eau représente les données.
• Les canalisations représentent les sources d’information.

Sources possibles

Les données peuvent venir de :

• Google Calendar ;
• emails ;
• Slack ;
• actualités ;
• investissements ;
• fichiers locaux ;
• tâches ;
• notes ;
• historiques de projets.

Interprétation pratique

Il ne faut pas commencer par les dashboards. Il faut d’abord créer les flux de données.

Ensuite seulement, on construit :

• les tableaux de bord ;
• les briefings ;
• les skills ;
• les automatisations ;
• les rapports ;
• les projets autonomes.

Étape 3 : créer les dossiers et le projet Cowork

But de l’étape

Avant de demander à Claude de construire tout le système, il faut créer un point d’ancrage local.

Procédure

1. Ouvrir le Finder.
2. Créer un nouveau dossier.
3. Nommer ce dossier, par exemple : mission control.
4. Ouvrir Cowork.
5. Aller dans Projects.
6. Cliquer sur New Project.
7. Choisir Use an Existing Folder.
8. Sélectionner le dossier créé.
9. Ajouter une instruction indiquant que Claude doit suivre le fichier PRD.
10. Créer le projet.
11. Déposer le fichier PRD mission control.md dans le dossier.
12. Dans Cowork, écrire : Please start building with the mission control PRD.

Résultat attendu

Claude Cowork lit le PRD et commence à proposer les prochaines étapes.

Il peut demander :

• d’installer des plugins ;
• de configurer des connecteurs ;
• de créer des skills ;
• de valider des permissions ;
• de confirmer des éléments du plan.

Étape 4 : exécuter le plan de construction

But de l’étape

À ce stade, le PRD existe et le projet est créé.

Il faut maintenant suivre le plan de construction.

1 : créer la couche de données

Objectif : mettre en place les fondations.

Actions typiques :

• créer les dossiers ;
• installer les connecteurs ;
• lancer le système de mémoire ;
• connecter les sources de données ;
• vérifier que les données circulent ;
• organiser les fichiers initiaux.

Dans l’exemple, la commande /start du plugin de productivité lance le système de mémoire.

Résultat attendu

Le système dispose d’une base stable pour récupérer, stocker et exploiter les données.

2 : construire le tableau de bord principal

Objectif : créer une interface de visualisation.

Dans l’exemple, le tableau de bord porte sur les investissements.

Mais le principe peut s’appliquer à d’autres domaines :

• projets clients ;
• tâches commerciales ;
• prospection ;
• contenus SEO ;
• campagnes email ;
• finances ;
• santé ;
• planning personnel ;
• production de contenu.

Rôle du dashboard

Un dashboard évite de fouiller dans les dossiers.

Il donne une vue claire :

• de l’état du système ;
• des tâches ;
• des informations importantes ;
• des projets ;
• des alertes ;
• des données actualisées.

3 : construire le briefing quotidien et les skills

Objectif : créer des fonctions utiles au quotidien.

Briefing quotidien

Le briefing synthétise la journée.

Il peut contenir :

• résumé du portefeuille ;
• calendrier ;
• emails ;
• tâches à suivre ;
• priorités ;
• réunions ;
• informations importantes.

Skills

Les skills permettent de déclencher des fonctions précises.

Exemples :

• afficher le briefing ;
• analyser une action ;
• préparer une réunion ;
• résumer une journée ;
• générer une liste de tâches ;
• vérifier un agenda ;
• produire un rapport.

4 : construire le système autonome

Objectif : permettre à Claude Cowork de prendre un PRD en attente et de le construire automatiquement.

C’est une couche avancée. Elle repose sur une logique de dossiers.

Étape 5 : mettre en place le constructeur autonome

But de l’étape

Le constructeur autonome permet d’empiler des demandes de construction sans avoir à les lancer une par une.

L’utilisateur prépare ou valide des PRD, puis Cowork les construit selon un calendrier.

Structure des dossiers

Pending

Contient les PRD validés mais pas encore construits.

In progress

Contient les projets en cours de construction.

Done

Contient les projets terminés.

Failed

Contient les projets échoués.

Logs

Contient les traces d’exécution.

Fonctionnement détaillé

1. Claude propose des idées de projets.
2. Claude rédige un PRD pour chaque idée.
3. L’utilisateur relit et valide.
4. Le PRD validé est placé dans pending.
5. Une tâche planifiée vérifie le dossier toutes les 30 minutes.
6. Si un PRD est trouvé, Claude le déplace vers in-progress.
7. Claude construit le projet.
8. Si le projet réussit, il est déplacé vers done.
9. Si le projet échoue, il est déplacé vers failed.
10. Claude écrit un log d’exécution.

Intérêt

Ce système permet de se réveiller avec un projet déjà construit.

Il transforme Cowork en chaîne de production autonome.

Étape 6 : créer un tableau de bord Mission Control

But

Le tableau de bord Mission Control sert à suivre l’ensemble du système.

Il donne une vue claire sur :

• les projets en attente ;
• les projets en cours ;
• les projets terminés ;
• les projets échoués ;
• les logs ;
• les automatisations ;
• les horaires de build ;
• les prochaines tâches.

Pourquoi le créer

Sans tableau de bord, il faut inspecter les dossiers manuellement.

Avec un tableau de bord, le système devient lisible.

Le dashboard transforme une architecture technique en interface de pilotage.

Étape 7 : finaliser et tester

But

La dernière phase consiste à vérifier que tout fonctionne réellement.

Actions à faire :

• tester les connecteurs ;
• vérifier les dossiers ;
• lancer un briefing ;
• tester un skill ;
• tester un PRD de construction ;
• vérifier les logs ;
• vérifier les notifications ;
• corriger les erreurs ;
• valider le fonctionnement de bout en bout.

Résultat attendu

Le système doit pouvoir :

• récupérer les données ;
• produire des synthèses ;
• exécuter des skills ;
• lancer une construction ;
• déplacer les projets selon leur état ;
• documenter ce qu’il fait.

Étape 8 : améliorer la mémoire

Problème

Plus Cowork construit de choses, plus sa mémoire devient volumineuse.

Avec le temps, il peut :

• oublier des décisions ;
• mélanger des projets ;
• conserver trop d’informations inutiles ;
• perdre la hiérarchie entre ancien et actuel ;
• devenir moins précis.

Solution

Il faut structurer la mémoire.

Exemples de bonnes pratiques :

• séparer mémoire active et archives ;
• résumer les projets terminés ;
• maintenir un fichier de décisions ;
• conserver les logs importants ;
• supprimer ou archiver les éléments obsolètes ;
• documenter les conventions ;
• créer des fichiers de référence stables.

Schéma global du système

Claude Cowork
│
├── Operating Instructions
│   ├── PRD obligatoire
│   ├── contradiction
│   ├── prise de notes
│   └── réversibilité
│
├── PRD initial
│   ├── projets à construire
│   ├── architecture
│   ├── données
│   ├── skills
│   └── plan horaire
│
├── Couche de données
│   ├── calendrier
│   ├── emails
│   ├── Slack
│   ├── investissements
│   └── actualités
│
├── Projets
│   ├── dashboard
│   ├── briefing quotidien
│   ├── skills
│   └── constructeur autonome
│
├── Constructeur autonome
│   ├── pending
│   ├── in-progress
│   ├── done
│   ├── failed
│   └── logs
│
└── Mission Control Dashboard
    ├── suivi des builds
    ├── suivi des tâches
    ├── suivi des erreurs
    └── pilotage du système

Méthode pratique à appliquer

1. Commencer par le comportement de Claude

Avant les projets, définir comment Claude doit travailler.

Sans ça, il exécute sans cadre.

2. Construire le PRD

Le PRD est obligatoire. Il transforme une idée vague en plan exécutable.

3. Créer le dossier local

Le dossier local est la base physique du système.

4. Connecter le projet Cowork au dossier

Cowork doit agir dans un espace précis, pas dans le vide.

5. Déposer le PRD dans le dossier

Le PRD devient la référence principale.

6. Lancer la construction

Claude lit le PRD et exécute progressivement.

7. Construire d’abord les données

Les données sont la matière première.

8. Construire ensuite les interfaces

Dashboards, briefings et skills viennent après la donnée.

9. Ajouter l’automatisation

Le constructeur autonome vient une fois la base stable.

10. Tester et maintenir

Un système IA local doit être testé, documenté et nettoyé.

Synthèse

Le système Claude Cowork décrit dans le contenu repose sur une idée centrale : ne pas utiliser l’IA comme un simple chatbot, mais comme un environnement de travail structuré.

La méthode suit une logique d’architecture :

1. définir les règles de comportement ;
2. rédiger un PRD ;
3. créer une structure de dossiers ;
4. connecter les sources de données ;
5. construire des outils sur ces données ;
6. automatiser les constructions ;
7. piloter le tout avec un dashboard ;
8. maintenir la mémoire.

Le point le plus important est le PRD.

Sans PRD, Claude Cowork improvise.
Avec un PRD, il construit selon un plan.