convez.ai
PluginDevOps & InfraestruturaAvançado
nclsprsn

Architect Claude

nclsprsn/architect-claude

Documentos de arquitetura TOGAF em minutos, com validação integrada

Ver no GitHub
InicialPluginScore · de 0 a 100

Plugin para Claude Code que acelera a criação de documentos de arquitetura empresarial conformes a TOGAF. Oferece 23 skills reutilizáveis para todo o ciclo ADM (Architecture Development Method), desde princípios arquiteturais até governança de implementações, gerando artefatos prontos para apresentação com marcadores de responsabilidade.

Instalação

$npx convez-ai nclsprsn/architect-claude

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Estruturar Statements of Architecture Work e Requirements Specifications
  • Avaliar gaps e riscos em arquiteturas existentes
  • Validar completude de artefatos antes de apresentações ao board
  • Gerar matrizes e catálogos de capacidades com evidência de maturidade

Veredito

Ferramenta sólida para arquitetos empresariais que trabalham dentro da estrutura TOGAF. Reduz significativamente o tempo de scaffolding de documentos e adiciona rigor via checklists de validação. Recomendado para equipes com maturidade em governança de TI; iniciantes em arquitetura podem achar o contexto TOGAF muito prescritivo.

README

A tradução para o português deste README ainda está na fila.

architect

License: MIT Version Claude Code Plugin TOGAF-aware

TOGAF-structured architecture outputs in minutes. Twenty-three skills covering the full ADM cycle — from establishing Architecture Principles to governing live implementations — each producing client-ready documents with built-in accountability markers.


Why install it

Every architecture engagement carries a scaffolding tax: hours spent formatting a Statement of Architecture Work correctly, constructing a capability catalog with the right maturity evidence, or checking an artifact against all required Catalogs, Matrices, and Diagrams before board submission. That time displaces architectural thinking.

This plugin pays down that tax:

  • TOGAF 10-fidelity templates — Statement of Architecture Work (§7.6, 9 clauses), Architecture Requirements Specification (§7.11, 9 sections), Architecture Contract (§7.18) — populated, not blank
  • Built-in accountability — every output carries confidence markers, reversibility tags, named owners, and a Broad Responsibility line; no vague recommendations
  • Staged validation pipeline — principles-check → architecture-review → artifact-completeness → compliance-review — each gate tells you what the next gate needs
  • Skill chaining — every skill ends with a ## Next Step block recommending the downstream skill to invoke next
  • Framework-agnostic fallback — TOGAF vocabulary active by default; omit it and the skills degrade cleanly to framework-agnostic output

If you produce architecture documents, review other people's designs, or sit on an Architecture Board — this is the plugin to install.


Requirements

Optional

  • Claude Code VS Code extension — run skills on open files without leaving the editor
  • Obsidian (Dataview, Mermaid Tools) — render generated diagrams, query ADRs and decisions as a live register

Install

/plugin marketplace add nclsprsn/architect-claude
/plugin install architect@architect-claude

Local development — session only (changes apply on restart, no install step):

git clone https://github.com/nclsprsn/architect-claude
claude --plugin-dir ./architect-claude

Local development — permanent install (replaces the GitHub source):

git clone https://github.com/nclsprsn/architect-claude
claude plugin marketplace add ./architect-claude
claude plugin install architect@architect-claude

To pick up local edits after install:

claude plugin update architect@architect-claude
# then restart Claude Code

Quick Start

# Don't know where to start? The router dispatches you to the right skill
/architect-router I'm starting a new TOGAF engagement for a data platform

# Establish Architecture Principles and EA governance model (Preliminary Phase)
/preliminary docs/organisation-context.md

# Define scope, stakeholders, and Architecture Vision (Phase A)
/architecture-vision docs/programme-brief.md

# Score a capability map for completeness and maturity evidence (Phase B)
/capability-assessment docs/capability-map.md

# Chief architect critique before a governance submission
/architecture-review docs/platform-design.md

# Full TOGAF Compliance Assessment — produces Architecture Board verdict
/compliance-review docs/architecture-definition-document.md

# Write an ADR for a decision already made
/adr-generator We chose Kafka over RabbitMQ for ordering guarantees and replay capability

# Rewrite a technical document for a C-level audience
/executive-summary docs/data-platform-proposal.md

Skills

Route

SkillWhat it does
/architect-router [context]Detect ADM phase and intent, recommend the right skill to invoke next

Frame — establish the engagement

SkillWhat it does
/preliminary [context]Architecture Principles (4-field template), tailored framework, Organizational Model for EA, Request for Architecture Work
/architecture-vision [context]Statement of Architecture Work (§7.6, 9 clauses), Architecture Vision, stakeholder map, communications plan
/requirements-management [context]Requirements Impact Assessments, Architecture Requirements Repository, traceability matrix — continuous across all ADM phases

Discover — understand the landscape

SkillWhat it does
/capability-assessment [path]Score a Phase B capability map — completeness, maturity evidence, ownership model, Phase B→C traceability
/gap-analysis [path]Baseline→target gap table by domain and effort, sequenced into H1/H2/H3 roadmap
/data-architecture [path]Data quality attributes, governance blind spots, GDPR/AI Act check, second-order effects
/integration-architecture [path]Integration topology fitness, contract governance, reliability patterns, anti-pattern detection
/data-pipeline-review [path]Pipeline pattern vs SLA fitness, idempotency, lineage, observability
/technology-architecture [path]Infrastructure topology, vendor lock-in surface, DR/HA patterns, IaC coverage, technology lifecycle, cost model

Decide — make and record decisions

SkillWhat it does
/trade-off-analysis [context]2–3 options → weighted decision matrix → clear recommendation → ADR-ready output
/adr-generator [context]MADR from a decision already made — DACI stakeholders, force-field analysis, QA scenarios

Communicate — land the message

SkillWhat it does
/executive-summary [path]Rewrite for C-level: Pyramid Principle, business implications, numbered claims
/stakeholder-communication [path]Tailor for a named role: CTO / Head of Eng / CPO / CFO / CISO / DPO / Board

Plan — sequence the delivery

SkillWhat it does
/migration-plan [path]Gap-analysis output → dependency-sequenced H1/H2/H3 roadmap with TOGAF Transition Architectures
/new-arch-doc [phase]Scaffold a TOGAF phase document (A–D) or framework-agnostic proposal with guiding questions

Validate — review before the board

Four sequential gates before Architecture Board submission. Run them in order.

SkillGateWhat it does
/principles-check [path]1Validate document against Architecture Principles; or audit the principles themselves
/architecture-review [path]2Chief architect critique — quality attributes, assumptions, disruptive alternative, second-order effects
/risk-radar [path]2 (parallel)Risk heat map, RAID log, top mitigations, one systemic risk worth naming
/artifact-completeness [path]3Score against canonical TOGAF template — required Catalogs, Matrices, and Diagrams
/compliance-review [path]48-category TOGAF Compliance Assessment — Approve / Approve with Conditions / Reject

Govern — implement and evolve

SkillWhat it does
/implementation-governance [context]Architecture Contracts, 8-category Compliance Assessments, dispensation and exception log (Phase G)
/change-management [context]Classify change requests, assess impact, determine if a new ADM cycle is required (Phase H)

ADM Workflow

Specification Track

From Preliminary through Phase F. Requirements Management runs continuously across all phases. Use /new-arch-doc to scaffold a blank phase document before populating it with the phase skills below.

flowchart TD
    subgraph RM["Requirements Management — continuous"]
        rm["/requirements-management"]
    end
    pre["Preliminary<br>/preliminary<br>Principles · Framework · Org Model"] --> va
    va["Phase A — Vision<br>/architecture-vision<br>Statement of Architecture Work"] --> vb
    vb["Phase B — Business<br>/capability-assessment<br>/gap-analysis"] --> vc_d
    vb --> vc_a
    vc_d["Phase C — Data<br>/data-architecture<br>/data-pipeline-review"] --> vd
    vc_a["Phase C — Application<br>/integration-architecture"] --> vd
    vd["Phase D — Technology<br>/technology-architecture"] --> ve
    ve["Phase E — Opportunities<br>/gap-analysis"] --> vf
    vf["Phase F — Migration Planning<br>/migration-plan"]
    rm -.->|"new or changed requirements"| va
    rm -.->|"new or changed requirements"| vb
    rm -.->|"new or changed requirements"| vc_d
    rm -.->|"new or changed requirements"| vc_a
    rm -.->|"new or changed requirements"| vd
    rm -.->|"new or changed requirements"| vf

Validation & Governance Track

From artifact submission through Architecture Board decision, Phase G ongoing monitoring, and Phase H change management. Phase H feeds back to the start of a new ADM cycle.

flowchart TD
    artifact["Architecture artifact<br>submitted for review"] --> pc
    pc["/principles-check<br>Validate against<br>Architecture Principles"] --> ar
    pc --> rr
    ar["/architecture-review<br>Chief architect critique<br>quality · assumptions · risks"] --> ac
    rr["/risk-radar<br>Risk heat map · RAID log<br>systemic risk named"] --> ac
    ac["/artifact-completeness<br>Check TOGAF template<br>Catalogs · Matrices · Diagrams"] --> cr
    cr["/compliance-review<br>8-category Compliance Assessment"] --> board{Architecture Board<br>decision}
    board -->|Approve| contract["Architecture Contract signed<br>/implementation-governance"]
    board -->|Approve with Conditions| dispense["Dispensation logged<br>/implementation-governance"]
    board -->|Reject| revise["Revise artifact<br>back to phase skill"]
    contract --> gov
    dispense --> gov
    gov["/implementation-governance<br>Phase G — ongoing monitoring<br>compliance checks · exception log"] --> change
    change["/change-management<br>Phase H — classify change request<br>simplification · incremental · re-architecting"]
    change -->|Re-architecting trigger| newcycle["New ADM cycle<br>/preliminary or /architecture-vision"]
    change -->|Simplification / Incremental| gov

Worked Examples

The references/examples/ directory contains twenty-four fully instantiated TOGAF artefacts anchored to a single coherent engagement — ACME Corp Customer Onboarding modernisation — so you can see how artefacts accumulate across phases rather than reading disconnected templates. Each example is produced by a specific skill and follows its template exactly.

FileArtefactPhaseSkill
references/examples/11.01-architecture-principles.md6 Architecture Principles — 4-field templatePreliminary/preliminary
references/examples/11.02-request-for-architecture-work.mdRequest for Architecture WorkPreliminary/preliminary
references/examples/12.01-statement-of-architecture-work.mdStatement of Architecture Work (§7.6, 9 clauses)A/architecture-vision
references/examples/13.01-architecture-requirements-specification.mdArchitecture Requirements Specification (§7.11, 9 sections)B/requirements-management
references/examples/21.01-business-capabilities-catalog.mdBusiness Capabilities Catalog — 20 capabilities, maturity 0–4B/capability-assessment
references/examples/31.01-trade-off-analysis.mdTrade-off Analysis — orchestration pattern, 3 options, TCO comparisonB→C/trade-off-analysis
references/examples/22.01-data-architecture.mdPhase C Data Architecture — 5 domains, DAMA-DMBOK, GDPR, data contractsC/data-architecture
references/examples/22.02-data-pipeline-review.mdData Pipeline Review — document processing pipeline, idempotency, lineage, GDPR data residency findingC/data-pipeline-review
references/examples/23.01-integration-architecture.mdPhase C Application Architecture — 7 integration points, 5 EIP anti-patterns, SLO tableC/integration-architecture
references/examples/24.01-technology-architecture.mdPhase D Technology Architecture — 12 components, 6 anti-patterns, cost model, Phase C→D traceabilityD/technology-architecture
references/examples/51.01-gap-analysis.mdPhase E Gap Analysis — 7 domains, 15 gaps, dependency DAG, TOGAF Gap Analysis Matrix, critical pathE/gap-analysis
references/examples/31.02-architecture-decision-record.mdArchitecture Decision Record — MADR with weighted decision matrixE/adr-generator
references/examples/52.01-migration-plan.mdPhase F Migration Plan — strangler-fig, 6Rs (7 workloads), 3 Transition Architectures, rollback playbooksF/migration-plan
references/examples/71.01-architecture-contract.mdArchitecture Contract — Design & Development (§7.18)G/implementation-governance
references/examples/71.02-compliance-assessment.mdCompliance Assessment — all 8 TOGAF categoriesG/compliance-review
references/examples/71.03-change-management.mdPhase H Change Management — Partner API Platform CR, Major classification, RIA, Repo Update LogH/change-management
references/examples/61.01-principles-check.mdPrinciples Check — 6 principles validated against Phase D Technology Architecture, per-principle conformance verdictsValidate/principles-check
references/examples/61.02-architecture-review.mdChief Architect Critique — Phase D Technology Architecture, unstated assumptions, disruptive alternative, 12-item fix listValidate/architecture-review
references/examples/61.03-risk-radar.mdProgramme RAID Log — 10 risks, heat map, bow-tie analysis, risk interconnection map, systemic risk namedValidate/risk-radar
references/examples/61.04-artifact-completeness.mdArtifact Completeness — Phase C Application Architecture scored against all TOGAF Catalogs, Matrices, DiagramsValidate/artifact-completeness
references/examples/41.01-executive-summary.mdExecutive Summary — 15-gap analysis rewritten for CCO, Pyramid Principle, Before/After pairCommunicate/executive-summary
references/examples/41.02-stakeholder-communication.mdCISO Briefing — security findings tailored for CISO, owner split, Before/After transformationCommunicate/stakeholder-communication
references/examples/81.01-architect-router.mdArchitect Router — two routing interactions (engagement start → Preliminary/Phase A; pre-board validation → 4-gate pipeline)Route/architect-router
references/examples/82.01-new-architecture-document.mdPhase D Technology Architecture scaffold — blank skeleton with all required sections and guiding questionsScaffold/new-arch-doc

Design Philosophy

Architect Mindset

Every skill operates from the same posture — the same questions an experienced chief architect would ask before signing off an output:

  • Work backwards from the business outcome — never forward from the technology
  • Surface a disruptive alternative that questions whether the problem was framed correctly
  • Name the horizon — H1 optimise core / H2 scale emerging / H3 seed disruptive; flag when an H3 problem gets H1 treatment
  • Apply the commoditisation curve — never custom-build a commodity
  • Anchor every claim with a number, reference architecture, or first-principles reasoning
  • Name at least one second-order effect per output

Output Accountability

Posture without accountability is theatre. Every skill enforces four output rules so recommendations land as decisions, not opinions:

MarkerWhat it enforces
[proven] / [informed estimate] / [working hypothesis]Calibrates confidence in every claim, score, and recommendation
one-way door / two-way doorMakes reversibility explicit before a decision is committed
Named owner + event-based review triggerPrevents unowned recommendations; no calendar-date triggers
Broad Responsibility lineSurfaces societal, regulatory, or downstream impact on every output

Skill Chaining

Each skill ends with a ## Next Step block recommending the downstream skill to invoke — either forward (next ADM phase) or lateral (validation gate, decision capture, or communication). Claude invokes the next skill if your intent is clear; you accept or override the suggestion.

TOGAF Default

TOGAF vocabulary — ADM phases, building blocks, gap analysis — is active by default. If your project does not use TOGAF, omit the vocabulary in your prompts and the skills degrade to framework-agnostic mode automatically.


Troubleshooting

The skill runs but the output ignores my TOGAF context. Include TOGAF vocabulary in your prompt or document. The skills detect signals (ADM phases, building blocks, gap analysis) to switch into full TOGAF mode. Ensure standard terms appear: "ADM", "Building Block", "Baseline", "Target Architecture", "Phase A/B/C/D".

The output is too generic. Pass the actual document as input, not a description of it. /architecture-review docs/platform-design.md is significantly richer than /architecture-review our platform uses microservices.

/trade-off-analysis gives me a tie with no clear winner. Add a tiebreaker criterion: the business constraint, timeline pressure, or team capability that should break the tie. Append it to your prompt.

Output is missing the Broad Responsibility line. If it outputs N/A, it must include a reason. If neither appears, re-run with an explicit reminder: append -- ensure Broad Responsibility line is present to your command.

I don't know which skill to invoke. Run /architect-router with a short description of what you're trying to do. The router detects ADM phase and intent and recommends the right skill.


License

MIT

Ver o original no GitHub

Bom para

Relacionados