Communitygithub.com

enregistrements-de-decisions-architecturales

Capturez les décisions architecturales prises lors des sessions Claude Code sous forme d'ADR structurés. Détection automatique des moments de décision, enregistrement du contexte, des alternatives envisagées et de la justification. Maintient un journal ADR pour que les développeurs futurs comprennent pourquoi la base de code est façonnée de la sorte.

Qu'est-ce que enregistrements-de-decisions-architecturales ?

Cette compétence permet de capturer et documenter les décisions architecturales prises pendant les sessions de développement avec Claude Code, Cursor, ou d'autres assistants IA. Elle détecte automatiquement les moments de décision explicites ("enregistrons cette décision") ou implicites (comparaison de frameworks, choix de base de données, etc.) et guide l'utilisateur dans la création d'un document ADR structuré au format Michael Nygard. La compétence gère le cycle de vie complet des ADRs (proposé, accepté, déprécié, remplacé), maintient un index dans docs/adr/README.md, et permet de consulter les décisions passées. Elle évite que les décisions architecturales ne se perdent dans des threads Slack ou des commentaires de PR, offrant aux développeurs futurs un contexte clair sur le pourquoi des choix techniques.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/architecture-decision-records

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Enregistrements de Décisions Architecturales (ADR)

Capturez les décisions architecturales au fur et à mesure qu'elles se produisent lors des sessions de codage. Au lieu que les décisions ne vivent uniquement dans des threads Slack, des commentaires de PR ou la mémoire de quelqu'un, cette compétence produit des documents ADR structurés qui vivent aux côtés du code.

Quand Activer

  • L'utilisateur dit explicitement "enregistrons cette décision" ou "ADR ceci"
  • L'utilisateur choisit entre des alternatives significatives (framework, bibliothèque, pattern, base de données, conception d'API)
  • L'utilisateur dit "nous avons décidé de..." ou "la raison pour laquelle nous faisons X au lieu de Y est..."
  • L'utilisateur demande "pourquoi avons-nous choisi X ?" (lire les ADRs existants)
  • Pendant les phases de planification où les compromis architecturaux sont discutés

Format ADR

Utilisez le format ADR léger proposé par Michael Nygard, adapté pour le développement assisté par IA :

# ADR-NNNN : [Titre de la décision]

**Date** : AAAA-MM-JJ
**Statut** : proposé | accepté | déprécié | remplacé par ADR-NNNN
**Décideurs** : [qui était impliqué]

## Contexte

Quel est le problème que nous voyons et qui motive cette décision ou ce changement ?

[2 à 5 phrases décrivant la situation, les contraintes et les forces en jeu]

## Décision

Quel est le changement que nous proposons et/ou que nous faisons ?

[1 à 3 phrases énonçant clairement la décision]

## Alternatives Envisagées

### Alternative 1 : [Nom]
- **Avantages** : [bénéfices]
- **Inconvénients** : [inconvénients]
- **Pourquoi pas** : [raison spécifique du rejet]

### Alternative 2 : [Nom]
- **Avantages** : [bénéfices]
- **Inconvénients** : [inconvénients]
- **Pourquoi pas** : [raison spécifique du rejet]

## Conséquences

Qu'est-ce qui devient plus facile ou plus difficile à faire à cause de ce changement ?

### Positives
- [bénéfice 1]
- [bénéfice 2]

### Négatives
- [compromis 1]
- [compromis 2]

### Risques
- [risque et atténuation]

Flux de Travail

Capturer un Nouvel ADR

Lorsqu'un moment de décision est détecté :

  1. Initialiser (première fois uniquement) — si docs/adr/ n'existe pas, demandez à l'utilisateur confirmation avant de créer le répertoire, un README.md amorcé avec l'en-tête du tableau d'index (voir Format de l'Index ADR ci-dessous), et un template.md vierge pour usage manuel. Ne créez pas de fichiers sans consentement explicite.
  2. Identifier la décision — extraire le choix architectural principal en cours
  3. Rassembler le contexte — quel problème a déclenché cela ? Quelles contraintes existent ?
  4. Documenter les alternatives — quelles autres options ont été envisagées ? Pourquoi ont-elles été rejetées ?
  5. Énoncer les conséquences — quels sont les compromis ? Qu'est-ce qui devient plus facile/plus difficile ?
  6. Attribuer un numéro — analyser les ADRs existants dans docs/adr/ et incrémenter
  7. Confirmer et écrire — présenter le brouillon d'ADR à l'utilisateur pour révision. Écrire dans docs/adr/NNNN-titre-decision.md uniquement après approbation explicite. Si l'utilisateur refuse, jeter le brouillon sans écrire de fichiers.
  8. Mettre à jour l'index — ajouter à docs/adr/README.md

Lire les ADRs Existants

Lorsqu'un utilisateur demande "pourquoi avons-nous choisi X ?" :

  1. Vérifier si docs/adr/ existe — si non, répondre : "Aucun ADR trouvé dans ce projet. Souhaitez-vous commencer à enregistrer des décisions architecturales ?"
  2. S'il existe, analyser l'index docs/adr/README.md pour les entrées pertinentes
  3. Lire les fichiers ADR correspondants et présenter les sections Contexte et Décision
  4. Si aucune correspondance n'est trouvée, répondre : "Aucun ADR trouvé pour cette décision. Souhaitez-vous en enregistrer un maintenant ?"

Structure du Répertoire ADR

docs/
└── adr/
    ├── README.md              ← index de tous les ADRs
    ├── 0001-utilisation-nextjs.md
    ├── 0002-postgres-plutot-que-mongo.md
    ├── 0003-rest-plutot-que-graphql.md
    └── template.md            ← modèle vierge pour usage manuel

Format de l'Index ADR

# Enregistrements de Décisions Architecturales

| ADR | Titre | Statut | Date |
|-----|-------|--------|------|
| [0001](0001-utilisation-nextjs.md) | Utiliser Next.js comme framework frontend | accepté | 2026-01-15 |
| [0002](0002-postgres-plutot-que-mongo.md) | PostgreSQL plutôt que MongoDB pour le stockage principal | accepté | 2026-01-20 |
| [0003](0003-rest-plutot-que-graphql.md) | API REST plutôt que GraphQL | accepté | 2026-02-01 |

Signaux de Détection de Décision

Surveillez ces schémas dans la conversation qui indiquent une décision architecturale :

Signaux explicites

  • "Allons avec X"
  • "Nous devrions utiliser X au lieu de Y"
  • "Le compromis en vaut la peine parce que..."
  • "Enregistre ceci en tant qu'ADR"

Signaux implicites (suggérer d'enregistrer un ADR — ne pas créer automatiquement sans confirmation de l'utilisateur)

  • Comparer deux frameworks ou bibliothèques et aboutir à une conclusion
  • Faire un choix de conception de schéma de base de données avec une justification énoncée
  • Choisir entre des patrons architecturaux (monolithe vs microservices, REST vs GraphQL)
  • Décider d'une stratégie d'authentification/autorisation
  • Sélectionner une infrastructure de déploiement après avoir évalué des alternatives

Ce qui Fait un Bon ADR

À Faire

  • Soyez spécifique — "Utiliser Prisma ORM" pas "utiliser un ORM"
  • Enregistrez le pourquoi — la justification compte plus que le quoi
  • Incluez les alternatives rejetées — les développeurs futurs ont besoin de savoir ce qui a été envisagé
  • Énoncez les conséquences honnêtement — chaque décision a des compromis
  • Restez court — un ADR doit pouvoir être lu en 2 minutes
  • Utilisez le présent — "Nous utilisons X" pas "Nous utiliserons X"

À Ne Pas Faire

  • Enregistrer des décisions triviales — les choix de nommage de variables ou de formatage ne nécessitent pas d'ADR
  • Écrire des dissertations — si la section contexte dépasse 10 lignes, c'est trop long
  • Omettre les alternatives — "nous venons de choisir" n'est pas une justification valide
  • Compléter rétroactivement sans le marquer — si vous enregistrez une décision passée, notez la date d'origine
  • Laisser les ADRs devenir obsolètes — les décisions remplacées doivent référencer leur remplacement

Cycle de Vie d'un ADR

proposé → accepté → [déprécié | remplacé par ADR-NNNN]
  • proposé : la décision est en discussion, pas encore engagée
  • accepté : la décision est en vigueur et suivie
  • déprécié : la décision n'est plus pertinente (ex. fonctionnalité supprimée)
  • remplacé : un ADR plus récent remplace celui-ci (toujours lier le remplacement)

Catégories de Décisions Valant la Peine d'Être Enregistrées

CatégorieExemples
Choix technologiquesFramework, langage, base de données, fournisseur cloud
Patrons architecturauxMonolithe vs microservices, événementiel, CQRS
Conception d'APIREST vs GraphQL, stratégie de versionnement, mécanisme d'authentification
Modélisation des donnéesConception de schéma, décisions de normalisation, stratégie de cache
InfrastructureModèle de déploiement, pipeline CI/CD, stack de surveillance
SécuritéStratégie d'authentification, approche de chiffrement, gestion des secrets
TestsFramework de test, objectifs de couverture, équilibre E2E vs intégration
ProcessusStratégie de branchement, processus de révision, cadence de livraison

Intégration avec d'Autres Compétences

  • Agent planificateur : lorsque le planificateur propose des changements d'architecture, suggérez de créer un ADR
  • Agent de révision de code : signalez les PR qui introduisent des changements architecturaux sans ADR correspondant

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Skills associés