Communitygithub.com

architecture-decision-records

Capture decisões arquiteturais tomadas durante sessões com Claude Code como ADRs estruturados. Detecta automaticamente momentos de decisão, registra contexto, alternativas consideradas e justificativas. Mantém um registro de ADRs para que futuros desenvolvedores entendam por que o código está como está.

O que é architecture-decision-records?

Esta skill permite que desenvolvedores registrem decisões arquiteturais importantes diretamente durante sessões de codificação assistidas por IA (Claude Code, Cursor, etc.). Em vez de decisões ficarem perdidas em threads do Slack, comentários de PR ou na memória de alguém, a skill gera documentos ADR (Architecture Decision Records) estruturados que vivem junto ao código. Ela detecta sinais explícitos (como 'vamos registrar esta decisão') e implícitos (como comparação de frameworks) para sugerir o registro, e segue o formato leve de ADR proposto por Michael Nygard, adaptado para desenvolvimento assistido por IA. A skill gerencia o ciclo de vida dos ADRs (proposto → aceito → depreciado/substituído), mantém um índice em docs/adr/README.md e suporta consultas a decisões anteriores. É útil para manter rastreabilidade arquitetural, facilitar onboarding de novos desenvolvedores e evitar a repetição de discussões técnicas.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/architecture-decision-records

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Registros de Decisão Arquitetural (ADR)

Capture decisões arquiteturais à medida que acontecem durante sessões de codificação. Em vez de decisões viverem apenas em threads do Slack, comentários de PR ou na memória de alguém, esta skill produz documentos ADR estruturados que residem junto ao código.

Quando Ativar

  • O usuário diz explicitamente "vamos registrar esta decisão" ou "ADR isso"
  • O usuário escolhe entre alternativas significativas (framework, biblioteca, padrão, banco de dados, design de API)
  • O usuário diz "decidimos..." ou "a razão de fazermos X em vez de Y é..."
  • O usuário pergunta "por que escolhemos X?" (ler ADRs existentes)
  • Durante fases de planejamento, quando trade-offs arquiteturais são discutidos

Formato ADR

Use o formato leve de ADR proposto por Michael Nygard, adaptado para desenvolvimento assistido por IA:

# ADR-NNNN: [Título da Decisão]

**Data**: YYYY-MM-DD
**Status**: proposed | accepted | deprecated | superseded by ADR-NNNN
**Decisores**: [quem esteve envolvido]

## Contexto

Qual é o problema que estamos vendo que está motivando esta decisão ou mudança?

[2 a 5 frases descrevendo a situação, restrições e forças em jogo]

## Decisão

Qual é a mudança que estamos propondo e/ou implementando?

[1 a 3 frases declarando a decisão claramente]

## Alternativas Consideradas

### Alternativa 1: [Nome]
- **Prós**: [benefícios]
- **Contras**: [desvantagens]
- **Por que não**: [razão específica pela qual foi rejeitada]

### Alternativa 2: [Nome]
- **Prós**: [benefícios]
- **Contras**: [desvantagens]
- **Por que não**: [razão específica pela qual foi rejeitada]

## Consequências

O que se torna mais fácil ou mais difícil de fazer por causa desta mudança?

### Positivas
- [benefício 1]
- [benefício 2]

### Negativas
- [trade-off 1]
- [trade-off 2]

### Riscos
- [risco e mitigação]

Fluxo de Trabalho

Capturando um Novo ADR

Quando um momento de decisão é detectado:

  1. Inicializar (primeira vez apenas) — se docs/adr/ não existir, peça confirmação ao usuário antes de criar o diretório, um README.md semeado com o cabeçalho da tabela de índice (veja Formato do Índice ADR abaixo) e um template.md em branco para uso manual. Não crie arquivos sem consentimento explícito.
  2. Identificar a decisão — extraia a escolha arquitetural central que está sendo feita
  3. Coletar contexto — qual problema motivou isso? Quais restrições existem?
  4. Documentar alternativas — quais outras opções foram consideradas? Por que foram rejeitadas?
  5. Declarar consequências — quais são os trade-offs? O que se torna mais fácil/mais difícil?
  6. Atribuir um número — escaneie ADRs existentes em docs/adr/ e incremente
  7. Confirmar e escrever — apresente o rascunho do ADR ao usuário para revisão. Escreva em docs/adr/NNNN-titulo-da-decisao.md apenas após aprovação explícita. Se o usuário recusar, descarte o rascunho sem escrever nenhum arquivo.
  8. Atualizar o índice — anexe ao docs/adr/README.md

Lendo ADRs Existentes

Quando um usuário pergunta "por que escolhemos X?":

  1. Verifique se docs/adr/ existe — se não, responda: "Nenhum ADR encontrado neste projeto. Gostaria de começar a registrar decisões arquiteturais?"
  2. Se existir, escaneie o índice docs/adr/README.md em busca de entradas relevantes
  3. Leia os arquivos ADR correspondentes e apresente as seções de Contexto e Decisão
  4. Se nenhuma correspondência for encontrada, responda: "Nenhum ADR encontrado para essa decisão. Gostaria de registrar um agora?"

Estrutura do Diretório ADR

docs/
└── adr/
    ├── README.md              ← índice de todos os ADRs
    ├── 0001-use-nextjs.md
    ├── 0002-postgres-over-mongo.md
    ├── 0003-rest-over-graphql.md
    └── template.md            ← modelo em branco para uso manual

Formato do Índice ADR

# Registros de Decisão Arquitetural

| ADR | Título | Status | Data |
|-----|--------|--------|------|
| [0001](0001-use-nextjs.md) | Usar Next.js como framework frontend | accepted | 2026-01-15 |
| [0002](0002-postgres-over-mongo.md) | PostgreSQL em vez de MongoDB como armazenamento principal | accepted | 2026-01-20 |
| [0003](0003-rest-over-graphql.md) | API REST em vez de GraphQL | accepted | 2026-02-01 |

Sinais de Detecção de Decisão

Observe os seguintes padrões na conversa que indicam uma decisão arquitetural:

Sinais explícitos

  • "Vamos com X"
  • "Devemos usar X em vez de Y"
  • "O trade-off vale a pena porque..."
  • "Registre isso como um ADR"

Sinais implícitos (sugira registrar um ADR — não crie automaticamente sem confirmação do usuário)

  • Comparar dois frameworks ou bibliotecas e chegar a uma conclusão
  • Fazer uma escolha de design de esquema de banco de dados com justificativa declarada
  • Escolher entre padrões arquiteturais (monólito vs microsserviços, REST vs GraphQL)
  • Decidir sobre estratégia de autenticação/autorização
  • Selecionar infraestrutura de implantação após avaliar alternativas

O Que Faz um Bom ADR

Faça

  • Seja específico — "Usar Prisma ORM", não "usar um ORM"
  • Registre o porquê — a justificativa importa mais do que o quê
  • Inclua alternativas rejeitadas — futuros desenvolvedores precisam saber o que foi considerado
  • Declare consequências honestamente — toda decisão tem trade-offs
  • Mantenha curto — um ADR deve ser legível em 2 minutos
  • Use o tempo presente — "Usamos X", não "Usaremos X"

Não Faça

  • Registre decisões triviais — nomes de variáveis ou escolhas de formatação não precisam de ADRs
  • Escreva redações — se a seção de contexto exceder 10 linhas, está muito longa
  • Omita alternativas — "apenas escolhemos" não é uma justificativa válida
  • Preencha retrospectivamente sem marcar — se estiver registrando uma decisão passada, observe a data original
  • Deixe ADRs ficarem obsoletos — decisões substituídas devem referenciar sua substituta

Ciclo de Vida do ADR

proposed → accepted → [deprecated | superseded by ADR-NNNN]
  • proposed: decisão está em discussão, ainda não comprometida
  • accepted: decisão está em vigor e sendo seguida
  • deprecated: decisão não é mais relevante (ex.: funcionalidade removida)
  • superseded: um ADR mais novo substitui este (sempre link a substituta)

Categorias de Decisões Que Valem a Pena Registrar

CategoriaExemplos
Escolhas de tecnologiaFramework, linguagem, banco de dados, provedor de nuvem
Padrões arquiteturaisMonólito vs microsserviços, orientado a eventos, CQRS
Design de APIREST vs GraphQL, estratégia de versionamento, mecanismo de autenticação
Modelagem de dadosDesign de esquema, decisões de normalização, estratégia de cache
InfraestruturaModelo de implantação, pipeline CI/CD, stack de monitoramento
SegurançaEstratégia de autenticação, abordagem de criptografia, gerenciamento de segredos
TestesFramework de teste, metas de cobertura, equilíbrio E2E vs integração
ProcessoEstratégia de branching, processo de revisão, cadência de release

Integração com Outras Skills

  • Agente planejador: quando o planejador propõe mudanças na arquitetura, sugira criar um ADR
  • Agente revisor de código: sinalize PRs que introduzem mudanças arquiteturais sem um ADR correspondente

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/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

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.

Habilidades Relacionadas