using-toolkit

Q: How do I install using-toolkit?

Run npx skills add https://github.com/pixel-process-ug/superkit-agents --skill using-toolkit in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/using-toolkit/ (personal) or .claude/skills/using-toolkit/ (project).

by pixel-process-ugProductivity & Automation

Use when starting any conversation, receiving a new task, or when uncertain which skill applies - establishes how to find and use all 64 toolkit skills, requiring Skill tool invocation before ANY response including clarifying questions

Installs: 80
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/pixel-process-ug/superkit-agents --skill using-toolkit

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads using-toolkit automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

<EXTREMELY-IMPORTANT> If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.

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. </EXTREMELY-IMPORTANT>

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.

FAQ

What does the using-toolkit skill do?

How do I install using-toolkit?

Run npx skills add https://github.com/pixel-process-ug/superkit-agents --skill using-toolkit in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/using-toolkit/ (personal) or .claude/skills/using-toolkit/ (project).

Which AI agents can use using-toolkit?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is using-toolkit safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains using-toolkit?

It is published by pixel-process-ug in pixel-process-ug/superkit-agents. It has 80 recorded installs.