Skip to content
Back to skills

Grill

ASecurity

L'initialisation et l'architecture du projet : initialiser un projet bâti sur le framework Roomi's Grillhouse — préparer le dépôt, mener le grill d'initialisation, puis écrire la charte, l'architecture, le cadre, les interfaces et le lexique, et ouvrir les premiers tickets. À charger au premier lancement d'un projet neuf ou d'un projet existant qui adopte le framework, quand l'ouverture de séance liste des éléments « pas encore renseignés » (critères d'arbitrage, champs de la charte, architec...

  • 2 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 18, 2026
developmenttypescriptpythongonodeapidocumentation

Works with

  • api

Security analysis

A100/100

Pro scans all 3 files and shows the line behind each finding

Scanned November 18, 2026

npx -y skills add roomi-fields/roomis-grillhouse --skill grill --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Grill?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Grill
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/roomi-fields-grill/badge)](https://www.skillsdirectory.com/skills/roomi-fields-grill)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: grill
description: "L'initialisation et l'architecture du projet : initialiser un projet bâti sur le framework Roomi's Grillhouse — préparer le dépôt, mener le grill d'initialisation, puis écrire la charte, l'architecture, le cadre, les interfaces et le lexique, et ouvrir les premiers tickets. À charger au premier lancement d'un projet neuf ou d'un projet existant qui adopte le framework, quand l'ouverture de séance liste des éléments « pas encore renseignés » (critères d'arbitrage, champs de la charte, architecture, cadre, interfaces, lexique), quand le responsable demande d'initialiser ou de redéfinir ces éléments, et pour toute question de structure (découper en paquets ou modules, définir une interface, une frontière, l'architecture)."
---

# Grill — initialiser le projet et décider de sa structure

Le framework fournit les outils et les compétences, et `${CLAUDE_PLUGIN_ROOT}/METACADRE.md` les intentions qu'ils servent ;
l'initialisation leur donne leur objet. Lis le métacadre avant le premier tour : chaque
recommandation du grill sert une de ses intentions. L'initialisation produit les éléments clés que
les compétences `pitmaster` et `developpeur` lisent à chaque séance :

| élément | ce qu'il fixe |
|---|---|
| `CLAUDE.md` | la charte du projet : le projet, le responsable, ce qui décide, ses critères d'arbitrage, ses commandes ; la charte commune du cadre, qu'elle importe du paquet installé (`@node_modules/@roomi-fields/grillhouse/charte.md`), la complète et ne se modifie pas |
| `docs/ARCHITECTURE.md` | comment le projet est construit, et pourquoi |
| `docs/CADRE.md` | le rôle de chaque composant, sa frontière, ce qu'il refuse (R1…) |
| `docs/INTERFACE.md` | ce qui traverse chaque frontière, et le garde qui le tient |
| `CONTEXT.md` | le lexique du domaine |

Dans un dépôt à plusieurs paquets, le cadre, l'interface et l'architecture de chaque paquet vivent
sous `packages/<x>/docs/`, et `docs/ARCHITECTURE.md` décrit l'ensemble.

## 0. Tout le projet, ou les seuls éléments vides

À chaque ouverture de séance, la liste « Pas encore renseignés » dit ce qui reste vide. Un projet
neuf passe par toutes les sections ci-dessous. Un projet déjà engagé grille les éléments listés, ou
celui que le responsable choisit, à n'importe quel moment : le relevé (§3) porte sur ce que
l'élément touche, le grill (§4) sur ses branches, l'écriture (§5) sur son document. Ainsi chaque
élément de l'architecture est décidé et écrit avant que le code en ait besoin.

**Une proposition à corriger** : chaque question arrive avec sa proposition, tirée du projet et de
son domaine. Pour les critères d'arbitrage (branche 2), cherche dans le code, les documents, les
projets voisins et la documentation publique les produits matures qui font le même travail, les
standards et outils en usage, les exigences mesurables du domaine, et propose-les nommément. Ainsi
le responsable corrige une proposition et garde son temps pour les vraies décisions.

## 1. Préparer le dépôt

Un projet neuf naît de `npx @roomi-fields/grillhouse init <dossier> [préfixe]` : le gabarit, les
tickets, l'index, les greffons et les crochets. S'il manque ensuite un élément, l'ouverture de séance
le signale sous « Manque », chacun avec sa commande, sans invite : `npx grillhouse maj` installe pour
le projet chaque greffon que `.claude/settings.json` déclare (`enabledPlugins`), après son
marketplace, et met le greffon du cadre à la version du paquet ; elle finit par `npm run verifier`,
une passe longue : lance-la en tâche de fond et relis son code à la fin. Le préfixe des tickets vient du nom du projet ; il se confirme au premier tour du grill.

## 2. La règle de l'architecture

- **Un petit projet se structure comme un grand** : ses composants, ses frontières et ses
  interfaces se décident sur ses objectifs et sur la construction de son code, comme pour un grand
  projet. Ainsi le projet est propre, pro et mature dès sa première ligne, et le reste en
  grandissant.
- **Les pièces d'abord** : chaque recommandation s'appuie sur une lecture de la construction du
  code, avec ses fichiers et ses symboles. Ainsi elle repose sur une preuve ; un compte de lignes,
  de fichiers ou d'imports ne fonde aucune recommandation.
- **Une question reportée nomme son fait** : reporter une question nomme le fait qui la rouvrira et
  ce qu'elle coûtera alors. Ainsi le report est une décision écrite de l'architecture, que le
  responsable peut juger.
- **Une frontière interne a son interface** : une frontière entre deux modules internes a son
  interface, tenue par le cadre et un test, comme une interface publiée. Ainsi le code suit
  l'architecture à l'intérieur du projet aussi.
- **Un découpage se justifie par ses pièces** : un rôle, un consommateur (dans le dépôt ou hors de
  lui), une raison de changer, une donnée qui traverse. Une fusion se justifie de même : deux
  parties qui changent toujours ensemble, qu'aucun consommateur ne sépare. Ainsi chaque frontière
  découle de l'architecture.
- **Les mots de la structure** : tu charges `grillhouse:codebase-design` avant le grill et tu
  emploies ses mots (module, interface, profondeur, jointure). Ainsi le responsable et les agents
  parlent de la structure avec les mêmes mots.
- **Chaque recommandation cite sa référence mature** : elle dit ce que ferait le produit mature du
  domaine (un compilateur mature, un DAW professionnel, selon le contexte), ce qui existe déjà, et
  ce qu'exige le domaine (la rapidité pour le live coding). Ainsi le responsable arbitre sur pièces,
  sans refaire l'enquête.

### Les façons de penser

- **Comme le produit mature** : avant de proposer un découpage, décris ce que ferait, et comment est
  structuré, le produit professionnel et mature qui fait le même travail (pour un transpileur :
  TypeScript ; pour un moteur audio : une station audionumérique professionnelle). Ta proposition
  dit en quoi elle le suit, et pourquoi elle s'en écarte. Ainsi le découpage repart de ce qui a
  fait ses preuves.
- **Un tout cohérent, une seule API** : un projet qui forme un tout cohérent publie un seul paquet,
  avec une API choisie et maîtrisée par lui. À l'intérieur, ses composants sont des modules, chacun
  avec son interface et ses tests ; un composant se publie à part quand il vit hors du produit.
  Ainsi le découpage interne sert l'architecture, et la publication sert les consommateurs.
- **L'existant d'abord** : on se base sur l'existant. Les conventions des projets voisins de
  l'auteur (organisation des paquets, numérotation, outils, vocabulaire) se reprennent avant toute
  invention, par exemple des dossiers de paquets numérotés comme dans un projet voisin. Ainsi le produit
  hérite de ce qui marche déjà.

## 3. Relever l'existant

**Les faits se cherchent** dans le code et les documents ; seules les décisions se posent au responsable. Ainsi il ne reçoit que des décisions.

**Le relevé structurel vient avant le premier tour** : un sous-agent (Explore, « very thorough ») rend le relevé décrit dans `references/releve-structurel.md`, et tu le juges avec `mesure` ; un relevé fait de comptes se refait. Ainsi l'architecture se décide sur une preuve.

**Le relevé dit ce qui est** : il décrit la construction réelle, défauts compris ; le grill décide
ce qui doit être. Ainsi chaque décision part de l'état réel du code.

## 4. Le grill d'initialisation

Charge `grillhouse:grilling` et suis-le : des tours numérotés, chaque
question avec ta recommandation et ses pièces, la frontière de l'arbre des décisions à chaque tour.
**Le grill se mène en entier**, par tours, même quand le responsable pose la question en une
phrase. Ainsi chaque décision de structure passe par l'architecture, et une réponse directe ne
remplace jamais le grill. Les branches de l'arbre :

1. **Les objectifs** — ce que le projet doit permettre, à qui, à quel horizon ; ce qui doit rester
   vrai dans cinq ans ; ce qu'il ne fait pas (ce que fait un autre système à sa place).
2. **Les références et les exigences** — les produits matures qui font référence dans le domaine
   (ce qu'un compilateur mature, une station audionumérique professionnelle… font du même
   problème), les standards et outils existants à reprendre, les exigences propres au domaine
   (temps de réponse, fiabilité en direct, compatibilité). Elles remplissent « Comment on arbitre »
   de la charte et arbitrent toutes les branches suivantes.
3. **Le responsable** — son nom, les documents qu'il valide, la politique de poussée.
4. **Ce qui décide** — la source d'autorité (une spécification, une cible, un produit de
   référence), puis le cadre, puis le code.
5. **Les consommateurs** — qui utilise le projet ou une de ses parties, aujourd'hui et demain
   (un éditeur, un autre dépôt, une ligne de commande) ; chacun dit une frontière.
6. **Les représentations** — les données qui traversent la chaîne de traitement : texte, arbre,
   graphe, sortie ; où chacune naît, qui la lit. Chaque étape reçoit une structure ; une étape qui
   ré-analyse du texte signale une frontière manquante.
7. **Les axes de changement** — ce qui changera (une syntaxe, une cible, un catalogue, un hôte) ;
   deux axes indépendants vivent dans deux modules.
8. **Les composants** — le découpage qui découle des branches 5 à 7, chaque frontière avec ses
   pièces ; pour chacun, les huit rubriques du cadre : rôle, reçoit, rend, connaît, ne connaît pas,
   refuse, invariants, coût. Puis la forme : un paquet ou plusieurs, bibliothèque ou service (un
   service garde `deployment/`, le démon et `.env`), et son langage (la rubrique suivante le déclare).
   **Le langage de chaque paquet** : le tableau des composants de `docs/ARCHITECTURE.md` porte une
   colonne « Langage » (`typescript`, `cargo`, `python`), une ligne par paquet, comme le fichier BUILD de
   Bazel nomme la règle de chaque cible ; le cadre lit là les langages du projet, rien ne se devine
   aux fichiers, et un projet qui n'en déclare aucun est refusé. L'`INTERFACE.md` de chaque paquet
   le reprend (`**Langage** : <nom>`). La garde `grillhouse langages-des-paquets` refuse un paquet
   que le tableau ne déclare pas, un paquet dont le manifeste suit un autre langage (un
   `package.json` pour `typescript`, un `Cargo.toml` pour `cargo`, un `pyproject.toml` pour
   `python`), un dossier déclaré sans ce manifeste, et une interface qui en nomme un autre.
   **Un paquet neuf naît en quatre temps, hors du circuit** (charte commune) : ce grill tranche
   son rôle, sa frontière, ses refus, son interface et son langage (1) ; le superviseur écrit sa
   ligne et ses documents, relus par le responsable (2) ; `npx grillhouse paquet <chemin>` bâtit
   son squelette et, pour le premier paquet d'un langage, les outils de ce langage (3), dans le
   même commit que 2 ; son code part en ticket ordinaire (4).
   Les mécanismes d'un paquet — sa forme publiée, les outils du projet, le corpus et ses données, les traces, Turborepo et la configuration Vitest — sont dans `references/paquets.md`, à lire au moment de créer un paquet.
9. **Les interfaces** — pour chaque frontière : ce qui la traverse, qui offre, qui consomme, qui
   juge quelle faute, et le garde qui la tiendra.
   **Une fois les composants décidés**, la nuit du projet tourne sans rien à écrire : la
   planification des nuits du poste (`npx grillhouse nuit --planifier`, une fois par poste, à 1 h
   sauf `--heure <0-23>`) lance la nuit de chaque projet du registre
   qui a bougé depuis sa dernière nuit verte, l'un après l'autre ; `npx grillhouse nuit <racine>`
   la demande à la main. La nuit rejoue pour de vrai la passe complète, puis les tests de nuit et
   les bancs de budget, que le jour ne joue pas. La CI de
   chaque branche de ticket (`agent/**`, qu'elle écoute) joue `npm run verifier` en entier (les
   gardes, le typage de chaque paquet et les tests) avant que main avance.
   Restent des choix selon la taille du projet, que le responsable tranche :
   - **le contrôle de l'interface contre le code** (`packages/grillhouse/scripts/langages/typescript/interfaces-contre-code.mjs`) : une
     seule passe avant les tests (petit projet), ou un banc par composant qui appelle
     `verifierComposant`, rejoué seulement quand son composant l'est (grand projet).
   - **les sous-modules partagés** : un sous-module qu'aucun ticket n'écrit (un moteur de
     référence, une dépendance externe) se déclare partagé, `npm pkg set 'grillhouse.partage[0]=<chemin>'` ;
     chaque copie le lit alors dans le dépôt principal, en lecture seule
     (`packages/grillhouse/scripts/sous-modules.sh`).
10. **L'architecture** — les trois ou quatre choix qui commandent le reste, chacun avec sa raison et
   l'objectif qu'il sert ; les données centrales ; où le code tourne.
11. **Le lexique** — les mots du domaine dont la définition change du code
    (`grillhouse:domain-modeling`).
12. **Le premier chantier** — ce qui se construit d'abord, et ce qui attend.

**La fin du grill** : le grill est fini quand la frontière est vide, que chaque composant et chaque
frontière porte ses pièces, que chaque recommandation cite sa référence mature et repose sur une
lecture du code, et que le responsable confirme la compréhension partagée. L'écriture commence
ensuite. Ainsi les documents écrivent des décisions prises.

## 5. Écrire

- Les documents lus par un humain s'écrivent avec la compétence `redacteur` (référence
  « Les documents d'un composant ») ; la charte avec `grillhouse:writing-for-agents`.
- **Les champs de la charte** : chaque champ `<…>` de la charte modèle reçoit sa valeur. Ainsi la
  charte cadre les agents dès la séance suivante.
- `package.json` (nom, description, auteur, dépôt), `README.md`, `LICENSE`, `CREDITS.md`,
  `CHANGELOG.md` et `CONTRIBUTING.md` prennent l'identité du projet.
- **Les règles de dépendance propres au projet** (un paquet qui n'importe rien, une couche qui ne
  lit qu'en type) et ses options de la carte (`exclude`, `doNotFollow`…) s'écrivent dans
  `.dependency-cruiser.projet.cjs` ; les règles communes sont générées
  (`npx grillhouse frontieres --ecrire`). Ainsi chaque règle de structure décidée au grill est
  tenue par un test.
- **Ce que la forme écarte se retire** dans le même commit (les parties de service d'une
  bibliothèque, le code d'exemple du modèle, `src/` et ses tests `tests/unit/config.spec.ts`,
  `errors.spec.ts`, `types.spec.ts` ; les tests du cadre restent à Grillhouse et n'arrivent pas
  dans le projet). Ainsi le dépôt contient seulement ce que
  l'architecture décidée garde.
- **Le responsable relit ses documents** : chaque document se relit au responsable avant son
  commit, puisqu'il les valide. Ainsi il tranche l'essentiel avant que le code ne s'y appuie.

## 6. Ouvrir le travail

- **Les premiers tickets attendent son mot** : une épopée pour le premier chantier ; ses tickets
  s'ouvrent sous l'étiquette `a-valider`, chacun avec les règles et les documents qu'il touche,
  et chaque réalisation avec ses critères d'acceptation numérotés (`docs/agents/issue-tracker.md`).
  Ainsi le premier chantier part avec l'accord du responsable.
- `pitmaster/SUIVI.md` : le premier tour, les questions restées ouvertes.
- Un commit `docs: initialiser le projet` qui ne contient que ces éléments.

À la fin, l'ouverture de séance ne signale plus rien : la séance suivante charge `pitmaster`.

Files in this skill

  • SKILL.md15.4 KB
  • references/paquets.md5.2 KB
  • references/releve-structurel.md2.5 KB

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in development →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.