using-toolkit

SKILL.md

IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.

This is not negotiable. This is not optional. You cannot rationalize your way out of this.

Overview

Master catalog and dispatch system for all 64 toolkit skills. Ensures proper skill identification at conversation start.

How to Access Skills

In Claude Code: Use the Skill tool. When you invoke a skill, its content is loaded and presented to you — follow it directly. Never use the Read tool on skill files.


Phase 1: Skill Identification

Before ANY action: scan catalog, identify ALL matching skills (even 1% relevance), invoke via Skill tool.


Phase 2: Skill Prioritization

Invoke in order: (1) Process (brainstorming, planning) → (2) Specialist (frontend, backend, architect) → (3) Quality (TDD, review) → (4) Docs → (5) Design → (6) Ops → (7) Terminal (verification).


Phase 3: Skill Execution

Rigid skills: Follow exactly. Flexible skills: Adapt to context. Always invoke verification-before-completion before claiming done.


Available Skills (64 Total)

Core Skills (6)

Skill When to Use
using-toolkit Session start — establishes skill usage
self-learning Starting work on unfamiliar projects, or when corrected
resilient-execution When an approach fails — ensures retry with alternatives
circuit-breaker Autonomous loops, repeated operations, stagnation detection
auto-improvement Self-improving system, tracks effectiveness, learns from errors
verification-before-completion Before claiming ANY task is complete

Process & Workflow Skills (9)

Skill When to Use
planning Before ANY implementation — forces structured planning
brainstorming Before creative work — exploring ideas, features, designs
task-management Breaking work into tracked steps during implementation
executing-plans Executing approved plan documents step by step
subagent-driven-development Multi-task execution with two-stage review gates
dispatching-parallel-agents Running multiple independent tasks concurrently
autonomous-loop Ralph-style iterative autonomous development loops
ralph-status End of every autonomous loop iteration — structured progress reporting
task-decomposition Hierarchical task breakdown, dependency mapping, parallelization

Quality Assurance Skills (17)

Skill When to Use
code-review After completing tasks, before committing
test-driven-development Writing any new code (RED-GREEN-REFACTOR)
systematic-debugging Investigating bugs, errors, unexpected behavior
testing-strategy Choosing testing approach for a project
security-review Reviewing for vulnerabilities, auth, input validation
performance-optimization Optimizing speed, reducing load times
acceptance-testing Validating implementation meets spec acceptance criteria
llm-as-judge Evaluating subjective quality (tone, UX, readability, aesthetics)
senior-frontend React/Next.js/TypeScript specialist with >85% test coverage
senior-backend API design, microservices, event-driven architecture
senior-architect System design, scalability, trade-off analysis, ADRs
senior-fullstack End-to-end development across the full stack
clean-code SOLID, DRY, code smells, refactoring patterns
react-best-practices React hooks, context, suspense, server components
webapp-testing Playwright-based web testing, screenshots, browser logs
senior-prompt-engineer Prompt design, optimization, chain-of-thought
senior-data-scientist ML pipelines, statistical analysis, experiment design

Documentation Skills (5)

Skill When to Use
prd-generation Generating Product Requirements Documents
tech-docs-generator Generating or updating technical documentation
writing-skills Creating new skills, commands, or agent definitions
spec-writing Writing specifications with JTBD methodology and acceptance criteria
reverse-engineering-specs Generating implementation-free specs from existing codebases

Design Skills (3)

Skill When to Use
api-design Designing API endpoints and generating specs
frontend-ui-design Component architecture, responsive design, accessibility
database-schema-design Data modeling, migrations, indexing

Operations Skills (7)

Skill When to Use
deployment Setting up CI/CD pipelines and deploy checklists
using-git-worktrees Creating isolated development environments
finishing-a-development-branch Completing work on a branch, preparing to merge
git-commit-helper Conventional commits, semantic versioning, changelogs
senior-devops CI/CD, Docker, Kubernetes, infrastructure-as-code
mcp-builder MCP server development, tools, resources, transport layers
agent-development Building AI agents, tool use, memory, planning

Creative Skills (6)

Skill When to Use
ui-ux-pro-max Full UI/UX design intelligence with styles, palettes, fonts, UX guidelines
ui-design-system Design tokens, component libraries, Tailwind CSS, responsive patterns
canvas-design HTML Canvas, SVG, data visualization, generative art
mobile-design React Native, Flutter, SwiftUI, platform HIG compliance
ux-researcher-designer User research, personas, journey maps, usability testing
artifacts-builder Generate standalone artifacts, interactive demos, prototypes

Business Skills (3)

Skill When to Use
seo-optimizer Technical SEO, meta tags, structured data, Core Web Vitals
content-research-writer Research methodology, long-form content, citations
content-creator Marketing copy, social media, brand voice

Document Processing Skills (3)

Skill When to Use
docx-processing Word document generation, template filling
pdf-processing PDF generation, form filling, OCR, merge/split
xlsx-processing Excel manipulation, formulas, charts

Frameworks & Languages Skills (3)

Skill When to Use
laravel-specialist Laravel development — Eloquent, Blade, Livewire, queues, Pest
php-specialist Modern PHP 8.x — PSR standards, static analysis, Composer
laravel-boost Laravel Boost performance optimization — caching, queries, N+1

Productivity Skills (1)

Skill When to Use
file-organizer Project structure, file naming, directory architecture

Communication Skills (1)

Skill When to Use
email-composer Professional email drafting, tone adjustment

Decision Table: Choosing the Right Skill

User Request Contains Primary Skill Supporting Skills
"build", "implement", "create feature" planning brainstorming, tdd, code-review
"fix", "bug", "error", "broken" systematic-debugging tdd, resilient-execution
"test", "coverage", "spec" test-driven-development testing-strategy, acceptance-testing
"review", "check", "audit" code-review security-review, clean-code
"plan", "how should we" planning brainstorming, task-decomposition
"deploy", "CI/CD", "pipeline" deployment senior-devops
"API", "endpoint", "REST", "GraphQL" api-design senior-backend
"React", "Next.js", "component" senior-frontend react-best-practices, frontend-ui-design
"Laravel", "Eloquent", "Blade", "Livewire" laravel-specialist php-specialist, laravel-boost
"PHP", "Composer", "PSR" php-specialist laravel-specialist
"database", "schema", "migration" database-schema-design senior-backend
"design", "UI", "UX" ui-ux-pro-max ui-design-system, frontend-ui-design
"mobile", "iOS", "Android" mobile-design ui-ux-pro-max
"document", "docs", "README" tech-docs-generator prd-generation
"spec", "requirements", "PRD" spec-writing prd-generation
"autonomous", "loop", "ralph" autonomous-loop ralph-status, circuit-breaker
"performance", "optimize", "slow" performance-optimization laravel-boost
"security", "vulnerability", "auth" security-review senior-backend
"SEO", "meta tags", "search engine" seo-optimizer content-research-writer
"email", "draft", "compose" email-composer content-creator
"PDF", "Word", "Excel" pdf-processing / docx-processing / xlsx-processing
"agent", "AI", "tool use" agent-development mcp-builder
"MCP", "server", "transport" mcp-builder agent-development

Workflow Patterns

Pattern Skill Chain
"Build feature X" brainstorming -> planning -> executing-plans -> code-review -> verification
"Fix bug Y" systematic-debugging -> TDD -> code-review -> verification
"Write new code" test-driven-development (always)
"Run autonomously" autonomous-loop -> ralph-status -> circuit-breaker
"Write specs" spec-writing (JTBD methodology)
"Understand legacy code" reverse-engineering-specs -> spec-writing (audit)
"Check acceptance criteria" acceptance-testing (backpressure chain)
"Validate subjective quality" llm-as-judge (rubric-based evaluation)
"Document the API" tech-docs-generator or api-design
"Create a PRD for Z" prd-generation
"Set up CI/CD" deployment
"How should we test?" testing-strategy
"Design the database" database-schema-design
"Build a UI component" frontend-ui-design
"Check for security issues" security-review
"Make it faster" performance-optimization
"Done with this branch" finishing-a-development-branch
"Design a UI" ui-ux-pro-max -> ui-design-system -> frontend-ui-design
"Build mobile app" mobile-design -> planning -> tdd
"Optimize SEO" seo-optimizer
"Write marketing copy" content-creator
"Process documents" docx-processing / pdf-processing / xlsx-processing
"Compose email" email-composer
"Build an AI agent" agent-development -> planning -> tdd
"Set up infrastructure" senior-devops -> deployment
"Decompose complex task" task-decomposition -> dispatching-parallel-agents
"Build Laravel feature" laravel-specialist -> planning -> tdd -> code-review
"Optimize Laravel app" laravel-boost -> performance-optimization -> verification
"Write PHP code" php-specialist -> tdd -> clean-code

Anti-Patterns

  • Never skip skill check for "simple" tasks — always check catalog
  • Never invoke skills from memory — use Skill tool for current version
  • Never read skill files with Read tool — use Skill tool
  • Never skip verification — always invoke verification-before-completion last
  • Never respond before checking skills — skill check is ALWAYS first

Anti-Rationalization Guards

If you think "This is just simple / I need context first / Let me explore first / This doesn't need a skill / I remember this skill / The skill is overkill / I'll do one thing first" — STOP. Check for skills FIRST. No exceptions.


Integration Points

Key integrations: self-learning (project context), verification-before-completion (terminal checkpoint), circuit-breaker (stall safety), auto-improvement (effectiveness tracking), planning (most common first skill), resilient-execution (failure recovery).


Core Rules

Plan before coding. TDD always. Verify completion with evidence. Review before merge. Use subagents for parallel work. Self-learn continuously. Try 3 approaches before escalating. Report RALPH_STATUS in loops. Protect config files. Write specs with acceptance criteria.


Skill Types

Rigid (TDD, debugging, planning, verification, code-review, autonomous-loop, circuit-breaker, spec-writing, acceptance-testing): Follow exactly. Flexible (brainstorming, tech-docs, api-design, frontend, database, performance, security-review, prd-generation, laravel-specialist, php-specialist): Adapt to context.


Find Missing Skills

npx skills find [query] to search, npx skills add <owner/repo@skill> -g -y to install. Prefer 1K+ weekly installs from reputable sources.


Skill Type

RIGID — Skill checking is mandatory. Every task begins with a catalog scan. No exceptions. No rationalization.

Weekly Installs
5
First Seen
Today
Installed on
amp4
cline4
opencode4
cursor4
kimi-cli4
warp4