navraj007in
49 verified skills98 total stars
well-architected
Six-pillar well-architected framework for evaluating architecture quality — operational excellence, security, reliability, performance, cost optimization, and developer experience
development2
validate
Run comprehensive quality checks on architecture blueprints. Validates completeness, consistency, best practices, and readiness for implementation. Identifies missing sections, conflicting decisions, and potential issues.
testing2
sdl-knowledge
Solution Design Language (SDL) specification — schema, validation, normalization, and generation rules
testing2
product-type-detector
Detects product type from user requirements to trigger domain-specific architecture depth sections
testing2
manifest-structure
Canonical system manifest format with all enumerated types for project, frontend, service, database, integration, LLM, agent, and communication components. Use when structuring architecture output.
development2
known-services
Setup steps, credentials, free tiers, and documentation links for 70+ commonly used services. Use when listing required accounts or recommending third-party services.
documentation2
infrastructure-generators
SDL generators for Docker Compose, Kubernetes, Monitoring, Nginx, and Deploy Diagram
devops2
export-diagrams
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.
testing2
cost-knowledge
Real pricing data for cloud compute, databases, LLM tokens, auth, payments, email, hosting, and monitoring services. Use when estimating infrastructure or operational costs.
testing2
coding-rules-enforcement
Generate hard enforcement tooling (ESLint, Ruff, golangci-lint, dependency-cruiser, pre-commit, arch tests, CI) from SDL
tools2
skills/consistency-rules
# Consistency Rules Skill 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. ## Rule Catalog The 23 rules are divided into three categories: 1. **State Rules (6)** — Validate individual fields in `_state.json` 2. **Output Rules (8)** — Validate files generated by individual commands 3. **Cross-Command Rules (9)** — Detect conflicts between outputs of different commands
development2
skills/prerequisite-graph
# Prerequisite Graph Skill 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. ## Quick Reference: Command Dependency Tiers Commands are organized by execution order: | Tier | Commands | ETA | Depends on | |------|----------|-----|-----------| | **Tier 0: Foundation** | blueprint, sdl, import | 20-30 min | Nothing (can start empty) | | **Tier 1: Desig
documentation2
production-hardening
Core Node.js patterns + cross-runtime reference. For Python see python.md, for .NET see dotnet.md, for Go see go.md.
development2
security-audit
Generate comprehensive security audit checklist from architecture blueprint. Covers OWASP Top 10, data security, authentication, authorization, secrets management, compliance, and testing procedures.
testing2
agent-architecture
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.
tools2
api-artifacts
Templates and rules for generating OpenAPI specs, Postman collections, AsyncAPI specs, and GraphQL schemas from architecture manifests
development2
application-patterns
Architecture pattern selection, folder structures, coding conventions, error handling, testing strategies, and platform-specific patterns for structuring application code
development2
architecture-methodology
Core methodology for analysing requirements, building system manifests, and generating architecture deliverables. Use when planning or designing any software architecture.
development2
skills/blocker-detection
# Blocker Detection Skill 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. ## When to Use Invoke this skill to determine if a command can execute or what prerequisites must be completed first. Blocker detection: - Prevents wasted time on commands that will fail due to missing inputs -
testing2
clean-code
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.
development2
coding-rules
Generate AI-consumable coding rules (CLAUDE.md, .cursorrules, copilot-instructions) and enforcement tooling from SDL
tools2
complexity-factors
10-factor weighted scoring methodology for assessing build difficulty. Includes factor definitions, scoring guides, and agent/hybrid adjustments. Use when assessing project complexity.
development2
Compliance & Security Standards
Compliance frameworks (SOC2, HIPAA, GDPR, PCI DSS) with control mappings and implementation guidance
development2
skills/conflict-resolution
# Conflict Resolution Guide 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. ## Quick Reference For each conflict type, this guide provides: 1. **Root cause** — why the conflict happened 2. **Impact** — what goes wrong if not fixed 3. **Auto-fix approach** — if `/architect:validate-consistency --fix` can handle it 4. **Manual fix steps** — fo
development2
skills/constraint-solver
# Constraint Solver Skill 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. ## When to Use Invoke this skill to: 1. **Understand constraint implications** — what does $2k/mo budget mean for tech choices? 2. **Find feasible options** — which architectures fit these constraints? 3. **Identify constraint conflicts** — can we really do en
testing2
skills/continuous-cost-monitor
# Continuous Cost Monitor Skill Tracks actual infrastructure costs against estimated costs. Alerts when actual spend drifts from projection, identifies cost drivers, and suggests corrective actions. ## When to Use Use this skill to: 1. **Detect cost creep** — infrastructure spending slowly increases over time 2. **Root-cause cost spikes** — which service changed? traffic? resource use? 3. **Compare actual vs. estimated** — am I spending what I projected? 4. **Trigger optimization cycles** — w
devops2
skills/cost-whatif-simulator
# Cost What-If Simulator Skill Shows cost and performance impact of "what if" infrastructure changes. Helps users understand trade-offs before committing to changes. ## When to Use Use this skill to answer questions like: - "What if we use spot instances instead of on-demand?" - "What if we upgrade to 32GB database?" - "What if we add a CDN?" - "What if we cut monitoring to save money?" - "What if we support 2× more users?" ## Input Provide current infrastructure + proposed change: ```json
devops2
deep-research
Structured web research methodology for market analysis, competitor research, and technology evaluation. Ensures research uses live web data with source citations and confidence tags.
development2
design-system
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.
development2
diagram-patterns
Mermaid diagram templates for solution architecture, service communication, C4 Context/Container, data flow, agent flow, deployment, and sequence diagrams. Use when generating architecture diagrams.
devops2
skills/error-messages
# Error Messages Skill 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. ## Error Message Structure Every error should follow this 4-part template: ``` ❌ [WHAT WENT WRONG] [WHY THIS MATTERS] [HOW TO FIX IT] [OPTIONAL CONTEXT] ``` ### Part 1: What Went Wrong Clear, specific statement of the error. No jargon unless unavoidable. **Bad:** ``` Error: ENOEN
development2
export-docx
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.
development2
export-openapi
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.
tools2
founder-communication
Communication guidelines for non-technical founders. Plain English defaults, analogy-first explanations, progressive disclosure. Use when generating any user-facing architecture output.
testing2
operational-patterns
Security architecture, observability, CI/CD pipelines, database migrations, and environment strategy patterns for production-ready systems
testing2
skills/pre-execution-validation
# Pre-Execution Validation Skill 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. ## When to Use Invoke this skill at the start of every command to: 1. **Fail fast** — detect impossible prerequisites before spending 30 minutes generating output 2. **Provide guidance** — tell users exactly what's missing and how to fix it 3. **Prevent cascading failures** — stop if earlie
testing2
skills/stack-compatibility
# Stack Compatibility Skill Verifies that chosen technologies integrate well together. Prevents "I picked these tools and they don't work well together" regrets. ## When to Use Use this skill to verify: 1. **Chosen tools work together** — React + Node + MongoDB = good? 2. **No hidden incompatibilities** — will I hit issues in production? 3. **Team can support it** — do we have expertise for this combo? 4. **Licenses compatible** — can we use these together commercially? 5. **Performance assum
tools2
skills/stack-swap-simulator
# Stack Swap Simulator Skill Estimates cost and effort to switch from one tech stack to another. Helps answer: "Can we migrate later if needed?" ## When to Use Use this skill to understand: 1. **Cost of switching stacks** — engineer weeks + downtime risk 2. **Timeline to switch** — how long is the project? 3. **Risk of switching** — what can go wrong? 4. **ROI of switching** — does it save money long-term? 5. **Backwards compatibility** — can we do a gradual migration? ## Input Provide sour
development2
skills/stage-detection
# Stage Detection Skill 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. ## When to Use Invoke this skill when you need to determine what stage a project is at based on its state file. Stage detection drives: - Command recommendations (what to run next) - Required fields validation (what should exist at this stage) - Risk assessment (w
testing2
stakeholder-doc
Generate presentation-ready Word documents for stakeholder discussions. Translates technical architecture blueprints into business-focused presentations with diagrams, cost analysis, and approval checklists.
testing2
skills/tradeoff-analysis
# Trade-Off Analysis Skill Quantifies exact trade-offs when switching between architecture options. Shows users precisely what they gain and lose when choosing Option A over Option B. ## When to Use Use this skill to help users decide between options by showing: 1. **Cost difference** — how much more/less per month? 2. **Performance difference** — how much faster/slower? 3. **Complexity difference** — how much harder to build/maintain? 4. **Scalability difference** — when does this option hit
development2
setup-env
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).
development2
wireframe-patterns
JSON wireframe spec patterns — SDL-to-screen mapping and section examples for each screen type.
tools2
skills/project-templates
--- name: project-templates description: 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 --- # Project Templates Starter templates for each supported framework. Used by the scaffolder agent to create real, working project scaffolds. > **All framewor
development2
generate-data-model
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).
development2
Observability & Monitoring
Patterns for metrics, tracing, logging, alerting, dashboards, and SLO definition
testing2
Testing Strategy
Test naming conventions, fixture patterns, mocking strategies, and coverage thresholds by stage
testing2
skills/decision-logging
# Decision Logging Skill 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. ## When to Log a Decision Log a decision whenever your command: 1. **Chooses a technology** (database, framework, language, messaging system, auth provider) 2. **Selects an architectural pattern** (monolith vs. microservices, clean vs. modular, etc.) 3. **Determines a
development2
sync-backlog
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.
tools2