risadams/ink-and-agency

Use when the user wants to analyze A/B test results, interpret p-values, determine statistical significance, or make a ship/no-ship decision. Triggers on: 'analyze A/B test', 'p-value', 'statistical significance', 'confidence interval', 'ship or no ship', 'test results', 'did it work'.

Use when you need comprehensive accessibility testing, WCAG compliance verification, or assessment of assistive technology support.

Use when you need to audit Active Directory security posture, evaluate privilege escalation risks, review identity delegation patterns, or assess authentication protocol hardening.

Use when the user wants to discover, browse, or install Claude Code agents from the subagent repository.

Use when assembling and optimizing multi-agent teams to execute complex projects that require careful task decomposition, agent capability matching, and workflow coordination.

Use when architecting, implementing, or optimizing end-to-end AI systems—from model selection and training pipelines to production deployment and monitoring.

Use when you need to audit content for AI writing patterns and rewrite text to remove them.

Use when architecting enterprise Angular 15+ applications with complex state management, optimizing RxJS patterns, designing micro-frontend systems, or solving performance and scalability challenges in large codebases.

Use when building infrastructure automation, configuration management, and orchestration with Ansible. Expert in playbooks, roles, modules, and large-scale infrastructure provisioning with idiomatic patterns and best practices.

Use when designing new APIs, creating API specifications, or refactoring existing API architecture for scalability and developer experience. Invoke when you need REST/GraphQL endpoint design, OpenAPI documentation, authentication patterns, or API versioning strategies.

Use when creating or improving API documentation, writing OpenAPI specifications, building interactive documentation portals, or generating code examples for APIs.

Use when the user needs to identify and prioritize risky assumptions in a product idea, feature, or strategy. Triggers on: 'assumptions', 'what could go wrong', 'validate', 'riskiest assumption', 'de-risk', 'assumption map'.

Use when designing, deploying, or managing Azure infrastructure with focus on network architecture, Entra ID integration, PowerShell automation, and Bicep IaC.

Use when building server-side APIs, microservices, and backend systems that require robust architecture, scalability planning, and production-ready implementation.

Use when the user needs to groom, refine, or clean up a product backlog. Triggers on: 'groom backlog', 'backlog refinement', 'backlog grooming', 'clean up backlog', 'refine stories', 'sprint refinement', 'backlog management'.

Use when building smart contracts, DApps, and blockchain protocols that require expertise in Solidity, gas optimization, security auditing, and Web3 integration.

Safely rebase the current branch onto its upstream target, auto-resolving trivial conflicts and prompting for complex ones. Use when the user says "rebase", "rebase onto main", "update my branch", "sync with baseline", "catch up with main", or invokes /branch- rebase.

Use when a git merge or rebase hits complex conflicts, or the user says "resolve conflicts" / "fix merge conflicts". Reconstructs intent, preserves both branches' goals when possible, and runs automated checks.

Decode messages into plain language with tone and intent analysis. Breaks down what someone actually means, analyzes emotional tone with probability scores, and flags ambiguity. Use when user says "break it down", "what does this mean", "decode this", "analyze this message", "what are they saying", or invokes /break-it-down.

Use when you need to optimize build performance, reduce compilation times, or scale build systems across growing teams.

Use when analyzing business processes, gathering requirements from stakeholders, or identifying process improvement opportunities to drive operational efficiency and measurable business value.

Use when you need to design and execute controlled failure experiments, validate system resilience before incidents occur, or conduct game day exercises to test your team's incident response capabilities.

Facilitates structured single-persona or multi-persona consultation for strategy, product, engineering, operations, and risk decisions. Use when the user requests a council, multiple perspectives, persona advice, tradeoff analysis, or iterative clarification and debate.

Use when building command-line tools and terminal applications that require intuitive command design, cross-platform compatibility, and optimized developer experience.

Use when you need to design, evaluate, or optimize cloud infrastructure architecture at scale. Invoke when designing multi-cloud strategies, planning cloud migrations, implementing disaster recovery, optimizing cloud costs, or ensuring security/compliance across cloud platforms.

Two-axis review of the working diff since a fixed point — Standards (repo conventions and code smells) and Spec (matches the originating ticket). Use when the user wants to review a branch or work-in-progress changes, says "review since X", or asks for a pre-MR review.

Analyze a git repository's history and produce an SVG treemap of file churn — area = lines changed, color = commit frequency. Use when user wants to find unstable areas of a codebase, predict bug-prone files, see "where do we change the most", spot refactor candidates, or invokes /codebase-churn.

Shared vocabulary and principles for designing deep modules — a lot of behaviour behind a small interface, placed at a clean seam. Use when designing or improving a module's interface, deciding where a seam goes, making code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

Tell the agent to explain code with broader context and a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.

Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

Use when you need repository-wide refactor governance with explicit approval loops, weighted risk prioritization, diff previews, and deterministic fallback strategies.

Create a detailed refactor plan with tiny commits via user interview, then file it as an issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

Use when the user wants to analyze retention, cohort behavior, engagement trends, or understand how different user groups perform over time. Triggers on: 'cohort analysis', 'retention analysis', 'user retention', 'cohort retention', 'week 1 retention', 'retention curve'.

Use when you need to achieve regulatory compliance, implement compliance controls, or prepare for audits across frameworks like GDPR, HIPAA, PCI DSS, SOC 2, and ISO standards.

Use when you need to develop comprehensive content strategies, create SEO-optimized marketing content, or execute multi-channel content campaigns to drive engagement and conversions. Invoke this skill for content planning, content creation, audience analysis, and measuring content ROI.

Use this skill before publishing any AI-generated content — blog posts, READMEs, release notes, commit messages, PR descriptions, documentation, or social posts. Strips AI writing patterns using unslop, then performs a final quality pass.

Use for managing shared state, information retrieval, and data synchronization when multiple agents need coordinated access to context and metadata.

Use when building high-performance C++ systems requiring modern C++20/23 features, template metaprogramming, or zero-overhead abstractions for systems programming, embedded systems, or performance-critical applications.

Use when building ASP.NET Core web APIs, cloud-native .NET solutions, or modern C# applications requiring async patterns, dependency injection, Entity Framework optimization, and clean architecture.

Personal daily briefing assistant. Pulls the last 24 hours of email and calendar from Outlook, summarizes today's schedule, surfaces open action items, and proposes focus blocks. Use when user says "daily briefing", "morning briefing", "daily standup prep", or invokes /daily-briefing.

Generate a per-team standup report from recent Jira, GitLab, Confluence, and Git activity, written into the Obsidian vault. Use when the user says "daily standup prep", "standup report", "generate standup", "scrum prep", or invokes /daily-standup-prep.

Use when you need to extract insights from business data, create dashboards and reports, or perform statistical analysis to support decision-making.

Use when you need to design, build, or optimize data pipelines, ETL/ELT processes, and data infrastructure. Invoke when designing data platforms, implementing pipeline orchestration, handling data quality issues, or optimizing data processing costs.

Use when you need to discover, collect, and validate data from multiple sources to fuel analysis and decision-making. Invoke this skill for identifying data sources, gathering raw datasets, performing quality checks, and preparing data for downstream analysis or modeling.

Use when you need to analyze data patterns, build predictive models, or extract statistical insights from datasets. Invoke this skill for exploratory analysis, hypothesis testing, machine learning model development, and translating findings into business recommendations.

Use when optimizing database performance, implementing high-availability architectures, setting up disaster recovery, or managing database infrastructure for production systems.

Use when you need to analyze slow queries, optimize database performance across multiple systems, or implement indexing strategies to improve query execution.

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

Use when you need to diagnose and fix bugs, identify root causes of failures, or analyze error logs and stack traces to resolve issues.

Extract clean markdown from web pages using Defuddle CLI, stripping navigation and clutter to save tokens. Use instead of WebFetch for any standard web page, documentation, article, or blog post — but not for URLs ending in .md, which WebFetch handles directly.

Use when you need to audit dependencies for vulnerabilities, resolve version conflicts, optimize bundle sizes, or implement automated dependency updates.

Use when designing, building, or optimizing CI/CD pipelines and deployment automation strategies.

Use when you need to translate a DESIGN.md into polished Claude Code instructions for building user interfaces that faithfully match the chosen brand. Invoke this skill whenever a developer or designer asks to replicate the look and feel of an existing product or website.

Use when building or optimizing infrastructure automation, CI/CD pipelines, containerization strategies, and deployment workflows to accelerate software delivery while maintaining reliability and security.

Use when actively responding to production incidents, diagnosing critical service failures, or conducting incident postmortems to implement permanent fixes and preventative measures.

Use when building Django 4+ web applications, REST APIs, or modernizing existing Django projects with async views and enterprise patterns.

Use when you need to build, optimize, or secure Docker container images and orchestration for production environments.

Use when you need to create, architect, or overhaul comprehensive documentation systems including API docs, tutorials, guides, and developer-friendly content that keeps pace with code changes.

Actively build and sharpen a project's domain model — challenge fuzzy terms, stress-test with scenarios, and write CONTEXT.md and ADRs inline as decisions crystallise. Use when the user wants to pin down domain terminology or a ubiquitous language, record an architectural decision, or when another skill needs to maintain the domain model.

Use when building .NET Core applications requiring cloud-native architecture, high-performance microservices, modern C# patterns, or cross-platform deployment with minimal APIs and advanced ASP.NET Core features.

Use when working on legacy .NET Framework 4.8 enterprise applications that require maintenance, modernization, or integration with Windows-based infrastructure.

Use when optimizing the complete developer workflow including build times, feedback loops, testing efficiency, and developer satisfaction metrics across the entire development environment.

Use when building Electron desktop applications that require native OS integration, cross-platform distribution, security hardening, and performance optimization. Use electron-pro for complete desktop app development from architecture to signed, distributable installers.

Use when you need to build fault-tolerant, concurrent systems leveraging OTP patterns, GenServer architectures, and Phoenix framework for real-time applications.

Use when developing firmware for resource-constrained microcontrollers, implementing RTOS-based applications, or optimizing real-time systems where hardware constraints, latency guarantees, and reliability are critical.

Score today's load (meetings, sensory demand, social events, deep work), flag burnout risk, and suggest what to drop or defer. Use when the user says "energy budget", "spoon check", "am I overcommitted", "what should I drop", or invokes /energy-budget.

Use when distributed system errors occur and need coordinated handling across multiple components, or when you need to implement comprehensive error recovery strategies with automated failure detection and cascade prevention.

Use when you need to diagnose why errors are occurring in your system, correlate errors across services, identify root causes, and prevent future failures.

Use when building mobile applications with Expo and React Native that require native module integration, navigation setup, performant animations, push notifications, OTA updates, or App Store/Play Store deployment.

Use when building modern async Python APIs with FastAPI, implementing Pydantic v2 validation, dependency injection patterns, or deploying high-performance ASGI applications.

Use when building payment systems, financial integrations, or compliance-heavy financial applications that require secure transaction processing, regulatory adherence, and high transaction accuracy.

Use when the user wants to challenge assumptions, break down a complex problem from scratch, or approach something with first principles reasoning. Triggers on: 'first principles', 'challenge assumptions', 'why do we do it this way', 'rethink', 'from scratch', 'fundamental truths'.

Use when building cross-platform mobile applications with Flutter 3+ that require custom UI implementation, complex state management, native platform integrations, or performance optimization across iOS/Android/Web.

Use when building complete frontend applications across React, Vue, and Angular frameworks requiring multi-framework expertise and full-stack integration.

Use when you need to build complete features spanning database, API, and frontend layers together as a cohesive unit.

Use when implementing game systems, optimizing graphics rendering, building multiplayer networking, or developing gameplay mechanics for games targeting specific platforms.

Use when the user needs to understand GDPR or CCPA compliance, review data practices, or assess privacy requirements. Triggers on: 'GDPR', 'CCPA', 'privacy compliance', 'data privacy', 'right to deletion', 'consent', 'data subject rights', 'California privacy'.

Use when you need to design, establish, or optimize Git workflows, branching strategies, and merge management for a project or team.

Use when building Go applications requiring concurrent programming, high-performance systems, microservices, or cloud-native architectures where idiomatic patterns, error handling excellence, and efficiency are critical.

Morning kickoff wrapper running sprint-snapshot, daily-standup-prep, and daily-briefing in order; idempotent on same-day re-runs. Use when the user says "good morning", "morning routine", "kick off my day", "start my day", or invokes /good-morning.

Use when building and configuring Gradle projects, optimizing build performance, managing dependencies, implementing multi-module architectures, or modernizing legacy build systems. Expert in Gradle 7+/8+ and build automation best practices.

Use when designing or evolving GraphQL schemas across microservices, implementing federation architectures, or optimizing query performance in distributed graphs.

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

Use when the user wants to design a growth loop, understand PLG mechanics, or build sustainable acquisition. Triggers on: 'growth loop', 'flywheel', 'viral loop', 'PLG growth', 'product-led growth', 'growth mechanics', 'how do we grow', 'word of mouth'.

Compact the current conversation into a handoff document for another agent to pick up.

Use when working on healthcare administration tasks including revenue cycle management, HIPAA/compliance auditing, medical coding (ICD-10, CPT, DRGs), CMS cost reports, payer contract analysis, quality improvement, clinical operations, health IT/interoperability, population health, and pharmacy benefits.

Use when the user is building a healthcare product and needs to understand HIPAA compliance. Triggers on: 'HIPAA', 'protected health information', 'PHI', 'healthcare compliance', 'covered entity', 'business associate', 'BAA', 'HITECH', 'health data'.

Park a deep work session before an interruption — capture what is only in your head, write a park file, drop a breadcrumb at the cursor. Use when the user says "I have to stop", "meeting in 10", "park this", "save my place", or invokes /hyperfocus-exit.

Reconstruct context after a deep session or interruption from git diff, modified files, and recent commits, then propose the next concrete action. Use when the user says "what was I doing", "where did I leave off", "lost my place", or invokes /hyperfocus-recovery.

Shape every response for an autistic reader — direct statements, required/optional labels, literal language, quantified uncertainty, named social subtext. Use when the user says "I'm autistic", asks for literal or direct output, or invokes /i-am-autistic — then keep applying it all session.

Shape every response for a reader with ADHD — next action first, numbered steps, progress restated each turn, one thread, numeric time estimates. Use when the user says "I have ADHD", asks for ADHD-shaped output, or invokes /i-have-adhd — then keep applying it all session.

Weigh one or more ideas with a structured pros-and-cons analysis and a Go / Go with caveats / Don't recommendation. Use when the user wants to evaluate an idea before committing, compare options on the merits, score tradeoffs, or asks "should I do X" / "is X worth it".

Force a binary pick when the user is stuck between options — three clarifying questions, then a verdict with reasoning. The fast counterpart to idea-choice. Use when the user says "I can't decide", "help me pick", "decision paralysis", "break the tie", or invokes /idea- decision-maker.

Helps users generate, refine, and stress-test ideas from loose topics. Use when user asks to brainstorm, find new ideas, or needs creative inspiration for a topic.

Build a piece of work (ticket, spec, or free-form request) through a tunable pipeline — test-first, verify, review, and track — where every phase can be skipped or tuned. Use when the user wants to actually build something, from a throwaway prototype to a CCB-gated feature.

Use when an active security breach, service outage, or operational incident requires immediate response, evidence preservation, and coordinated recovery.

Capture the current hyperfixation into the Obsidian vault fast, so it isn't lost and doesn't derail today's work. Use when the user says "capture this idea", "hyperfixation dump", "interest capture", "stash this", "don't let me forget", or invokes /interest- capture.

Use when designing and deploying IoT solutions requiring expertise in device management, edge computing, cloud integration, and handling challenges like massive device scale, complex connectivity scenarios, or real-time data pipelines.

Draft a customer-facing release note for a Jira ticket from its context and linked merge requests. Read-only unless the user opts in to publish. Use when the user says "draft release notes", "write a release note", "release note for [TICKET-KEY]", or invokes /issue-draft-release-notes.

Scan a Jira project's open issues for likely duplicates and report each suspected pair with a probability score and reasoning. Read-only. Use when the user says "find duplicates", "duplicate check", "dedupe issues", or invokes /issue-dup-find.

Estimate story points for a Jira ticket using historical data and multi-persona scrum poker. Use when user says "estimate this ticket", "how many points", "story point estimate", "estimate [TICKET-KEY]", or invokes /issue-estimate-sp. Read-only — never modifies the ticket.

Analyze a Jira ticket into an actionable breakdown, following linked tickets and Confluence context to surface gaps and ambiguities. Read-only. Use when the user says "break down this feature", "analyze this ticket", "feature breakdown", or provides a ticket key for analysis.

Suggest Jira components for one ticket or sweep a project's open tickets, confirming before any modification. Use when the user says "suggest components", "tag components", "fix components", "categorize tickets", or invokes /issue-suggest-component.

Triage a bug or Jira ticket into ranked root-cause candidates and proposed solution paths. Read-only unless the user opts in to publish. Use when the user says "triage this", "triage [TICKET-KEY]", "what's causing this bug", "help me find the root cause", or invokes /issue-triage.

Use for orchestrating complex IT operations tasks that span multiple domains (PowerShell automation, .NET development, infrastructure management, Azure, M365) by intelligently routing work to specialized agents.

Use when designing enterprise Java architectures, migrating Spring Boot applications, or establishing microservices patterns for scalable cloud-native systems.

Use when you need to build, optimize, or refactor modern JavaScript code for browser, Node.js, or full-stack applications requiring ES2023+ features, async patterns, or performance-critical implementations.

Use when you need to extract actionable patterns from agent interactions, synthesize insights across multiple workflows, and enable organizational learning from collective experience.

Use when building Kotlin applications requiring advanced coroutine patterns, multiplatform code sharing, or Android/server-side development with functional programming principles.

Use when you need to design, deploy, configure, or troubleshoot Kubernetes clusters and workloads in production environments.

Use when building Laravel 10+ applications, architecting Eloquent models with complex relationships, implementing queue systems for async processing, or optimizing API performance.

Use when modernizing legacy systems that need incremental migration strategies, technical debt reduction, and risk mitigation while maintaining business continuity.

Use when you need to draft contracts, review compliance requirements, develop IP protection strategies, or assess legal risks for technology businesses.

Use when architecting, implementing, or optimizing end-to-end legal licensing systems—from OSI standard selection and dependency compliance pipelines to proprietary deployment and risk monitoring.

Use when designing LLM systems for production, implementing fine-tuning or RAG architectures, optimizing inference serving infrastructure, or managing multi-model deployments.

Use when automating Microsoft 365 administrative tasks including Exchange Online mailbox provisioning, Teams collaboration management, SharePoint site configuration, license lifecycle management, and Graph API-driven identity automation.

Use when you need to build, debug, or optimize Model Context Protocol (MCP) servers and clients that connect AI systems to external tools and data sources.

Process a meeting dump — separate facts from feelings, flag action items, sort social ambiguities into worth-following-up vs noise. Use when the user says "meeting decompression", "process this meeting", "what just happened", or invokes /meeting- decompression.

Use when designing distributed system architecture, decomposing monolithic applications into independent microservices, or establishing communication patterns between services at scale.

Use when building production ML systems — training pipelines, model serving, inference optimization, automated retraining — or setting up MLOps: model versioning, experiment tracking, GPU orchestration, and operational monitoring.

Use when building iOS and Android apps, native or cross-platform (React Native, Flutter), with a focus on native performance, platform-specific UX, and offline-first architecture.

Use when coordinating multiple concurrent agents that need to communicate, share state, synchronize work, and handle distributed failures across a system.

Use when designing, optimizing, or troubleshooting cloud and hybrid network infrastructures, or when addressing network security, performance, or reliability challenges.

Use when building production Next.js 14+ applications — App Router, server components, server actions, Core Web Vitals, and SEO-optimized deployment.

Use when building production NLP systems, implementing text processing pipelines, developing language models, or solving domain-specific NLP tasks like named entity recognition, sentiment analysis, or machine translation.

Use when you need to build, optimize, or debug Node.js backend applications, APIs, CLIs, or microservices requiring deep ecosystem knowledge and server-side JavaScript expertise.

Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries. Use when working with .base files, creating database-like views of notes, or when the user mentions Bases, table views, card views, filters, or formulas in Obsidian.

Create and edit Obsidian Canvas files (.canvas) following the JSON Canvas spec — nodes, edges, groups, and connections. Use when working with .canvas files, creating visual canvases, mind maps, or flowcharts in Obsidian.

Build interactive Chart.js charts in Obsidian notes via chart codeblocks — inline series, a markdown table by block ID, or a Dataview query. Use when the user wants to chart, plot, graph, or visualize data in their Obsidian notes, or mentions "obsidian charts" or "renderChart".

Read, create, search, and manage Obsidian vault notes, tasks, and properties from the command line; also supports plugin and theme development and debugging. Use when the user asks to interact with their Obsidian vault or develop Obsidian plugins and themes.

Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes.

Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian.

Turn an unstructured dump of everything competing for attention into exactly one thing to do now, with the rest parked and dated. Use when the user says "everything is on fire", "I'm overwhelmed", "too much going on", "I don't know what to do first", or invokes /overwhelm-triage.

Use when implementing payment systems, integrating payment gateways, or handling financial transactions that require PCI compliance, fraud prevention, and secure transaction processing.

Use when you need to conduct authorized security penetration tests to identify real vulnerabilities through active exploitation and validation. Use penetration-tester for offensive security testing, vulnerability exploitation, and hands-on risk demonstration.

Use when you need to identify and eliminate performance bottlenecks in applications, databases, or infrastructure systems, and when baseline performance metrics need improvement.

Use when establishing observability infrastructure to track system metrics, detect performance anomalies, and optimize resource usage across multi-agent environments.

Use when working with PHP 8.3+ projects that require strict typing, modern language features, and enterprise framework expertise (Laravel or Symfony). Use when building scalable applications, optimizing performance, or requiring async/Fiber patterns.

Turn a decision you can't answer alone into a Markdown questionnaire for the one person who can — filled in async, or worked through together in a meeting.

Synthesize the current conversation into a spec (PRD) and stage it as a local file. Use when a design discussion, grilling session, or work-plan is settled and you want it written up as a spec — no interview, just synthesis. Publishing to Confluence is opt-in, only on request.

Break a spec, plan, or the current conversation into a local, numbered, spec-kit-style task list of tracer-bullet vertical slices with explicit dependencies. Use when a spec or plan is ready to become actionable tasks. Pushing to Jira is opt-in, only on request.

Use when building or improving internal developer platforms — platform architecture, golden paths, self-service infrastructure, and developer workflow friction.

Use when you need to optimize PostgreSQL performance, design high-availability replication, or troubleshoot database issues at scale. Invoke this skill for query optimization, configuration tuning, replication setup, backup strategies, and mastering advanced PostgreSQL features for enterprise deployments.

Use when automating Windows infrastructure tasks requiring PowerShell 5.1 scripts with RSAT modules for Active Directory, DNS, DHCP, GPO management, or when building safe, enterprise-grade automation workflows in legacy .NET Framework environments.

Use when building cross-platform cloud automation scripts, Azure infrastructure orchestration, or CI/CD pipelines requiring PowerShell 7+ with modern .NET interop, idempotent operations, and enterprise-grade error handling.

Use when architecting and refactoring PowerShell modules, designing profile systems, or creating cross-version compatible automation libraries. Invoke it for module design reviews, profile optimization, packaging reusable code, and standardizing function structure across teams.

Use when you need to harden PowerShell automation, secure remoting configuration, enforce least-privilege design, or align scripts with enterprise security baselines and compliance frameworks.

Use when designing or building desktop graphical interfaces (WinForms, WPF, Metro-style dashboards) or terminal user interfaces (TUIs) for PowerShell automation tools that need clean separation between UI and business logic.

Use when you need to establish project plans, track execution progress, manage risks, control budget/schedule, and coordinate stakeholders across complex initiatives.

Use when you need to design, optimize, test, or evaluate prompts for large language models in production systems.

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, explore what a UI should look like, or resolve a prototype-type decision ticket before committing to a build.

Use when you need to build type-safe, production-ready Python code for web APIs, system utilities, or complex applications requiring modern async patterns and extensive type coverage.

Use when developing quantitative trading strategies, building financial models, or running risk analytics for derivatives and portfolios — statistical arbitrage, backtesting, derivatives pricing, portfolio risk.

Use when building or modernizing Rails applications requiring API development, Hotwire reactivity, real-time features, background job processing, deployment automation, or Rails-idiomatic patterns for maximum productivity. Version-aware: adapts to Rails 7.x and 8.x projects.

Use when optimizing existing React applications for performance, implementing advanced React 18+ features, or solving complex state management and architectural challenges within React codebases.

Write, overhaul, or review a project README that is accurate to the repository and readable by a human. Use when the user says "write a README", "improve my README", "my README is out of date", "review my README", or a project needs its front page.

Use when you need to transform poorly structured, complex, or duplicated code into clean, maintainable systems while preserving all existing behavior.

Use when designing RL environments, training agents with reward optimization, implementing policy gradient methods, or deploying decision-making systems for robotics, gaming, and autonomous operations.

Calibrate a message that stung — separate evidence from interpretation, score how much sting is warranted. Use when the user says "did they mean it that way", "is this criticism", "am I reading this wrong", "this stung", or invokes /rejection-sensitivity- check.

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

Use when building Rust systems where memory safety, ownership patterns, zero-cost abstractions, and performance optimization are critical for systems programming, embedded development, async applications, or high-performance services.

Use when you need to conduct technical pre-sales activities including solution architecture, proof-of-concept development, and technical demonstrations for complex sales deals.

Use when you need to find specific information across multiple sources using advanced search strategies, query optimization, and targeted information retrieval. Invoke this skill when the priority is locating precise, relevant results efficiently rather than analyzing or synthesizing content.

Use when implementing security across infrastructure and CI/CD — threat modeling, zero- trust architecture, security automation, vulnerability management, and compliance programs.

Use when building shell scripts for system administration, automation, and DevOps. Expert in POSIX sh, Bash, Zsh, and modern shell best practices with strong focus on portability, error handling, and production-grade scripting.

Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill.

Use when developing Slack applications, implementing Slack API integrations, or reviewing Slack bot code for security and best practices.

Use when building enterprise Spring Boot 3+ applications requiring microservices architecture, cloud-native deployment, or reactive programming patterns.

Convert the start-of-sprint canvas into a planning report — committed scope, capacity vs commitment, WIP-saturation risk, observations, risks. Use when the user says "sprint plan", "sprint planning report", or invokes /sprint-plan.

End-of-sprint stakeholder report comparing the sprint's start and end canvases, fitted to the standard Scrum Master template. Use when the user says "sprint review", "end of sprint report", "sprint stakeholder report", or invokes /sprint-review.

Capture a point-in-time snapshot of a scrum team's sprint board into the Obsidian vault. Use when the user says "sprint snapshot", "snapshot the sprint", "capture sprint state", "sprint planner", "scrum board snapshot", or invokes /sprint-snapshot.

Weekly scrum-of-scrums report comparing two sprint snapshots — findings, observations, trouble areas, trends. Use when the user says "scrum of scrums", "sos report", "weekly sprint report", "sprint progress report", or invokes /sprint-sos-report.

Use when you need to optimize complex SQL queries, design efficient database schemas, or solve performance issues across PostgreSQL, MySQL, SQL Server, and Oracle requiring advanced query optimization, index strategies, or data warehouse patterns.

Use when you need to establish or improve system reliability through SLO definition, error budget management, and automation. Invoke when implementing SLI/SLO frameworks, reducing operational toil, designing fault-tolerant systems, conducting chaos engineering, or optimizing incident response processes.

Use when building native iOS, macOS, or server-side Swift applications requiring advanced concurrency patterns, protocol-oriented architecture, and Swift-specific optimizations. Invoke for SwiftUI modernization, async/await implementation, actor-based state management, or memory safety concerns.

Use when building Symfony 6+/7+/8+ applications, architecting Doctrine ORM entities with complex relationships, implementing Messenger component for async processing, or optimizing API Platform performance.

Use when distributing tasks across multiple agents or workers, managing queues, and balancing workloads to maximize throughput while respecting priorities and deadlines.

Produce the literal first physical action when the user knows what to do but can't start — not a plan, not a breakdown. Use when the user says "I can't start", "help me begin", "task initiation", "stuck on starting", or invokes /task-initiation.

Test-driven development — the red → green loop and the rules that make its tests worth keeping. Use when the user wants to build a feature or fix a bug test-first, mentions "red-green-refactor", TDD, or integration tests.

Teach the user a new skill or concept, within this workspace.

Use when you need to create, improve, or maintain technical documentation including API references, user guides, SDK documentation, and getting-started guides.

Use when building, refactoring, or scaling infrastructure as code using Terraform with focus on multi-cloud deployments, module architecture, and enterprise-grade state management.

Use when orchestrating Terraform with Terragrunt — DRY configurations, multi-environment deployments, stacks, units, and dependency management. Covers scalable IaC patterns with a focus on code reuse, maintainability, and enterprise-grade infrastructure automation.

Use when you need to build, implement, or enhance automated test frameworks, create test scripts, or integrate testing into CI/CD pipelines.

Counter time blindness with a calibrated estimate that accounts for setup, interruptions, and re-entry. Use when the user says "how long will this take", "time check", "reality check", "estimate this", "am I being realistic", or invokes /time-reality-check.

Use when you need to build or enhance developer tools including CLIs, code generators, build tools, and IDE extensions.

Use when implementing TypeScript code requiring advanced type system patterns, complex generics, type-level programming, or end-to-end type safety across full-stack applications.

Use when designing visual interfaces, creating design systems, building component libraries, or refining user-facing aesthetics requiring expert visual design, interaction patterns, and accessibility considerations.

Use when you need exhaustive UI and UX functionality testing driven by documented user flows, with browser or desktop interaction tooling and structured defect reporting.

Use when you need to generate production-ready visual assets for a project — app icons, favicons, OG images, logos, wordmarks, or social media images. Invokes the prompt-to-asset MCP server to route generation requests across 30+ image models.

Use when building Vue 3 applications that require Composition API mastery, reactivity optimization, or Nuxt 3 development with enterprise-scale performance concerns.

Stop — that last message didn't land. Re-pitch it in plain language with the context I'm missing.

Use when implementing real-time bidirectional communication features using WebSockets, Socket.IO, or similar technologies at scale.

Router over this pack's skills and flows. Ask it "which skill fits X" when you don't remember what's available.

Use when managing Windows Server infrastructure, Active Directory, DNS, DHCP, and Group Policy configurations, especially for enterprise-scale deployments requiring safe automation and compliance validation.

Generate an interactive bash wizard that walks a human step by step through a manual procedure. Use when provisioning infrastructure, setting up credentials or CI secrets, walking someone through an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke it for steps the agent can perform itself.

Use when you need to architect, optimize, or troubleshoot WordPress — custom theme and plugin development, multisite platforms, performance, security hardening, headless APIs, or WooCommerce.

Plan a huge chunk of work — more than one agent session can hold — as a shared map of decision tickets on your issue tracker, and resolve them one at a time until the way to the destination is clear.

Use when you need to design, implement, or optimize complex business process workflows with multiple states, error handling, and transaction management.

Calibrate a drafted apology — strip reflexive over-apology, keep warranted accountability. Use when the user says "calibrate this apology", "am I over-apologizing", "apology check", "did I say sorry too much", or invokes /writing-apology-calibrator.

Shape an article as a journey of beats, choose-your-own-adventure style — write one beat, offer pivots, repeat until it ends. Use when the user has raw material and wants it assembled as a narrative rather than an argument.

Produce the first sentence of a message when the blank cursor is winning — two or three openings matched to relationship and goal, then step out. Use when the user says "cold open", "help me start this message", "how do I begin", or invokes /writing-cold-open.

Guide the user from raw idea or draft to a finished article through relentless questioning and iterative writing. Use when the user wants to write something from scratch and have it completed.

Reference for writing any document an agent consumes — a skill, an AGENTS.md or CLAUDE.md, a doc reached by a pointer. Use when creating or editing a skill, writing agent-facing instructions, or modifying AGENTS.md / CLAUDE.md.

Mine the user for raw writing fragments — claims, vignettes, sharp sentences, half- thoughts — and append them to one document as material for a future article. Use when the user wants to develop ideas before imposing structure, or mentions "fragments" or "raw material".

Remove signs of AI-generated writing — inflated symbolism, promotional language, vague attributions, em dash overuse, rule of three, AI vocabulary, negative parallelisms, filler. Use when editing or reviewing text to make it read as human-written.

Shape a file of raw material into an article through a conversational session — candidate openings, paragraph by paragraph, arguing format at each step. Use when the user has notes, fragments, or a rough draft and wants it turned into something publishable.

Generate a script for a dreaded social scenario — declining, asking for an extension, following up, setting a boundary — in two or three phrasings from direct to softened. Use when the user says "script for", "help me say", "how do I tell them", or invokes /writing- social-script.

Reverse decoder — paste a draft message and get a read on how it will land before you send. Flags blunt, cold, accidentally passive-aggressive, or over-apologetic patterns. Use when user says "tone check", "how does this sound", "before I send this", "will this land okay", "check this draft", or invokes /writing-tone-check.