architect

Audit frontend code for WCAG 2.1 AA accessibility compliance with scored findings

AI agent architecture — orchestration, tools, guardrails, token costs

Wire analytics SDKs (GA4, PostHog, Mixpanel) with GDPR-compliant consent management

Generate multiple architecture options based on project constraints (budget, team size, timeline, ops maturity)

Check local environment readiness for the project — runtimes, databases, tools, credentials

Validate project state consistency — schema compliance, type checking, per-command write rule violations

Side-by-side technology comparison with recommendation

Identify emerging competitive threats, strategic moves by rivals, and existential risks

Build difficulty assessment with 10-factor scoring

Analyze project for compliance gaps across SOC2, HIPAA, GDPR, and PCI DSS frameworks

Infrastructure + third-party + LLM token cost breakdown

Design database scaling strategy with read replicas, partitioning, and sharding recommendations

Deep web research on market, competitors, technology, and differentiation for the project

Generate a complete design system from product context and wireframes — no blueprint required

Design disaster recovery strategy with RTO/RPO targets, backup config, and incident runbooks

Render Mermaid architecture diagrams to PNG/SVG and export to docs or wikis

Generate ORM schemas (Prisma, SQLAlchemy, Mongoose, Drizzle) from blueprint shared types and database definitions

Generate operational, architecture, and ADR documentation from project state

Generate unit, integration, and e2e test suites from scaffolded project with framework-appropriate coverage

Developer hiring package with role descriptions and interview questions

Setup internationalization for frontend apps with multi-language support and RTL handling

Synthesize all ideation research into a single, actionable briefing with go/no-go recommendation

_Part 1 of 2. Read implement-index.md first, then this file, then implement-2.md._

_Part 2 of 2. Read implement-index.md and implement-1.md first._

Implement a specific feature or user story into an already-scaffolded codebase — route, service, model, migration stub, and tests

Reverse-engineer architecture from an existing codebase — generates SDL and analysis

Investor/stakeholder update template pre-filled from project data

Run a 10-point launch readiness checklist against your project

Pre-launch readiness checklist generated from SDL and deployment configuration

Generate load testing scenarios (k6/Locust) from API contracts with realistic traffic patterns

MVP boundary definition with prioritized features, user stories, and cut criteria

Intelligent next-steps guide — recommends 3 highest-ROI commands based on project stage, completion status, and blockers

Developer onboarding package for first hire or agency handoff

Find cost savings in infrastructure without sacrificing quality or performance

Full 15-slide investor pitch deck with web-verified market data — generates .md + .pptx

Structured problem validation with assumptions testing and experiment design

Deep code analysis across all components — produces a scored, categorised go/no-go verdict before launch

Apply targeted changes to an existing prototype without regenerating from scratch

Generate a clickable UI prototype with distinctive visual design, working navigation, and realistic data

Generate interactive API documentation from blueprint specs (Swagger UI, Redoc, AsyncAPI)

5-minute lightweight architecture overview for idea validation

Recommend optimal tech stacks based on project type, team expertise, budget, and timeline

Coordinated architecture refactor — change database, cloud provider, or framework with full SDL consistency

_Part 1 of 2. Read review-index.md first, then this file, then review-2.md._

_Part 2 of 2. Read review-index.md and review-1.md first._

Review code changes against the project's own patterns and best practices — pattern conformance, production hardening, security surface scan, test coverage, architecture fitness

Comprehensive risk register with quantified impact, mitigations, and monitoring triggers

Scaffold a single named component from the architecture blueprint with production-depth code

Create repos and bootstrap projects from a blueprint architecture

Detect architecture drift — compare current codebase against committed SDL and surface topology changes

Generate, validate, diff, or browse SDL (Solution Design Language) architecture specifications

Validate scaffolded project code against the blueprint's security architecture checklist

Configure SEO metadata, structured data, sitemaps, robots.txt, and Core Web Vitals tracking

Configure real CI/CD pipelines in GitHub Actions, Azure Pipelines, or GitLab CI from the blueprint

Walk through third-party account setup, validate API keys, and write verified .env files

Configure observability stack with metrics, tracing, logging, alerts, and dashboards

Show current sprint progress by cross-referencing backlog with activity logs

Generate a CTO / board-ready presentation document from the architecture blueprint

Push sprint backlog from a blueprint into Azure DevOps or Jira as sprints and work items

Phased delivery plan with milestones, dependencies, risk gates, and resource planning

Detailed user journey maps with touchpoints, emotions, and design opportunities

Research-backed user personas with behavioral depth and product implications

Cross-command consistency validator — detects conflicts between outputs from different /architect: commands

Generate an interactive architecture visualisation with component topology and data flow

Six-pillar well-architected review with scores and improvement roadmap

Generate screen spec JSON files (NOT HTML) — one .json file per screen, rendered natively by Archon

Takes OpenAPI, AsyncAPI, and GraphQL specs from a blueprint and deploys interactive API documentation. Supports Swagger UI, Redoc, and Stoplight.

Syncs sprint backlog from a blueprint into Azure DevOps or Jira. Creates sprints, epics, and user stories as work items. Prefers MCP tools when available, falls back to CLI/REST.

Takes the DevOps blueprint from an architecture and configures real CI/CD pipelines in GitHub Actions, Azure Pipelines, or GitLab CI. Sets up workflows, environment secrets, and deployment configs.

Analyze project for compliance gaps across frameworks (SOC2, HIPAA, GDPR, PCI); generate gap reports with remediation steps

Publishes a generated architecture artifact to Confluence via MCP. Creates or updates a page under a specified parent space.

Takes shared types and database definitions from a blueprint manifest and generates real ORM schemas (Prisma, SQLAlchemy, Mongoose, Drizzle) with migrations.

Renders Mermaid architecture diagrams from a blueprint to PNG/SVG files and optionally exports to Confluence, Notion, or a documentation folder.

Generate runbooks, architecture guides, ADRs, and incident playbooks from project state

Walks through third-party account creation, validates API keys, and writes a verified .env file for each project component.

Reads from and writes to Figma via MCP. Handles three flows: pull design tokens from a Figma file, push generated design-tokens.json as Figma variables/styles, and export wireframe JSON specs as Figma frames.

Per-component code-writing agent for /architect:implement. Receives a pattern fingerprint, write plan, and story context for one component, then writes all files and verifies the build.

Generate k6/Locust/Artillery load test scenarios from OpenAPI contracts with realistic traffic patterns

Generate observability stack config, metrics/tracing/logging code, dashboards, alerts, and SLO templates

Publishes a generated architecture artifact to Notion via MCP. Creates or updates a page in a specified Notion database or as a child of a parent page.

Per-component code review agent for /architect:review. Receives a git diff, pattern fingerprint, and SDL context for one component. Runs five checks and returns a structured findings array.

Creates repos and bootstraps projects for architecture components. Use after generating a blueprint with /architect:blueprint.

Validates scaffolded project code against the blueprint's security architecture checklist. Checks auth middleware, CORS, rate limiting, headers, and input validation.

Generate unit, integration, and e2e test suites following testing-strategy patterns

AI agent orchestration patterns (ReAct, chain-of-thought, multi-agent), tool design, memory strategies, guardrails, and token cost modeling. Use when designing AI agent systems.

Templates and rules for generating OpenAPI specs, Postman collections, AsyncAPI specs, and GraphQL schemas from architecture manifests

Architecture pattern selection, folder structures, coding conventions, error handling, testing strategies, and platform-specific patterns for structuring application code

Identifies missing prerequisites (blockers) for each `/architect:` command based on `_state.json` field requirements. Used by `/architect:next-steps`, `/architect:check-state`, and validation commands to determine which commands can run and which are blocked.

Structural code quality rules applied at write time (implementer, scaffolder) and check time (reviewer). Covers function length, single responsibility, abstraction levels, meaningful naming, magic values, parameter design, boolean traps, DRY, dead code, premature abstraction, frontend component decomposition, null safety, async safety, input validation at boundaries, and concurrency safety.

Generate hard enforcement tooling (ESLint, Ruff, golangci-lint, dependency-cruiser, pre-commit, arch tests, CI) from SDL

Generate AI-consumable coding rules (CLAUDE.md, .cursorrules, copilot-instructions) and enforcement tooling from SDL

10-factor weighted scoring methodology for assessing build difficulty. Includes factor definitions, scoring guides, and agent/hybrid adjustments. Use when assessing project complexity.

Compliance frameworks (SOC2, HIPAA, GDPR, PCI DSS) with control mappings and implementation guidance

Step-by-step remediation procedures for each of the 23 consistency rules. Used by `/architect:validate-consistency --fix` to auto-fix safe conflicts, and by users to manually resolve complex conflicts.

Defines the 23 rules used by `/architect:validate-consistency` to detect conflicts across project outputs. These rules are the "law of the land" for cross-command consistency.

Maps project constraints (budget, team size, timeline, ops maturity, compliance) to architecture decisions. Used by `/architect:blueprint-variants` and `/architect:recommend-stack` to generate informed options.

Tracks actual infrastructure costs against estimated costs. Alerts when actual spend drifts from projection, identifies cost drivers, and suggests corrective actions.

Real pricing data for cloud compute, databases, LLM tokens, auth, payments, email, hosting, and monitoring services. Use when estimating infrastructure or operational costs.

Shows cost and performance impact of "what if" infrastructure changes. Helps users understand trade-offs before committing to changes.

When commands make architecture decisions (choosing tech stacks, patterns, frameworks, databases, etc.), they MUST log those decisions to `_state.json.decisions[]` for auditability and future reference.

Structured web research methodology for market analysis, competitor research, and technology evaluation. Ensures research uses live web data with source citations and confidence tags.

Generate a context-aware, production-grade design system from the SDL blueprint. Produces design tokens, typography, palette, motion language, and component inventory — grounded in the product domain, audience, and architecture. Use this skill when generating or refining the SDL design section, scaffolding frontend projects, or when the user asks about visual direction.

Mermaid diagram templates for solution architecture, service communication, C4 Context/Container, data flow, agent flow, deployment, and sequence diagrams. Use when generating architecture diagrams.

Provides clear, actionable error messages that help users understand what went wrong, why it matters, and how to fix it. Better error messages reduce debugging time and user frustration.

Extract and render all Mermaid diagrams from architecture blueprints to PNG images. Creates a diagrams/ folder with high-quality images ready for presentations and documentation.

Convert architecture documents (blueprints, stakeholder presentations) from Markdown to professionally formatted Word (.docx) files. Applies corporate styling, embeds PNG diagrams, and creates presentation-ready documents.

Generate OpenAPI 3.0 specification from blueprint API documentation. Creates interactive API docs that can be imported into Postman, Swagger UI, and other API testing tools.

Communication guidelines for non-technical founders. Plain English defaults, analogy-first explanations, progressive disclosure. Use when generating any user-facing architecture output.

ORM and data model generation patterns. Core file covers Node.js (Prisma/Drizzle/TypeORM). Runtime-specific files: python.md (SQLAlchemy/Django ORM), dotnet.md (EF Core), go.md (GORM/sqlc).

SDL generators for Docker Compose, Kubernetes, Monitoring, Nginx, and Deploy Diagram

Setup steps, credentials, free tiers, and documentation links for 70+ commonly used services. Use when listing required accounts or recommending third-party services.

Canonical system manifest format with all enumerated types for project, frontend, service, database, integration, LLM, agent, and communication components. Use when structuring architecture output.

Patterns for metrics, tracing, logging, alerting, dashboards, and SLO definition

Security architecture, observability, CI/CD pipelines, database migrations, and environment strategy patterns for production-ready systems

Validates that a command can execute before running it. Prevents wasted time by stopping early if prerequisites are missing, state is invalid, or conflicting outputs exist.

Documents the complete dependency graph of all 54 `/architect:` commands, showing which commands must run before others, in what order, with estimated execution times for full dependency chains.

Sync sprint backlog from architecture blueprint to project management tools (Linear, Jira, GitHub Issues, Asana, ClickUp). Creates issues/tasks with user stories, acceptance criteria, priorities, and sprint assignments.

Test naming conventions, fixture patterns, mocking strategies, and coverage thresholds by stage

Quantifies exact trade-offs when switching between architecture options. Shows users precisely what they gain and lose when choosing Option A over Option B.

Run comprehensive quality checks on architecture blueprints. Validates completeness, consistency, best practices, and readiness for implementation. Identifies missing sections, conflicting decisions, and potential issues.

Six-pillar well-architected framework for evaluating architecture quality — operational excellence, security, reliability, performance, cost optimization, and developer experience

JSON wireframe spec patterns — SDL-to-screen mapping and section examples for each screen type.

Detects product type from user requirements to trigger domain-specific architecture depth sections

Core Node.js patterns + cross-runtime reference. For Python see python.md, for .NET see dotnet.md, for Go see go.md.

Starter file templates and boilerplate for scaffolding projects across frontend, backend, mobile, and AI agent frameworks. Sub-files: nextjs.md, react-vite.md, react-native.md, ios-swift.md, android-kotlin.md, frontend-config.md, nodejs.md, python.md, go.md, dotnet.md, nestjs.md, spring-boot.md

Solution Design Language (SDL) specification — schema, validation, normalization, and generation rules

Generate comprehensive security audit checklist from architecture blueprint. Covers OWASP Top 10, data security, authentication, authorization, secrets management, compliance, and testing procedures.

Environment variable setup patterns. Core file covers Node.js (dotenv, NEXT_PUBLIC_, VITE_). Runtime files: python.md (pydantic-settings, Django settings), dotnet.md (appsettings.json, User Secrets), go.md (caarlos0/env, godotenv).

Verifies that chosen technologies integrate well together. Prevents "I picked these tools and they don't work well together" regrets.

Estimates cost and effort to switch from one tech stack to another. Helps answer: "Can we migrate later if needed?"

Detects the current project stage (concept → mvp → growth → enterprise) based on `_state.json` field presence and completeness. Used by `/architect:next-steps`, `/architect:check-state`, and roadmap commands.

Generate presentation-ready Word documents for stakeholder discussions. Translates technical architecture blueprints into business-focused presentations with diagrams, cost analysis, and approval checklists.