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

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 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

    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).

    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

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skill Creator Skills.

    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.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    2 uses

    Times used to date

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    No. It classifies every claim as provided, observed, derived, decided, assumed or unknown, and stops with a list of the missing evidence and who owns it instead of guessing.

    No. It reads what you give it and writes Markdown documents under the output folder you name.

    Any agent that supports SKILL.md skills, including Claude Code, Codex CLI, Cursor and Gemini CLI. It has no scripts and makes no network calls.

    Unzip it into your agent's skills folder, for example: unzip architect-skill-orchestrator.zip -d ~/.claude/skills/

    New in Agents & Orchestration

    Free