Agentic OS sur Claude Code : l’architecture en trois couches

Agentic OS sur Claude Code : la construction à trois couches

La plupart des gens utilisent Claude Code comme une machine à sous.

Ouvrez le terminal. Tapez une invite. Tirez le levier. Parfois, vous obtenez un refactor fonctionnel. Parfois, vous obtenez un mur de mises en garde. Parfois, vous recevez la moitié de ce que vous avez demandé et une explication polie expliquant pourquoi l'autre moitié n'est « pas conseillée pour le moment ». Vous relancez donc l'invite. Tirez à nouveau. Peut-être modifier un mot. Tirez à nouveau.

J'ai fait cela pendant les huit premiers mois d'utilisation de Claude Code. Je me suis dit que c'était une ingénierie rapide. Ce n'était pas le cas. C'était du jeu.

Ce qui a finalement brisé la boucle, c'est une méthodologie que j'ai tirée d'un résumé vidéo sur la création d'un « système d'exploitation agent » sur Claude Code, puis adaptée à ma propre réalité désordonnée consistant à gérer quatre marques et à publier environ 250 messages longs dans le système cette année. La méthodologie comporte trois couches : architecture, mémoire et observabilité. Mots ennuyeux. Une récompense massive.

Cet article est la version de cette méthodologie que j'utilise réellement, écrite sur le terrain, avec les primitives Claude Code spécifiques que j'utilise et les choses que j'ai essayées qui n'ont pas survécu au contact avec le travail réel. Si vous en êtes au stade des machines à sous et que vous commencez à soupçonner qu'il existe une meilleure solution, vous avez raison. C'est ici.

Le problème des machines à sous a un coût

Avant que la méthodologie ait un sens, la douleur doit être spécifique. Alors permettez-moi d'être précis.

Un flux de travail sur une machine à sous semble productif. Vous êtes au terminal. Il se passe des choses. Le code est en cours de génération. Mais le travail derrière le travail – la partie où vous réexpliquez la voix de votre marque pour la onzième fois, collez la même structure de dossiers dans une nouvelle session, déboguez une sortie qui dérive parce que vous avez oublié de mentionner la contrainte qui était évidente pour vous mais invisible pour le modèle – cette partie est invisible jusqu'à ce que vous la mesuriez.

J'ai mesuré le mien en mars. Au cours d'une semaine de sessions Claude Code, j'ai dépensé environ 35 % de mes jetons d'invite sur le contexte que j'avais déjà donné au modèle lors d'une session précédente. Pas l'œuvre elle-même. La configuration pour le travail. Les règles de la marque que j'avais écrites à trois endroits. Chemins de dossiers Je l'avais montré mardi et réaffiché vendredi. Des contraintes vocales enfouies dans un CLAUDE.md quelque part que je n'ai jamais pris la peine de pointer du doigt.

Pire : la variance. Demandez à Claude Code d'écrire un article sur mejba.me lundi et vous obtiendrez une forme. Demandez de la même manière vendredi et vous obtiendrez quelque chose qui semble avoir été écrit par une personne apparentée mais inconnue. Ce n'est pas le modèle qui se comporte mal. C'est moi qui exécute une invite non structurée sur un moteur sans état et qui suis surpris que la sortie ne soit pas stable.

La méthodologie du système d'exploitation agentique résout les deux problèmes en arrêtant le jeu et en démarrant l'architecture. Trois niveaux, par ordre d'impact : organiser ce que vous faites (architecture), se souvenir de ce que vous avez fait (mémoire), voir ce qui se passe (observabilité).

Même si vous n’adoptez que la première couche, vous obtiendrez l’essentiel de la valeur. Je veux être honnête à ce sujet dès le départ, car la tentation lorsque vous lisez parler d'un système à trois niveaux est d'essayer de construire les trois un samedi. Ne le faites pas. Construisez la première couche. Vivez dedans. Ajoutez ensuite le suivant.

Allons-y.

Couche 1 : Architecture – Des invites aléatoires à un véritable organigramme

La première couche est celle qui a brisé pour moi l’habitude des machines à sous. C'est aussi celui que j'ai failli sauter car il semble le moins technique.

L’idée est simple. Arrêtez de considérer Claude Code comme un endroit où vous tapez des invites. Commencez à y penser comme une organisation avec des départements, des descriptions de poste et des procédures opérationnelles standard. Concrètement, cela signifie organiser votre travail en quatre concepts imbriqués :

- Domaines : les grands domaines dans lesquels vous opérez réellement (création de contenu, recherche, productivité, communauté, sécurité)

• Tâches — le travail récurrent produit par chaque domaine (un article de blog, une analyse des concurrents, une révision du code, un audit de marque)
• Compétences — instructions codifiées et reproductibles sur la façon de bien accomplir une tâche spécifique
• Automations — compétences qui s'exécutent sur un déclencheur au lieu d'attendre que vous les invoquiez

Ce n’est pas abstrait. Dans Claude Code, chacun de ces concepts correspond à une véritable primitive. Les compétences vivent sous forme de fichiers SKILL.md avec le frontmatter YAML. Les sous-agents vivent sous forme de fichiers de démarque dans .claude/agents/. Les commandes Slash vivent sous forme de fichiers dans .claude/commands/. Les automatisations sont des compétences enveloppées dans un hook (SessionStart, PostToolUse) ou un déclencheur planifié via le SDK de l'agent Claude. La plateforme est déjà conçue pour cela. Il vous suffit d'utiliser la forme.

À quoi ressemble réellement un domaine dans ma configuration

Je dirige quatre marques – mejba.me, ramlit.com, colorpark.io, xcybersecurity.io – ainsi qu'un domaine « opérations » interne pour tout ce qui traverse les marques. J'ai donc cinq domaines. Chaque domaine comporte entre trois et sept tâches que j'effectue de manière récurrente, et chaque tâche est associée à au plus une compétence.

Voici la structure tronquée sur le disque :

~/projects/agentic-os/
├── CLAUDE.md                          # root config (more on this below)
├── .claude/
│   ├── settings.json                  # permissions + hooks
│   ├── agents/                        # subagents (one per role)
│   │   ├── aria.md                    # content engineer
│   │   ├── auditor.md                 # SEO + voice auditor
│   │   └── researcher.md              # WebSearch + summary specialist
│   ├── commands/                      # slash commands
│   │   ├── morning-scan.md
│   │   ├── post-from-video.md
│   │   └── brand-audit.md
│   └── skills/                        # repeatable instructions
│       ├── write-blog-post/SKILL.md
│       ├── extract-video-summary/SKILL.md
│       └── seo-pass/SKILL.md
└── vault/                             # memory layer (Obsidian)
    ├── raw/
    ├── wiki/
    └── output/

C'est toute l'architecture dans un seul arbre. Aucun outillage intelligent. Pas de plateforme propriétaire. Uniquement les dossiers que Claude Code comprend déjà nativement.

Ce qui en fait un organigramme et pas seulement un dossier, ce sont les relations entre les éléments. Le sous-agent aria.md lit la compétence write-blog-post. La commande barre oblique morning-scan appelle le sous-agent researcher, qui lit la compétence extract-video-summary. Chaque pièce fait une chose. Aucun d’eux ne se reproduit. Lorsque je souhaite modifier la façon dont les publications mejba.me sont écrites, je modifie un fichier – le write-blog-post/SKILL.md – et chaque invocation dans chaque domaine hérite de la modification.

C'est la superpuissance ennuyeuse. Une source de vérité pour chaque capacité.

Une vraie compétence, pas un jouet

Laissez-moi vous montrer à quoi ressemble réellement une compétence. Voici une version allégée de celle que j'utilise pour extraire des résumés structurés des transcriptions vidéo avant qu'elles ne deviennent des articles de blog :

---
name: extract-video-summary
description: Extract a structured summary from a video transcript or YouTube URL. Use when the user provides a video, transcript, or asks to "summarize this video" before writing a post.
---

You are extracting a structured summary that another agent will use as
source material for a blog post. The output must be:

1. **TLDR** — three sentences. The single most important takeaway.
2. **Key claims** — bullet list. One claim per bullet. No editorializing.
3. **Specific examples** — bullet list. Names, numbers, dates, tools.
4. **Quotes worth pulling** — direct quotes that would land in a blog.
5. **What the video gets wrong or oversimplifies** — be honest.

Rules:
- Do not soften claims. If the speaker said it, write it as they said it.
- If a claim is unverified, mark it `[unverified]` and move on.
- Save the result to `vault/raw/video-summaries/[slug].md` using
  the video title as the slug.

C'est tout. Quarante lignes une fois que l’on compte le formatage. Chargé dans Claude Code via l'outil Skill, il transforme une invite peu fiable « Résumez ceci pour moi » en un processus déterministe. La même forme à chaque fois. Même emplacement de fichier à chaque fois. Les mêmes agents en aval peuvent le lire sans vérifier le format affiché aujourd'hui.

L'essentiel d'une bonne compétence est ce qu'elle supprime, pas ce qu'elle ajoute. Une compétence prend une demande floue et supprime la variance. Si vous vous retrouvez à écrire une compétence longue et intelligente, vous n'avez probablement pas décidé quelle est réellement la tâche.

Automatisations : des compétences avec un déclencheur

Une automatisation est une compétence qui fonctionne sans vous. Dans Claude Code, le moyen le moins cher d'en connecter un est via un crochet dans settings.json. Un hook SessionStart se déclenche lorsqu'une session Claude Code commence. Un hook PostToolUse se déclenche après la fin d'un outil. Les deux sont configurés dans settings.json et sont documentés dans la référence officielle des hooks Claude Code.

Voici l'analyse des tendances matinales que j'effectue. Il s'agit d'une commande slash (/morning-scan) que je déclenche manuellement la plupart du temps, mais les jours où je souhaite qu'elle soit automatisée, la même commande s'exécute à partir d'une tâche cron qui envoie simplement à claude -p "/morning-scan" :

---
name: morning-scan
description: Aggregate AI news, competitor moves, and trending topics into a single daily brief. Save to vault/raw/scans/YYYY-MM-DD.md.
---

# Morning Scan

Run this every weekday morning before I open the terminal.

1. Use WebSearch to pull the top 5 stories from each of:
   - Anthropic, OpenAI, Google AI launches in the last 24h
   - HackerNews top 10 (filter to AI/dev/agent topics)
   - r/ClaudeAI top posts of the day
2. For each story, write a 2-sentence summary. No fluff.
3. Flag anything that affects my multi-brand workflow:
   - Claude Code changelog → tag #claude-code-update
   - New AI tool launches → tag #stack-candidate
   - Security/CVE news → tag #xcyber-relevant
4. Save the brief to vault/raw/scans/YYYY-MM-DD.md.
5. If anything in the brief is post-worthy for mejba.me, add a
   line at the top: `POST CANDIDATE: [topic]`.

La compétence est le quoi. La tâche cron est le déclencheur. Ensemble, ils forment une automatisation.

Pour la version plus propre, vous utiliseriez le SDK de l'agent Claude pour planifier l'exécution par programme et publier le résultat sur un canal Slack ou sur votre propre tableau de bord. J'ai finalement construit cette version. La version slash-command-plus-cron m'a permis d'obtenir 80 % de la valeur en 30 minutes.

Quand l'automatisation devient un piège

Section honnête. J'ai surautomatisé pendant deux mois début 2026. J'ai construit quatorze automatisations pour les quatre marques. Des hooks se déclenchant sur chaque Edit, des analyses programmées toutes les deux heures, un hook qui validait automatiquement tout fichier touché par Claude Code. C'était magnifique sur un tableau blanc. En pratique, ce fut un désastre.

Trois choses sont cassées. Premièrement, les crochets se sont battus. Un formateur PostToolUse a continué à reformater les fichiers en cours d'édition et à les appliquer en cascade lors de l'appel d'outil suivant. Deuxièmement, le coût a explosé : chaque analyse programmée représentait une session Claude complète sans plafond, et la facture en mars était presque le double de celle de février. Troisièmement, le bruit. Quatorze automatisations signifiaient quatorze notifications Slack par jour, dont la plupart étaient désactivées, ce qui annulait tout le problème.

Je l'ai réduit à quatre automatisations. Analyse du matin. Nettoyage du coffre-fort en fin de journée. Audit hebdomadaire de la voix de la marque. Revue mensuelle de la pile. Tout le reste est devenu une commande slash que j'exécute quand je le souhaite réellement. La leçon : l'automatisation concerne les choses que vous exécuteriez de toute façon, pas celles que vous souhaiteriez que quelqu'un exécute.

Si vous partez de zéro, créez une compétence, une commande slash et zéro automatisation. Utilisez-les pendant une semaine. Ajoutez la chose suivante seulement lorsque vous avez ressenti l'absence.

J'ai couvert la philosophie plus large de conception des compétences dans l'étude approfondie sur les compétences Claude Code pour lesquelles les entreprises paient en 2026, et les modèles tactiques pour garder les compétences bon marché dans le post d'épargne de jetons de compétences d'homme des cavernes - tous deux méritent d'être lus avant de commencer à codifier les vôtres.

C'est la première couche. Domaines, tâches, compétences, automatisations. Si vous arrêtez de lire ici et construisez simplement ceci, vous serez déjà en avance sur 95 % des utilisateurs de Claude Code. Les deux couches suivantes l’aggravent.

Couche deux : mémoire – Le coffre-fort Obsidian et le CLAUDE.md qui l'exécute

La première couche organise ce que vous faites. La couche deux donne à Claude Code un endroit où se souvenir de ce qu'il a fait.

Je veux être prudent ici, car la « mémoire » est actuellement le concept le plus sophistiqué de l'écosystème des agents. Toutes les deux semaines, une autre startup expédie une « couche mémoire pour Claude », c'est-à-dire, après inspection, une base de données vectorielle avec un budget marketing. Pour 90 % des flux de travail personnels et en petites équipes, vous n’en avez pas besoin. Vous avez besoin d'un dossier de fichiers de démarques et d'un fichier de configuration indiquant à Claude Code ce qu'il contient.

Le modèle qui a finalement cliqué pour moi est l'approche Karpathy LLM Wiki — Andrej Karpathy a publié sa version le 3 avril 2026 et j'ai passé un week-end à reconstruire la mienne pour qu'elle corresponde. La forme est constituée de trois dossiers dans un coffre-fort Obsidian : raw/, wiki/, output/. Chaque dossier a un travail clair. Le LLM est le bibliothécaire et l'auteur. Il n'y a pas de base de données vectorielle, pas d'intégration, pas de stratégie de segmentation.

J'ai écrit cette approche en détail dans l'article Karpathy Obsidian RAG — cet article est une analyse approfondie de pourquoi cela fonctionne. Cette section explique comment il s'intègre dans le système d'exploitation agent en tant que couche mémoire.

Les trois dossiers et à quoi sert chacun d'eux

Le coffre-fort est très simple :

vault/
├── raw/                              # ingestion, no organization required
│   ├── video-summaries/
│   ├── scans/                        # morning-scan output lands here
│   ├── transcripts/
│   ├── research-clippings/           # Obsidian Web Clipper drops here
│   └── inbox/                        # everything else, sorted later
│
├── wiki/                             # codified knowledge, LLM-maintained
│   ├── index.md                      # master index, LLM-written
│   ├── claude-code/
│   │   ├── index.md
│   │   ├── skills.md
│   │   ├── hooks.md
│   │   └── agents.md
│   ├── brands/
│   │   ├── mejba-me-voice.md
│   │   ├── ramlit-positioning.md
│   │   └── colorpark-design-rules.md
│   └── ops/
│       ├── seo-rules.md
│       └── publishing-checklist.md
│
└── output/                           # final deliverables
    ├── posts/
    ├── briefs/
    └── decks/

raw/ est le dépotoir. Tout ce que je veux que Claude Code sache éventuellement sur les terrains ici, non trié. Transcriptions vidéo. Coupures Web (un clic via le Obsidian Web Clipper). Résultats de l'analyse quotidienne. Notes vocales aléatoires que je dicte en marchant. La friction d'ingestion est intentionnellement proche de zéro, car à la seconde où je dois réfléchir à où déposer quelque chose, j'arrête de classer les choses.

wiki/ est l'endroit où le LLM gagne sa vie. De manière récurrente (ou à la demande via une commande slash), Claude Code lit raw/, identifie le nouveau matériel qui n'a pas été intégré et met à jour le wiki. Il écrit des articles de style encyclopédique. Il gère le maître index.md. Il relie les concepts associés à l'aide de [[wiki-style links]] que Obsidian restitue de manière native. Le wiki est la compréhension compilée par le LLM de tout ce qui se trouve dans le coffre-fort, écrit dans un format que la prochaine session peut lire efficacement.

output/ est la ligne d'arrivée. Les derniers articles du blog vont ici. Les briefs clients vont ici. Les présentations des ateliers à venir sont ici. Tout ce qui a été livré. La raison pour laquelle il dispose de son propre dossier est que Claude Code puisse répondre rapidement « Qu'est-ce que j'ai expédié ? » sans explorer le reste du coffre-fort.

C'est toute la couche mémoire. Trois dossiers. Réduction. Gratuit. Portable.

Le CLAUDE.md au niveau du coffre-fort qui le relie

Le fichier unique qui rend cette couche fonctionnelle est le CLAUDE.md à la racine du coffre-fort. C'est la configuration qui indique à Claude Code ce qu'il y a dans les dossiers et comment les traiter. Sans cela, Claude doit deviner chaque session. Avec cela, vous réduisez vos jetons de configuration de contexte d'environ 70 %.

Voici ma structure réelle, légèrement expurgée :

# CLAUDE.md — Configuration du coffre-fort Agentic OS

## Objectif

Ce coffre-fort constitue la couche de mémoire persistante du système d'exploitation agent. C'est
maintenu conjointement par moi et Claude Code. Le coffre-fort comporte trois niveaux supérieurs
dossiers, chacun avec un rôle spécifique.

## Rôles de dossier

### brut/
Matériau source non traité. Traitez cela comme une ingestion uniquement.
- NE PAS modifier les fichiers en raw/ sauf pour en ajouter de nouveaux.
- NE PAS utiliser raw/ comme source principale pour répondre aux questions —
  vérifiez toujours wiki/ d'abord, puis revenez à raw/ si le wiki
  a un écart.
- Nouveau matériel de Obsidian Web Clipper, résumés vidéo et
  l'automatisation du scan matinal atterrit ici.

### wiki/
Connaissances codifiées, entretenues par Claude Code. Traitez cela comme le
principale source de vérité pour tout ce qui a été traité.
- Commencez toujours ici lorsque vous répondez à une question.
- Mettez toujours à jour wiki/index.md lorsque vous créez un nouvel article wiki.
- Utilisez des [[liens de style wiki]] pour croiser les concepts associés.
- Si vous trouvez une lacune dans le wiki en répondant à une question, notez
  au bas de l'index.md correspondant en tant que TODO.

### sortie/
Livrables finaux. Traitez ceci comme étant lu principalement.
- N'écrivez ici que lorsqu'on vous demande explicitement de produire un livrable.
- Lors de la production d'un nouveau message, vérifiez output/posts/ pour vous assurer
  la balle n'est pas déjà prise.

## Règles de flux de travail

1. Lorsque je demande un article de blog, lisez la section wiki correspondante
   d'abord, puis brut/pour tout nouveau matériel depuis la création du wiki
   dernière mise à jour, puis écrivez le brouillon dans output/posts/[slug].md.
2. Lorsque j'ajoute un nouveau matériau à raw/, ne le traitez pas automatiquement.
   Attendez que je lance /update-wiki.
3. Les règles vocales de la marque sont disponibles dans wiki/brands/.. Chargez toujours le
   pertinent avant d'écrire avec la voix de cette marque.
4. Les règles de référencement sont disponibles dans wiki/ops/seo-rules.md. Appliquez-les à chaque publication.

## Marques actives
- mejba.me (personnel, à la première personne, passionné)
- ramlit.com (entreprise, troisième personne, axé sur les résultats)
- colorpark.io (design, opiniâtre, visuel)
- xcybersecurity.io (sécurité, faisant autorité, urgent)

Ce fichier fait peut-être 60 lignes. Cela fait plus pour la cohérence de mes résultats que n'importe quelle compétence que j'ai écrite. La raison est simple : cela élimine les devinettes. Claude Code n'a pas besoin de déterminer où se trouvent les choses, à quoi sert chaque dossier ou comment gérer les demandes ambiguës. Les règles sont dans le fichier, le fichier est chargé à chaque session et chaque sous-agent hérite du contexte.

Si vous souhaitez écrire un fichier de configuration pour l'ensemble de votre configuration, écrivez celui-ci.

Ce que j'ai essayé en premier et abandonné

Deux expériences de mémoire qui n'ont pas survécu au contact du travail réel.

Premièrement : j'ai essayé de stocker de la mémoire dans une base de données vectorielle Supabase avec un serveur MCP personnalisé. Supabase comme magasin de vecteurs, intégrations OpenAI, récupération sémantique sur mes notes. Cela a fonctionné. Il était également extrêmement sur-conçu pour ce dont j'avais réellement besoin, c'est-à-dire "rappelez-vous ce que nous avons décidé mardi dernier". La qualité de la récupération était activement pire que de simplement laisser Claude Code lire directement la démarque, car les morceaux trancheraient le milieu de la phrase et les scores de similarité feraient apparaître des quasi-doublons au lieu de la note la plus utile. Après deux week-ends de réglage, j'ai tout supprimé.

Deuxièmement : j'ai essayé de demander à Claude Code de traiter automatiquement chaque nouveau fichier brut au moment où il était ajouté - un hook PostToolUse qui déclencherait une mise à jour du wiki à chaque écriture dans raw/. Le coût était brutal. Chaque fois que je coupais un long article, cela engendrait une session qui lisait l'article, décidait de sa place dans le wiki, écrivait parfois un nouvel article, parfois mettait à jour un article existant. Certaines de ces sessions contenaient plus de 30 000 jetons. Faire cela des dizaines de fois par jour a brûlé des crédits sans fournir de valeur proportionnelle, car la plupart des coupures n'ont pas besoin d'être traitées le jour même de leur sauvegarde.

Le correctif était la commande explicite /update-wiki dans le CLAUDE.md ci-dessus. Je le lance une fois par semaine, le dimanche. Il regroupe toutes les matières premières non traitées en une seule session, et le rapport coût par information diminue d'environ 10 fois.

La leçon : les couches de mémoire échouent soit en raison d'une architecture excessive (bases de données vectorielles), soit d'un excès d'empressement (traitement automatique de chaque entrée). La structure des dossiers Karpathy plus un CLAUDE.md clair plus une commande de mise à jour manuelle est le milieu ennuyeux qui fonctionne réellement.

C'est la deuxième couche. Trois dossiers, un fichier de configuration, une habitude hebdomadaire. Maintenant, le système a une continuité.

Couche trois : observabilité – un tableau de bord qui expose le système d'exploitation aux humains

La première couche organise ce que vous faites. La couche deux se souvient de ce que vous avez fait. La couche trois est la partie qui compte lorsque vous cessez d'être le seul utilisateur.

Je vais être honnête : j'ai construit la troisième couche en dernier lieu, et pendant longtemps, je n'ai pas pensé que j'en avais besoin. J'étais le seul opérateur. J'habitais dans le terminal. Le terminal était bien. Ensuite, j'ai essayé de confier l'automatisation de l'analyse matinale à une coéquipière afin de pouvoir partir en vacances pendant une semaine, et l'ensemble du système s'est effondré non pas à cause d'une défaillance technologique, mais parce qu'elle a dû apprendre trois commandes CLI, une structure de coffre-fort et la différence entre une commande slash et un sous-agent avant de pouvoir exécuter une tâche.

Le terminal est un fossé. Pour moi, c'est une fonctionnalité. Pour tout le monde, c'est un mur.

Un tableau de bord est la troisième couche d'un système d'exploitation agentique, car c'est la couche qui permet au système de servir les personnes qui ne veulent pas taper claude -p "..." pour gagner leur vie. Cela inclut les coéquipiers non techniques, les clients, votre futur un dimanche matin lorsque la frappe ressemble à du travail, et toute personne souhaitant voir ce que fait le système sans consulter les fichiers journaux.

Ce que fait réellement le tableau de bord

Il n’existe pas encore un seul tableau de bord officiel Claude Code. Depuis mai 2026, Anthropic fournit la pile de surveillance Claude Code via OpenTelemetry – huit métriques, dont le nombre de sessions, l'utilisation des jetons, le coût estimé et la durée d'activité – et un écosystème sain de couches d'observabilité construites par la communauté (le projet claude-code-otel est celui que j'ai le plus utilisé). Ce que personne ne livre immédiatement, c'est la surface de contrôle — la partie qui expose vos compétences et vos automatisations sous forme de boutons.

Vous construisez donc cette partie vous-même. La forme qui a le mieux fonctionné pour moi est une petite application Next.js (peut-être 600 lignes au total) qui fait quatre choses :

1. ** Expose chaque compétence et automatisation sous la forme d'un bouton cliquable. ** Cliquez sur "Morning Scan" et le tableau de bord s'affiche sur claude -p "/morning-scan" (ou accède au SDK de l'agent Claude par programme). La sortie est renvoyée dans le UI. 2. Suite l'utilisation. Quand chaque compétence a-t-elle été exécutée pour la dernière fois ? Combien de temps cela a-t-il pris ? Combien de jetons cela a-t-il coûté ? Quelles automatisations ont fonctionné dans les délais et lesquelles ont échoué silencieusement ? 3. Face aux modifications récentes du coffre-fort. Qu'est-ce qui a été ajouté à raw/ au cours des dernières 24 heures ? Qu'est-ce que le dernier /update-wiki a changé dans wiki/ ? Qu'est-ce qui a été publié sur output/posts/ cette semaine ? 4. Lien chaque sortie dans Obsidian. Chaque résultat affiché par le tableau de bord comporte un lien « Afficher la source » qui ouvre le fichier de démarque pertinent dans Obsidian.

Traçabilité complète : chaque réclamation que le système fait apparaître pointe vers le dossier d'où provient la réclamation.

Ce dernier est le plus important. Sans cela, le tableau de bord devient une autre boîte magique dans laquelle AI fait des choses et vous lui faites confiance. Grâce à lui, chaque sortie est auditable en un clic. Vous voyez le résultat, vous cliquez sur la source, vous lisez la démarque lue par l'agent. Aucune hallucination ne peut se cacher.

Ce que le tableau de bord n'a PAS besoin de faire

Je tiens à signaler cela parce que j'y ai consacré un mois. Le tableau de bord n'a pas besoin d'être :

• Un outil complet de gestion de projet. Ce n'est pas linéaire. Ce n'est pas un remplacement pour votre outil de suivi des tâches. Il s’agit d’une surface de contrôle pour votre système d’exploitation agent, point final.
• Une plateforme d'analyse. Le suivi des dépenses en jetons est utile. Un entrepôt d’analyse personnalisé ne l’est pas.
• Un SaaS multi-tenant. Si vous en créez un, vous passerez trois mois sur l'authentification et zéro mois sur les améliorations réelles du flux de travail.
• Un outil de collaboration multi-utilisateurs en temps réel. Vous êtes l'opérateur. Le tableau de bord est destiné à vous et peut-être à un ou deux collaborateurs de confiance.

Le tableau de bord que j'ai créé est une application Next.js d'une seule page avec une seule route, sans authentification (elle est uniquement locale) et une instance Postgres pour les journaux d'utilisation. Temps total de construction : environ 14 heures, réparties sur deux week-ends. Il fait les quatre choses ci-dessus. Rien d'autre.

Les indicateurs qui comptent réellement

Sur les huit métriques exportées nativement par Claude Code, quatre s'affichent sur l'écran d'accueil de mon tableau de bord :

• Jetons dépensés par compétence et par semaine. Il s'agit de la mesure qui détecte les automatisations qui deviennent malveillantes. La semaine où le hook auto-wiki s'est déclenché, ce graphique a augmenté 3x et j'ai pu voir exactement quelle compétence était responsable.
• Nombre d'exécutions par automatisation. Quelles automatisations s'exécutent réellement et lesquelles j'ai discrètement arrêté d'utiliser. Si un automatisme hebdomadaire ne s'est pas déclenché depuis trois semaines, il est mort et je le supprime.
• Vault delta. Combien de fichiers ont été modifiés dans raw/, wiki/, output/ cette semaine. C'est la chose la plus proche de "le système fonctionne-t-il réellement" que j'ai trouvé.
• Horodatage de la dernière exécution par compétence. Quand l'ai-je invoqué pour la dernière fois ? Les compétences que je n'ai pas exécutées depuis 60 jours sont archivées. Le système devrait être un organisme vivant et non un musée.

Les quatre autres métriques (nombre de PR, lignes de code, décisions de modification du code, temps d'activité) sont utiles pour les équipes d'ingénierie mais moins utiles pour une opération de contenu. Votre kilométrage variera en fonction de vos domaines.

Ce que je construirais si je commençais aujourd'hui

Si je reconstruisais le tableau de bord à partir de zéro en mai 2026, je commencerais par l'une des piles d'observabilité open source Claude Code - claude-code-otel de Cole Murray plus Grafana est une base solide - et boulonnerais la surface de contrôle par-dessus. La partie observabilité est résolue par le travail communautaire. La surface de contrôle est la partie que vous devez écrire vous-même, car elle est spécifique à vos compétences et automatisations.

N'essayez pas de tout construire dès la première semaine. Le tableau de bord devrait être ce que vous recherchez lorsque l’exécution du système d’exploitation dans le terminal ne semble plus rapide. Si vous êtes toujours satisfait du terminal, vous n’en avez pas encore besoin.

C'est la troisième couche. Une surface de contrôle qui expose le système d'exploitation aux humains, avec une traçabilité jusqu'au coffre-fort. Construisez-le en dernier, construisez-le petit, construisez-le pour un seul utilisateur.

Quand toute cette structure est réellement payante

J'ai écrit comme si tout le monde devait construire les trois couches. Ils ne devraient pas. Le système d’exploitation agentique s’avère payant dans des situations spécifiques et excessif dans d’autres. Évaluation honnête :

Construisez les trois couches si vous :

• Gérer plus d'une marque ou un projet majeur (la structure se compose de chacun)
• Confiez le travail à des coéquipiers, des clients ou des sous-traitants qui ne vivent pas dans un terminal
• Produire des livrables récurrents selon un planning (articles de blog, briefs, audits, scans)
• Vous vous êtes surpris à réexpliquer la même chose à Claude Code plus de trois fois

Construisez uniquement la première couche si vous :

• Êtes un opérateur solo avec un projet principal
• Utilisez principalement Claude Code pour des tâches de codage ponctuelles
• Vous en êtes à votre premier mois d'utilisation sérieuse de Claude Code (donnez-lui du temps avant d'ajouter une architecture)

Ignorez tout cela si vous :

• Utilisez Claude Code occasionnellement pour des projets personnels sans sorties récurrentes
• Vous êtes encore en train de déterminer quels sont vos domaines et vos tâches
• Vous voulez d'abord apprendre la plateforme : la surstructuration avant de comprendre les primitives est le deuxième moyen le plus rapide d'abandonner la plateforme.

La raison pour laquelle le système d’exploitation est particulièrement rentable pour moi est que je gère quatre marques et que j’envoie environ 250 publications longues par an. Sans structure, la variance me tue. Avec cette structure, chaque marque a une voix stable, chaque publication part du même échafaudage et le temps par publication passe de « un après-midi complet » à « quatre-vingt-dix minutes, recherche comprise ». C'est le calcul qui fait que les frais généraux architecturaux en valent la peine.

Si vos calculs sont différents, la réponse est différente. Je veux m'assurer que je ne vends pas quelque chose dont personne n'a besoin.

Ce que je sauterais le premier jour

On me demande sans cesse « par où commencer ? » et je continue de donner la même réponse, alors permettez-moi de la rendre explicite. Si vous lisez cet article et décidez de créer un système d'exploitation agentique, voici ce qu'il faut faire cette semaine :

Premier jour, cette semaine, uniquement. Choisissez un domaine. Juste un. La chose que vous faites le plus souvent dans Claude Code en ce moment. Pour moi, c'était la création de contenu. Pour vous, il peut s'agir de révision de code, de recherche ou de travail de conception. Choisissez-en un.

À l'intérieur de ce domaine, identifiez trois tâches. Les trois choses que vous faites réellement de manière récurrente dans ce domaine. Pas de tâches théoriques. Des choses que vous avez faites au moins quatre fois au cours du mois dernier.

Écrivez une compétence par tâche. Utilisez le format ci-dessus. Quarante lignes maximum. Le but est de supprimer la variance, pas d'être intelligent. Enregistrez-les dans .claude/skills/.

Écrivez un seul CLAUDE.md. Un paragraphe par tâche expliquant ce que vous voulez et où doit aller le résultat. Pas un livre. Une page.

Arrêtez-vous là.

Ne construisez pas encore le coffre-fort. Ne créez pas encore le tableau de bord. Ne créez pas d'automatisations. Utilisez l'architecture pendant deux semaines. Faites attention à l'endroit où il se brise et à l'endroit où il chante. Ajustez les compétences en fonction de ce que vous apprenez de l’utilisation réelle.

Au bout de deux semaines, si l'architecture a tenu, vous commencerez à ressentir l'absence de mémoire. C'est à ce moment-là que vous construisez le coffre-fort. Après deux semaines supplémentaires, si vous travaillez avec quelqu'un d'autre, vous commencerez à ressentir l'absence du tableau de bord. C'est à ce moment-là que vous créez le tableau de bord.

L’intérêt complexe de cette approche est que chaque couche résout un problème que vous avez déjà ressenti. Vous ne construisez pas d’infrastructure spéculative. Vous comblez des lacunes que vous pouvez nommer.

Ce que cela change dans la façon dont vous utilisez Claude Code

Le changement le plus profond produit par le système d’exploitation agentique n’est pas tactique. C'est psychologique.

Avant d'avoir cette structure, chaque session Claude Code avait l'impression qu'elle pouvait aller dans n'importe quelle direction. J'ouvrais le terminal avec une vague intention, je tapais quelque chose et je laissais le modèle faire ce qu'il voulait. La variance ressemblait à de la créativité. Ce n'était pas le cas. C'était du hasard avec de bonnes relations publiques.

Après la structure, chaque séance a une forme. J'ouvre Claude Code en sachant quelle compétence va s'exécuter, quel sous-agent va la gérer, dans quel dossier la sortie va atterrir et quel agent en aval va la récupérer ensuite. La session ressemble moins à une incitation qu’à une répartition. Je ne collabore plus avec une machine à sous. Je gère un organigramme.

Ce changement, plus que n'importe quel outil ou astuce individuel, est ce qui a fait passer Claude Code d'« outil intéressant » à « système d'exploitation » pour moi. C’est la méthodologie qui m’y a amené. Ce sont les trois couches qui le maintiennent en place.

Si vous êtes actuellement au stade des machines à sous, voici la seule chose que je veux que vous reteniez de cet article : la sortie n'est pas une meilleure invite. C'est une meilleure architecture. Choisissez un domaine cette semaine. Écrivez trois compétences. Écrivez un CLAUDE.md. Arrêtez de tirer le levier et commencez l’opération.

Je serai dans le terminal, mais je ne joue plus.

Questions fréquemment posées

Qu'est-ce qu'un système d'exploitation agent dans Claude Code ?

Un système d'exploitation agentique est un cadre structuré qui transforme Claude Code d'invites ad hoc en un système en couches avec trois couches : architecture (domaines, tâches, compétences, automatisations), mémoire (un coffre-fort Obsidian avec des dossiers bruts, wiki et de sortie plus un CLAUDE.md au niveau du coffre-fort) et observabilité (un tableau de bord qui expose les compétences et les automatisations sous forme de boutons cliquables avec des métriques d'utilisation). Il utilise les primitives natives de Claude Code telles que les compétences, les sous-agents, les hooks et les commandes slash plutôt que des outils personnalisés. Pour la présentation complète de la mise en œuvre, consultez la répartition en trois couches ci-dessus.

Ai-je besoin d'un coffre-fort Obsidian pour utiliser efficacement Claude Code ?

Non – Obsidian est une bonne option pour la couche mémoire, pas une exigence. La couche du coffre-fort est simplement un dossier de fichiers markdown avec un CLAUDE.md au niveau du coffre-fort indiquant à Claude Code à quoi sert chaque dossier. Vous pouvez implémenter la même structure dans n’importe quel dossier simple ; Obsidian ajoute une visualisation gratuite et conviviale, des liens de style wiki et Web Clipper pour l'ingestion.

En quoi une compétence Claude Code est-elle différente d'une commande slash ?

Une compétence est un fichier SKILL.md avec un frontmatter YAML qui décrit une tâche répétable et est chargé automatiquement le cas échéant. Une commande slash est un fichier markdown dans .claude/commands/ que vous appelez explicitement avec /command-name. Les compétences concernent la capacité ; Les commandes slash concernent l'invocation. La plupart des systèmes bien construits possèdent des compétences qui sont déclenchées par des commandes slash.

Qu'est-ce qu'une automatisation Claude Code et comment en créer une ?

Une automatisation est une compétence qui s'exécute sur un déclencheur au lieu d'attendre que vous l'invoquiez. Le moyen le moins cher d'en connecter un est via un hook dans .claude/settings.json - un hook SessionStart ou PostToolUse qui déclenche la commande slash appropriée. Pour les automatisations planifiées, une tâche cron envoyée à claude -p "/your-command" fonctionne correctement. Le SDK de l'agent Claude fournit une version programmatique lorsque vous dépassez cette capacité.

Combien coûte l'exécution d'un système d'exploitation agentique sur Claude Code ?

La première couche (architecture) ne coûte rien de plus : vous payez quand même pour Claude Code. La couche deux (coffre-fort) est gratuite si vous utilisez Obsidian. La couche trois (tableau de bord) correspond uniquement à votre coût d'hébergement - généralement inférieur à 10 /month pour une configuration à opérateur unique. Le coût variable provient des automatisations : une automatisation mal réglée peut doubler vos dépenses en jetons, c'est pourquoi je plafonne les automatisations à quatre et examine les métriques de jeton par compétence chaque semaine.

Puis-je confier un système d'exploitation agent à un coéquipier non technique ?

C’est exactement pour cela que la couche trois (le tableau de bord) est conçue. Le terminal est un fossé pour les opérateurs techniques et un mur pour tous les autres. Un tableau de bord qui expose les compétences et les automatisations sous forme de boutons, avec une sortie diffusée dans le UI et des liens sources vers le Obsidian, permet à un coéquipier non technique d'exécuter le système sans jamais toucher le CLI. Sans le tableau de bord, le transfert est pénible.

Travaillons ensemble

Vous cherchez à créer des systèmes AI, à automatiser les flux de travail ou à faire évoluer votre infrastructure technologique ? J'aimerais aider.

• Fiverr (versions et intégrations personnalisées) : fiverr.com/s/EgxYmWD
• Portefeuille : mejba.me
• Ramlit Limited (solutions d'entreprise) : ramlit.com
• ColorPark (conception et image de marque) : colorpark.io
• xCyberSecurity (services de sécurité) : xcybersecurity.io