Architect Skill Router (companion)

    2

    Routes an architecture request to the installed Architect skills that own it, and plans what to load in order.

    Free

    1 installSecurity scanned

    Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseOpenClawOpenClaw+21 more

    Architect Skill Router (companion)

    Example session with this skill installed

    Route and plan the execution sequence of Architect skills for our Enterprise Event-Driven Payment Migration.

    • Objective: Decompose our legacy monolith payment processing into an asynchronous, event-driven microservices architecture with strict security and reliability controls.
    • Deciders: Principal Enterprise Architect (Marcus Vance) and Core Engineering Director (Sarah Chen).
    • Scope Requirements:
      1. Overall asynchronous messaging topology, event schemas, and transactional outbox.
      2. REST API contracts for public merchant checkout and idempotency guarantees.
      3. Zero-trust security threat model, OAuth 2.0 PKCE profile, and API key management.
      4. Kubernetes platform multi-tenant topology and container autoscaling.
      5. Reliability engineering: Service Level Objectives (SLOs), error budgets, and operational failover runbooks.
    • Tension: Tech leads attempted to begin coding simultaneously without defining handoff boundaries, resulting in schema drift between payment APIs and event topics. Marcus Vance mandates a sequenced skill DAG defining artifact lineage and strict ownership before implementation starts.

    Write the route plan under docs/architecture/routing/.

    • Read your context and instructions
    • Compiled the architect router companion
    • Generated the design tokens stylesheet

    Wrote docs/architecture/routing/skill-route-plan.md. Complete multi-skill route plan and dependency DAG orchestrating 8 specialized Architect skills across 4 execution phases for the Enterprise Event-Driven Payment Migration.

    Architect Skill Route Plan: Enterprise Event-Driven Payment Migration [ROUTE-PAY-001]

    1. Request Analysis & Intent Classification

    The objective is decomposing a legacy monolithic payment processing engine into an asynchronous, event-driven microservices platform. This initiative requires coordination across four distinct technical domains: Backend APIs, Asynchronous Messaging, Cloud Infrastructure & Security, and Reliability Operations.

    Intake RequirementTarget DomainSelected Skill IDRationale
    Async messaging topology & schemasAsynchronous Architectureevent-driven-architectOwns topic topology, partition keying, and event-command boundaries.
    Dual-write consistency & outboxBackend Architectureoutbox-designSpecializes in transactional outbox persistence and CDC relay mechanics.
    Merchant API endpoints & OpenAPIBackend APIsrest-api-designOwns HTTP contract, cursor pagination, and RFC 9457 error models.
    Duplicate charge protectionBackend APIsidempotency-designOwns idempotency keys, composite scoping, and in-flight locking.
    Threat analysis of payment flowApplication Securitythreat-modeling-taskEvaluates STRIDE threats, entry surfaces, and mitigation controls.
    Delegated merchant authorizationSecurity & Identityoauth-designDefines OAuth 2.0 Authorization Code + S256 PKCE profile.
    Shared Kubernetes infrastructureDevOps & Cloudkubernetes-architectDesigns multi-tenant clusters, tainted node pools, and network isolation.
    Checkout availability & runbooksSRE & Operationssli-slo-designOwns CUJ indicators, error budget mathematics, and burn-rate alerting.

    2. Selected Skills and Execution DAG

    The migration plan is structured into four sequential phases forming a strict Directed Acyclic Graph (DAG). Foundation contracts precede transport specifications, which precede infrastructure and reliability operational baselines.

    Phase 1: Security & API Contract Foundations
      ├── [threat-modeling-task] ──► Threat Model & Abuse Scenarios
      │                                    │
      └── [rest-api-design] ───────────────┼────────────────────────┐
                                           ▼                        ▼
    Phase 2: Authorization & Resilience Mechanics
      ├── [oauth-design] ◄─── (Needs API scopes)                    │
      ├── [idempotency-design] ◄─── (Needs POST refund contracts)  │
      └── [event-driven-architect] ◄─── (Needs payment domain events)
                 │
                 ▼
    Phase 3: Event Relaying & Platform Provisioning
      ├── [outbox-design] ◄─── (Needs topic schemas & Kafka cluster)
      └── [kubernetes-architect] ◄─── (Needs workload resource specs)
                 │
                 ▼
    Phase 4: Reliability Governance & Operations
      └── [sli-slo-design] ◄─── (Needs end-to-end user checkout journey)
    

    3. Boundary & Responsibility Matrix

    Skill IDPrimary DeliverableOwned ScopeForbidden Scope Overlap
    threat-modeling-taskthreat-model-report.mdSTRIDE analysis, trust boundaries, attacker profilesDoes not design token crypto or write runbooks
    rest-api-designrest-api-contract.mdHTTP methods, status codes, OpenAPI schemaDoes not configure database outbox tables
    oauth-designoauth-profile-spec.mdAuthorization code flow, PKCE S256, token rotationDoes not evaluate business fraud scores
    idempotency-designidempotency-contract.mdComposite key tuple, DynamoDB lock, payload hashDoes not configure Kafka topics
    event-driven-architecteda-architecture.mdKafka topic topology, CloudEvents schemas, partitionsDoes not implement DB replication slots
    outbox-designoutbox-pattern-contract.mdPostgreSQL outbox table, Debezium CDC, DLQDoes not define merchant REST endpoints
    kubernetes-architectkubernetes-architect-overview.mdEKS node pools, Cilium NetworkPolicy, PSS restrictedDoes not write application business code
    sli-slo-designsli-slo-contract.mdAvailability/latency SLIs, error budget burn ratesDoes not configure IAM policies

    4. Intake Context and Artifact Lineage

    [threat-modeling-task] ──► docs/architecture/security/threat-model.md
                                          │
                                          ▼
    [oauth-design] ──────────► docs/architecture/security/oauth-profile.md
                                          │
    [rest-api-design] ───────► docs/architecture/api/rest-contract.md
                                          │
                                          ▼
    [idempotency-design] ────► docs/architecture/api/idempotency-contract.md
                                          │
    [event-driven-architect] ─► docs/architecture/eda/eda-architecture.md
                                          │
                                          ▼
    [outbox-design] ─────────► docs/architecture/eda/outbox-contract.md
                                          │
    [kubernetes-architect] ──► docs/architecture/k8s/platform-overview.md
                                          │
                                          ▼
    [sli-slo-design] ────────► docs/architecture/sre/sli-slo-contract.md
    

    5. Verification & Route Self-Check

    No validator was supplied, so no command was run.

    Reviewer self-check against routing invariants:

    Catalog Verification: PASS. All 8 skill IDs (threat-modeling-task, rest-api-design, oauth-design, idempotency-design, event-driven-architect, outbox-design, kubernetes-architect, sli-slo-design) exist in references/catalog.yml.

    • DAG Integrity: PASS. Zero cyclical loops detected; dependencies cascade deterministically across 4 phases.
    • Single Ownership: PASS. Every architectural asset has exactly one designated primary skill owner.
    • Completeness: PASS. Addresses all five intake concerns stated by Marcus Vance and Sarah Chen.

    Next steps

    1. Present this Route Plan to Marcus Vance and Sarah Chen for Architecture Review Board endorsement.
    2. Initialize Phase 1 execution by loading threat-modeling-task and rest-api-design.
    3. Feed resulting threat model boundaries and REST contracts into Phase 2 execution lanes (oauth-design, idempotency-design, and event-driven-architect).

    architect-skill-router-companion-tokens.css

    CSS · design tokens

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    This skill is the metadata-only entry point for unclassified architecture requests. It resolves the requested decision and deliverable, accountable authority, artifact ownership, required dependencies, and evidence obligations; selects the smallest compatible leaves; and emits a progressive load and handoff plan. It does not perform architecture, author artifacts, execute tasks, spawn agents, or infer a route from names.

    Use it when

    • The request is architectural but exact authoritative leaf IDs are not supplied
    • Multiple plausible owners overlap and the requested decision/deliverable must discriminate them
    • A domain authority and a narrow task procedure must be paired without transferring ownership
    • Prerequisite producer/consumer contracts and execution order must be identified before loading bodies
    • Ambiguity, missing authority, incompatible ownership, unavailable packages, or stale metadata must block deterministically
    • Context cost requires bounded metadata discovery and smallest-leaf progressive loading

    What you get

    The output is one structured routing decision with a stable status, reason, bounded candidates, and the smallest compatible selected leaf set — a domain leaf, a task leaf, or a domain-plus-task pair — each carrying its SKILL.md and references/output-contract.md authority files (two files for one leaf, four for a pair). This meta-skill produces no architecture artifact.

    What it will not do

    Do not use when authoritative leaf IDs are already resolved, or merely to perform architecture, write a design/specification/diagram/ADR, plan a generic task, search a catalog, spawn agents, execute a workflow, choose tools, or route from titles/keywords.

    What's in the package

    Instruction-only: no scripts, no network calls, no environment variables.

    • LICENSE.txt
    • SKILL.md
    • agents/openai.yaml
    • references/catalog.yml
    • references/domain-rules.md
    • references/operating-rules.md
    • references/output-contract.md

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    1 install

    Downloaded by developers to date

    Free forever

    No account required to browse

    Trust & safety

    Security scanned

    Verified clean 12 days ago

    • Free to download with an account

    Listed12 days ago

    What's inside

    Frequently Asked Questions