m

Amend the last commit with staged changes

Create a well-formatted commit from staged changes

Rewrite text or file content with clear structure and good copy

Guided debugging workflow

Implement a task from the task plan

Generate documentation for code

Explain a topic clearly in a 3-5 minute read with friendly language and practical examples

Scope a feature into structured requirements

Fix or adjust an already-implemented task

Initialize product documentation (mission, tech-stack, roadmap, changelog)

Write a well-structured LLM prompt from a rough description

Interactive git rebase with conflict resolution

Analyze the impact of a change to existing code and produce scoped requirements

Deep research with tech stack context, parallel agents, and long-form output

Code review on staged or recent changes

Create a technical specification for a feature

Generate BDD scenarios and step definitions for a feature

Break a specification into implementation tasks

Write, run, or analyze tests for code

Cross-platform clipboard operations. Use when copying text to the system clipboard via Bash.

This skill should be used when creating or updating README.md files for codebase directories. It covers LLM-optimized documentation conventions, YAML frontmatter, file listings, Mermaid diagrams, and rules for keeping READMEs current as the codebase evolves.

Text transformation skill for restructuring and improving the clarity of written content. Use when rewriting text for better organization, grouping related ideas, applying lists and structure, and producing concise copy that preserves all original details.

Task implementation workflow for the /m:dev command. Provides two execution modes: single-task mode (7-step workflow for one task at a time) and multi-task mode (wave-based orchestration with parallel subagents for feature groups, ranges, and use cases).

Conventions and rules for BDD scenario generation. Use this skill when creating Gherkin feature files, step definitions, or managing the bdd/ scaffold. It defines language/format detection, domain detection, file naming, tagging, step writing rules, and index maintenance.

Use when creating git commits, amending commits, or reviewing commit messages. Triggers on phrases like "commit my changes", "commit this", "commit what I have", "commit the staged changes", "make a commit", "save this as a commit", "create a commit", or any request to commit staged work. Also triggers via /m:commit command. Defines commit message standards: imperative verbs, 50-character limit, conventional commit prefixes adapted to the project's existing style, and absolutely no AI or tool attribution.

This skill should be used when writing, reviewing, or debugging Go tests. It covers table-driven tests, test organization, assertions, mocking patterns, coverage analysis, benchmarking, integration tests, race detection, and test quality standards.

This skill should be used when writing, reviewing, or refactoring Go code. It covers Go idioms, error handling, concurrency patterns, project structure, API patterns (HTTP, gRPC, GraphQL), security practices, documentation standards, and mandatory post-change verification.

This skill should be used when writing, reviewing, or debugging Node.js backend tests. It covers integration testing with Fastify inject and Supertest, CRUD test patterns, authentication testing, Testcontainers for Docker-based database testing, and end-to-end user flow testing.

This skill should be used when writing, reviewing, or refactoring Node.js backend code. It covers Fastify API patterns (plugins, routes, hooks), Zod validation, database access with Prisma and Drizzle, authentication and authorization (JWT, RBAC, ABAC), error handling, and Docker deployment.

This skill should be used when planning products, defining features, writing requirements, creating specifications, breaking work into tasks, or managing product development workflows. It covers document standards, ID schemes, formatting rules, estimation with story points, and vertical feature slicing.

Skill for writing clear, effective LLM prompts. Covers structure, specificity, role-setting, examples, output format specification, and iterative refinement. Model-agnostic principles that work across Claude, GPT, and other language models.

This skill should be used when creating, modifying, or reviewing React UI components. It covers Atomic Design methodology (atoms through pages), shadcn/ui setup and customization, Radix UI accessibility primitives, responsive design patterns, and component placement rules for monorepos.

This skill should be used when writing, reviewing, or debugging React component tests. It covers Testing Library query priority, user event simulation, form testing, custom hook testing, Playwright E2E testing, accessibility testing with axe-core, and keyboard navigation testing.

This skill should be used when writing, reviewing, or refactoring React code. It covers React 19 patterns (server/client components, Actions, use() hook), component composition, custom hooks, state management with Zustand and urql, and performance optimization.

Research, learn, and explain topics with clear, beginner-friendly output. Use when the user asks to research, learn about, explain, or understand a topic. Triggers on phrases like "research X", "how does X work", "explain X to me", "I want to learn about X", "what is X and how do I use it", "deep dive into X", or any request to investigate, explore, or study a technical or non-technical subject. Also triggers via /m:explain, /m:research, and /m:refactor commands.

This skill should be used when designing features, refactoring code, reviewing code quality, making architectural decisions, writing tests, or applying design principles like DRY, SOLID, KISS, and YAGNI. It covers feature slicing, testing strategies, and code quality standards.

This skill should be used when writing, reviewing, or modifying Tailwind CSS styles. It covers Tailwind v4 CSS-first configuration, utility-first patterns, the cn() utility with tailwind-merge, responsive design, dark mode, and common UI patterns for cards, buttons, forms, and layouts.

This skill should be used when writing, reviewing, or debugging TypeScript tests. It covers Vitest configuration, test organization, assertion patterns, mocking strategies, coverage analysis, parameterized tests, and test quality standards.

This skill should be used when writing, reviewing, or refactoring TypeScript code. It covers strict type configuration, type safety patterns, ESM module conventions, error handling, Biome linting/formatting, naming conventions, and mandatory post-change verification.