
Craft stunning macOS desktop experiences with SwiftUI — cinematic animations, particle systems, glass materials, and wallpaper-grade visual design. Use like `/apple-craftsman A minimalist weather widget with aurora particle effects`.
Pre-flight architecture dependency check — maps the Tech Stack Taxonomy (15 domains) and flags known incompatibilities BEFORE code gets written. Use when evaluating a proposed tech stack for a new project or major feature.
Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
Use when reviewing any interface for usability — walks through Krug's principles from Don't Make Me Think covering cognitive load, scanning, navigation, homepage clarity, mobile usability, accessibility, and the goodwill reservoir.
Queryable knowledge base of community-proven patterns and gotchas for technology combinations across the 15-domain Tech Stack Taxonomy. Use when evaluating stack choices, diagnosing production issues, asking how to correctly combine specific technologies, looking up best practices for a particular technology pattern, or feeding the Stack Compatibility Oracle.
Use when starting any creative work — new features, components, functionality changes, or modifications to existing behavior. Turns vague ideas into approved design docs through collaborative dialogue.
Simplify complex code by removing unnecessary abstractions, over-engineering, and cognitive overhead. Use this skill at the end of coding sessions or to clean up complex PRs. Focuses on making code easier to read, understand, and maintain.
Use when starting a new project, adding major features, or reviewing an existing system's architecture — guides through structured design phases covering data, storage, distribution, correctness, processing, infrastructure, and frontend concerns.
Use when building or reviewing SwiftUI interfaces for iOS or macOS — reviews code against Design+Code principles covering visual hierarchy, animation quality, materials, gestures, accessibility, and platform conventions.
Adaptive teaching layer that wraps software-forge — builds complete systems from vague ideas while upskilling the engineer. Tracks competency, teaches at decision points, evolves from mentor to peer as the user grows.
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
Use when you have a written implementation plan to execute in a separate session with review checkpoints
Master iOS Human Interface Guidelines and SwiftUI patterns for building native iOS apps. Use when designing iOS interfaces, implementing SwiftUI views, or ensuring apps follow Apple's design principles.
Use when starting a new project, adding a major feature to an existing system, or when unsure which skills to run and in what order. Supports macOS, iOS, web, full-stack, voice agent, and edge/IoT+ML projects.
Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
Engineer system prompts for LiveKit voice agents with multilingual support. Use when creating or optimizing AI agent conversation flows.
Use when you have a spec or requirements for a multi-step task, before touching code
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
Use when completing tasks, implementing major features, or before merging to verify work meets requirements
Scan any software project against a 15-domain, 7-layer taxonomy to produce a coverage report showing what exists, what's missing, and what's immature. Use before major architecture decisions, onboarding to a new codebase, or planning tech debt work. Focuses on technology coverage and infrastructure maturity, not on understanding application logic or business intent (use brownfield-greenfield for that).
Use when executing implementation plans with independent tasks in the current session
Use when reviewing any web or app interface for visual quality — walks through Refactoring UI principles covering hierarchy, spacing, typography, color, depth, images, and finishing touches to elevate design from amateur to professional.
Use when testing a web application for security vulnerabilities, before deployment or during security review — guides through a structured 10-phase penetration testing methodology covering mapping, authentication, session management, access controls, injection, logic flaws, and server configuration.
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
Use when implementing any feature or bugfix, before writing implementation code
Cut a professional release — bump version, write release notes, commit, tag, and push. Use when shipping a new version of any project.
Use when evaluating an existing project to understand what it does and what a fresh start would look like — extracts the intent graph from brownfield code, identifies pain points, strips technology choices, redesigns with current best practices, and presents a side-by-side comparison so the user can decide what (if anything) to change. Also use when inheriting an unfamiliar codebase and needing to understand its intent and constraints before making changes.
Audit security configurations - CSP, RLS, auth, dependencies, and OWASP vulnerabilities. Use before deployments or after adding integrations.
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation