
Use when completing tasks, implementing major features, or before merging to verify work meets requirements
Use when executing implementation plans with independent tasks in the current session
Use when implementing any feature or bugfix, before writing implementation code
Use when you have a spec or requirements for a multi-step task, before touching code
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
Apply official brand colors and typography to artifacts for cohesive visual identity.
Manage database schema changes using migration tools and version control.
Delegate focused tasks to a subagent for specialized execution while maintaining main context.
Create, read, edit, and manipulate Word documents (.docx) with proper formatting.
Implement JWT (JSON Web Token) authentication for secure API access.
Build high-quality MCP (Model Context Protocol) servers for LLM tool integration.
Use Prisma ORM for type-safe database access in TypeScript/JavaScript applications.
Entity Framework Core best practices including NoTracking by default, query splitting for navigation collections, migration management, dedicated migration services, and common pitfalls to avoid.
Perform security vulnerability scanning and audits to identify and fix security issues.
--- name: huashu-design description: Huashu-Design uses HTML to create high-fidelity prototypes, interactive demos, slide decks, animations, design variation explorations, design-direction consulting, and expert critique in one integrated capability. HTML is a tool, not the medium; embody the right expert for the job (UX designer, animator, slide designer, prototyper) and avoid generic web-design tropes. Trigger phrases: make a prototype, design demo, interactive prototype, HTML presentation, an
Design, build, and deploy serverless event-driven functions using AWS Lambda.
Build high-performance REST APIs using Fastify framework for Node.js.
Write internal communications including updates, newsletters, and reports following company formats.
Write integration tests using .NET Aspire's testing facilities with xUnit. Covers test fixtures, distributed application setup, endpoint discovery, and patterns for testing ASP.NET Core apps with real dependencies.
Create new skills interactively with proper structure and documentation.
Use when building Retrieval-Augmented Generation (RAG) systems, chatbots with document context, semantic search, or AI apps that query a knowledge base before generating responses.
Use when integrating Stripe payments, subscriptions, webhooks, or billing into web applications. Covers Checkout, Payment Intents, subscriptions, customer portal, and webhook handling.
Use when building UIs with shadcn/ui components in React/Next.js projects. Covers setup, component usage, theming, customization, and composition patterns with Tailwind CSS.
Build React applications with Vite for fast development and optimized builds.
Implement Prometheus metrics and monitoring for applications.
Use when running LLMs locally with Ollama, integrating local models into apps, or building AI features without sending data to external APIs. Covers model management, API usage, and integration with AI SDK.
Automate workflows and connect services using n8n, a powerful workflow automation tool.
Design and implement GraphQL APIs with proper schema design, resolvers, and best practices.
Implement MediatR mediator pattern in .NET for decoupled request handling.
Apply systematic debugging strategies and use appropriate tools to identify and fix issues.
Create CI/CD pipelines using GitHub Actions for automated builds, tests, and deployments.
Build full-stack web applications using SvelteKit with server-side rendering.
Create algorithmic and generative art using tools like p5.js, focusing on seeded randomness, flow fields, and interactive parameters.
Apply modern standards and best practices for designing scalable, secure, and maintainable REST APIs.
Configure Aspire AppHost to emit explicit app config via environment variables; keep app code free of Aspire clients and service discovery.
Test email sending locally using Mailpit with .NET Aspire. Captures all outgoing emails without sending them. View rendered HTML, inspect headers, and verify delivery in integration tests.
Create a shared ServiceDefaults project for Aspire applications. Centralizes OpenTelemetry, health checks, resilience, and service discovery configuration across all services.
Build fast websites with Astro framework. Perfect for content-focused sites, blogs, and landing pages.
GitHub Copilot Agent Skills catalog from awesome-copilot repository. Trigger: When user wants to browse, search, or use Agent Skills from the awesome-copilot collection.
Use when building ANY 2D or 3D game, game prototype, or interactive simulation with SpriteKit, SceneKit, or RealityKit. Covers scene graphs, ECS architecture, physics, actions, game loops, rendering, SwiftUI integration, SceneKit migration.
Build JavaScript/TypeScript applications using Bun runtime for fast performance.
Create visual art in PNG/PDF using design philosophy with original compositions.
Use when generating or updating a CHANGELOG.md file, writing release notes, or summarizing changes between versions based on git commits or PR history.
Use when reviewing code changes, pull requests, or diffs. Provides a structured review framework covering correctness, security, performance, readability, and test coverage.
Use GitHub Copilot CLI with /fleet for parallel subagent execution and custom agent workflows.
Orchestrate and delegate tasks to subagents in GitHub Copilot CLI for parallel or focused execution.
Database access patterns for performance. Separate read/write models, avoid N+1 queries, use AsNoTracking, apply row limits, and never do application-side joins. Works with EF Core and Dapper.
Apply systematic debugging patterns and strategies to identify and fix software issues efficiently.
Delegate focused tasks to a subagent for specialized execution while maintaining main context.
Build applications using Deno runtime with TypeScript support and built-in tooling.
# design-md Skill A skill for creating and managing DESIGN.md files — a format specification for describing visual identity to coding agents, developed by Google Labs. ## Overview DESIGN.md combines machine-readable design tokens (YAML front matter) with human-readable design rationale (markdown prose). Tokens give agents exact values; prose tells them *why* those values exist and how to apply them. ## File Structure A DESIGN.md has two layers: 1. **YAML front matter** — Machine-readable d
Run multiple independent tasks in parallel using subagents for faster execution.
Run multiple independent tasks in parallel using subagents for faster execution.
Guide users through structured workflow for collaborative document creation.
Orchestrate containerized applications using Docker Swarm for clustering and service management.
Build minimal .NET APIs using Carter framework with declarative routing.
Implement Clean Architecture in .NET with proper layer separation for maintainable applications.
Implement CQRS (Command Query Responsibility Segregation) pattern in .NET for separated read/write operations.
Implement declarative validation rules using FluentValidation in .NET.
Use when working with Drizzle ORM for TypeScript database access. Covers schema definition, migrations, queries, relations, and integration with PostgreSQL, MySQL, SQLite, and edge runtimes.
Implement full-text search capabilities using Elasticsearch for scalable search solutions.
Build scalable web applications using Elixir Phoenix framework.
Use when implementing Event Sourcing patterns, building event-driven systems, or combining Event Sourcing with CQRS. Covers event stores, aggregates, projections, and eventual consistency.
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
Create professional, distinctive frontend designs. Use for any UI work, component creation, or design decisions.
Use when writing git commit messages, planning commits, or setting up commit conventions. Enforces Conventional Commits format with proper types, scopes, breaking changes, and semantic versioning compatibility.
Set up continuous integration workflows using GitHub Actions.
Build scalable REST APIs with Go. Perfect for high-performance backends.
Build high-performance APIs using FastAPI framework with Python type hints.
Implement GraphQL resolver functions for data fetching and mutation handling.
Implement gRPC communication between microservices using protocol buffers.
Use when building APIs with Hono framework on Bun, Deno, Node.js, Cloudflare Workers, or Vercel Edge. Covers routing, middleware, validation with Zod, RPC client, and deployment patterns.
Process streaming data using Apache Kafka Streams for real-time analytics.
Deploy and manage applications on Kubernetes clusters.
Use when working with MongoDB and Mongoose ODM in Node.js or TypeScript projects. Covers schema design, models, queries, aggregation pipelines, indexes, and connection management.
Build scalable Node.js APIs using NestJS framework with TypeScript.
Configure Nginx as a reverse proxy for routing traffic to backend services.
Use when documenting REST APIs with OpenAPI 3.x spec, generating Swagger UI, creating typed API clients, or setting up API docs in Node.js/Hono/Fastify/Express projects.
Create and use specialized subagents in OpenCode for focused tasks.
Provides guidance for implementing OpenTelemetry instrumentation in .NET codebases, covering tracing (Activities/Spans), metrics, naming conventions, error handling, performance, and API design best practices.
Process PDF files for extraction, creation, modification, and manipulation.
Use when provisioning cloud infrastructure with Pulumi using TypeScript or Python. Covers AWS, GCP, Azure resources, stacks, state management, and component resources as Infrastructure as Code.
Implement asynchronous messaging using RabbitMQ for distributed systems.
Implement API rate limiting to control request frequency and prevent abuse.
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
Implement Redis caching strategies to improve application performance and reduce database load.
Build command-line applications in Rust with proper CLI patterns and argument parsing.
Use when setting up or writing Storybook stories for React components, building component documentation, or creating visual test scenarios with controls, decorators, and play functions.
Build backend services using Supabase for database, auth, and real-time features.
Apply core patterns from superpowers library for TDD, debugging, and collaboration.
Build production-quality HTML artifacts using React, Tailwind CSS, and shadcn/ui.
Build full-stack TypeScript applications using T3 Stack (Next.js, tRPC, Prisma, Tailwind).
Apply test-driven development (TDD) methodology to build reliable, maintainable code systematically.
Advanced Test-Driven Development (TDD) patterns and workflows for maintaining high quality software with confidence.
Manage infrastructure as code using Terraform for reproducible and version-controlled deployments.
# ui-experiments Skill Collection of beautifully designed open-source layouts and UI experiments built with Origin UI and shadcn/ui. From [origin-space/ui-experiments](https://github.com/origin-space/ui-experiments). ## Available Experiments | # | Name | Demo | Description | |:--|:-----|:-----|:------------| | 01 | Dark Table | [exp1](https://crafted.is/exp1) | Dark-themed data table | | 02 | AI Chat | [exp2](https://crafted.is/exp2) | Chat interface for AI interactions | | 03 | SaaS Dashboar
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
Use when integrating vector databases for semantic search, embeddings storage, or RAG systems. Covers Pinecone, Qdrant, Chroma, pgvector, and Weaviate with TypeScript examples.
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 writing or running unit tests with Vitest in TypeScript/JavaScript projects. Covers test setup, assertions, mocking, coverage, and integration with React Testing Library.
Test web applications using Playwright for end-to-end browser testing.
Implement WebSocket communication for real-time bidirectional client-server communication.
Use when creating new skills, editing existing skills, or verifying skills work before deployment
Apply TypeScript design patterns and idioms for type-safe, maintainable code.
Implement webhook handlers for processing incoming events from external services.
Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
Use when you have a written implementation plan to execute in a separate session with review checkpoints