Skills
97,501 packaged capabilities and playbooks for agents. Install any of them with one command.
Development
Derive and debug CSS Grid layout math for grid coordinates, line placement, spans, negative indexes, fr units, minmax(), fit-content(), repeat(), auto-fill, and auto-fit. Use when building grid systems, explaining track sizing, troubleshooting fr distribution, placing items by line numbers, or converting a layout sketch into CSS Grid formulas.
Creates an EF Core entity + runs the migration that creates its table in Postgres. CRUD drill Day 1 step 5. Trigger: 'day1 step5', 'create entity/table for up-api'. Use the entity name and columns exactly as user specifies — do not suggest or add columns.
Adds the five CRUD REST endpoints (all, detail/{id}, save, update, delete) for an entity to up-api and redeploys. Use when the user asks for Day 1 step 7 of the CRUD drill, or asks to add CRUD API endpoints to up-api. Needs the same entity that was used in the entity-migration step.
Generates an Angular service that calls the up-api CRUD endpoints for a given entity (getAll, getById, save, update, delete). Use when the user asks for Day 2 step 3 of the CRUD drill, or asks to create the Angular service that talks to up-api. Needs the same entity used on Day 1.
Use this skill to build, fix, or publish a standalone HTML page or report in DataLens. DataLens takes a whole self-contained HTML document — often an AI-generated report with tables, charts, and a CSV/download button — and renders it in a sandboxed, CSP-locked iframe, so normal web code silently breaks. Reach for it when generating such a page from scratch, and when one already in DataLens misbehaves: images, fonts, scripts, or CDN libraries blocked or throwing Content-Security-Policy errors; fetch/XHR/localStorage failing; charts blank; a download or Export button doing nothing; an upload rejected as too large or the wrong encoding; or the page needing to match the user's DataLens theme (light/dark) and language (ru/en); or embedding a Yandex map. Also covers which CDNs and hosts are allowed and making the page fully self-contained. Not for DataLens chart cells or HTML-markup table columns.
Use when designing or critiquing aggregate boundaries — phrases like "aggregate", "aggregate root", "should these be one entity or two", "consistency boundary", "transactional consistency", "this aggregate is huge", "should I reference by ID or by object". Defines aggregates as transactional consistency boundaries and the rules for entity references within and across them
Use when identifying DDD anti-patterns and smells in code or design — phrases like "anemic domain model", "primitive obsession", "leaky repository", "smart UI", "transaction script", "god aggregate", "big ball of mud". Catalogs the common DDD anti-patterns with symptoms, why each is wrong, and the pattern skill that explains the fix
Use when mapping relationships between bounded contexts — phrases like "context map", "how do these two services talk", "should we use an anticorruption layer", "shared kernel vs separate ways", "upstream/downstream", "what integration pattern fits here". Catalogs the seven relationship patterns (Shared Kernel, Customer-Supplier, Conformist, Anticorruption Layer, Open Host Service, Published Language, Separate Ways) and the signals that pick one.
Use when the model is "working but feels off" and the user wants to deepen it — phrases like "supple design", "refactor toward deeper insight", "implicit concept", "the model isn't quite right yet", "what would a better model look like", "intention-revealing interfaces", "side-effect-free functions", "assertions in the domain", "conceptual contours". Covers Evans's Part III techniques for evolving a model past its first draft.
Use when the user wants to design a new domain model from scratch — phrases like "help me model X", "what's the bounded context for Y", "design a domain for this feature", "we need a domain model". Walks the user through ubiquitous language, bounded context, aggregate identification, and then routes to the relevant pattern skills. Do NOT use for code generation (route to ddd-implement) or refactoring existing code (route to ddd-refactor).
Use when modeling significant domain occurrences — phrases like "domain event", "OrderPlaced", "PaymentSettled", "something the business cares happened", "decouple these two aggregates", "eventual consistency across aggregates". Defines domain events, their naming (past tense, business-meaningful), and how they coordinate work across aggregates without violating aggregate boundaries
Use when behavior does not naturally belong to a single entity or value object—phrases like “domain service”, “this logic spans multiple aggregates”, “where does this go”, “the entity is starting to know too much”, “we need a calculator/coordinator that isn't a thing”. Defines when to introduce a stateless domain service instead of forcing behavior onto an entity. Distinguishes domain services from application and infrastructure services.
Use when creation of an aggregate or complex value object requires non-trivial work — phrases like "factory", "the constructor is doing too much", "construction has business meaning", "how do I create this aggregate", "constructor with twelve parameters". Defines when to introduce a factory and when a constructor or static creation method suffices
Use when the user wants concrete code that realizes a DDD pattern — phrases like "scaffold an entity for X", "write the Aggregate for Y", "give me the repository interface", "implement this value object". Drives the conversation through naming + invariants and then delegates code generation to a language adapter skill (e.g., ddd-kotlin-idioms for Kotlin). Do NOT use for refactoring (route to ddd-refactor), review (route to ddd-review), or design from scratch (route to ddd-design)
Use when designing how aggregates are persisted and retrieved—phrases like “repository”, “how should I load this aggregate”, “JPA repository vs DDD repository”, “leaky repository”, “finder methods”, “the repository is doing too much”. Defines a repository as the abstraction that gives the illusion of an in-memory collection of aggregates. One repository per aggregate root.
Use when the user asks for a PR-style code review for DDD smells—phrases like “is this DDD-clean”, “review this for domain modeling issues”, “what's wrong with this aggregate”, “audit this module for DDD”. Scans a file, diff, or module against the DDD anti-pattern catalog and reports specific violations with citations to the relevant pattern skill. Do NOT use when the user wants new code (route to ddd-implement) or wants to design from scratch (route to ddd-design).
Use when deciding where to spend modeling effort — phrases like "core domain", "supporting subdomain", "generic subdomain", "what's worth building vs buying", "where should the senior engineers work", "is this our competitive edge or just plumbing". Distinguishes Core (competitive edge), Supporting (custom but not differentiating), and Generic (commodity, buy/library) subdomains
Use when establishing or auditing a domain's shared vocabulary—phrases like “ubiquitous language”, “what should we call this concept”, “the team uses different words for the same thing”, “the code uses different names than the business”. Defines what a ubiquitous language is, how to grow one, and the smell tests that reveal a missing one. Do NOT use for code generation; this is a process/language skill.
Use when the user is modeling a descriptive concept with no identity — phrases like "value object", "Money", "Address", "DateRange", "primitive obsession", "wrap this primitive into a type", "two instances with the same attributes are the same". Distinguishes from entities; pairs with ddd-entity
Parse error logs, stack traces, and crash reports into a structured root cause diagnosis. Use when an application is throwing exceptions, crashing, or producing unexpected errors and you need to understand why and what to fix. Produces a structured diagnosis with error classification, stack trace walkthrough, probable root cause with confidence level, affected code path, a concrete code-level fix suggestion, and ordered next debugging steps.
Apply Gang of Four design patterns to solve architectural problems in TypeScript. Use when refactoring code architecture, implementing extensible systems, decoupling components, or following SOLID principles. Covers all 22 GoF patterns: Creational (Factory Method, Abstract Factory, Builder, Prototype, Singleton), Structural (Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy), and Behavioral (Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor).
Creates devcontainers with Claude Code, language-specific tooling (Python/Node/Rust/Go), and persistent volumes. Use when adding devcontainer support to a project, setting up isolated development environments, or configuring sandboxed Claude Code workspaces.
Inspect code diffs before opening a pull request or merging. This skill MUST be used when the user provides a code diff, pastes code changes, asks for a code or PR review, or when code is about to be submitted as a PR or merged. It MUST NOT be skipped solely because the diff is small. It SHOULD also be used before committing or handing back substantial or high-risk code changes. It MUST NOT be used when changes are limited to non-code content such as documentation, prose, images, or formatting. For small, low-risk self-changes, perform only a lightweight review without specialist dispatch. Checks requirement scope, correctness, security, compatibility, and test coverage. Triggers on: 幫我看程式 diff, 看一下程式改了什麼, review 程式碼, PR review, diff review, code review, 看看程式有沒有問題
Post-ship documentation update. Reads all project docs, cross-references the diff, updates README/ARCHITECTURE/CONTRIBUTING/CLAUDE.md to match what shipped, polishes CHANGELOG voice, cleans up TODOS, and optionally bumps VERSION. Use when asked to "update the docs", "sync documentation", or "post-ship docs". Proactively suggest after a PR is merged or code is shipped.
Advanced Effect-TS patterns for typed errors, dependency injection, concurrency, resource management, schema validation, and streaming. Use when building Effect programs — not simple Effect.succeed/fail questions, but multi-concern tasks like designing service layers with Layer composition, handling typed error hierarchies with tagged errors, managing concurrent fibers with structured concurrency, scoped resource lifecycles, schema-driven API contracts, or integrating Effect with existing Express/Hono/database stacks. Do not use for basic TypeScript or general functional programming questions.
Motion accessibility and WCAG compliance for web animations. CRITICAL: This skill should be co-loaded with elite-gsap or elite-css-animations whenever implementing animations. Covers prefers-reduced-motion (CSS and GSAP patterns), WCAG contrast requirements, APCA, focus management, keyboard navigation, touch interaction patterns, and screen reader considerations. Use when asked about: reduced motion, motion sensitivity, vestibular disorders, accessibility, a11y, WCAG, contrast ratios, focus styles, touch targets, safe areas, gesture accessibility, or making animations accessible. Also covers touch interaction patterns for mobile.
Generate an EliteForge Java service project via Maven archetype wrapper script. Use when users ask to scaffold a new EliteForge service, provide companyName/productName/serviceName (kebab-case), need Maven archetype generation execution, or want tech stack to enableXXX mapping.
Event-driven architecture patterns including message queues, pub/sub, event sourcing, CQRS, and sagas. Use when implementing async messaging, distributed transactions, event stores, command query separation, domain events, integration events, data streaming, choreography, orchestration, or integrating with RabbitMQ, Kafka, Apache Pulsar, AWS SQS, AWS SNS, NATS, event buses, or message brokers.
Use when exactly one of several properties should be present. Use when modeling mutually exclusive options. Use when building component props with alternative configurations. Use when designing API parameters that have variants.
Executes exactly one planned Jira or GitHub work-item task after critique approval. Use when a numbered task should move through kickoff, implementation, documentation, requirements verification, clean-code, architecture, and security gates, targeted fix cycles, tracker finalization, and a final report without continuing to the next task. Does not plan tasks or select the next task.
Implement Figma UI with export-faithful assets, a screen×state inventory, a control measured in its shipping parent, and a durable living spec in the target repo (state/mode/basis, required Assets subsection). With a component workbench (Storybook or similar), also deliver inventory-covering stories and spec-locking tests. Use when implementing from Figma URLs/nodes or for pixel-level restoration; light/dark is in scope when the file has modes or the project has theme switching. In the same run, measure laid-out frames via figma-pixel-verify until passing; no person is needed between iterations. Triggers — 「像素级还原」「按稿实现」「Figma 对齐实现」「还原 Figma」「figma 保真实现」「暗黑模式还原」「多主题保真实现」 / implement from Figma, pixel restore, dark mode implement, multi-theme fidelity. Do NOT use for code→Figma canvas writes, creative UI without a design, or post-implementation alignment checks alone (use figma-pixel-verify).
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.