skill-visualizer
Generate interactive HTML visualizations of the skills collection, codebase structure, or dependency graphs. Uses D3.js for interactive visualization with collapsible nodes, color-coded categories, and hover details. Triggers on "visualize skills", "generate skill map", "codebase visualization", or "show skill dependencies".
brainstorm
Interactive idea refinement using Socratic questioning methodology. This skill should be used when users want to explore an idea, find gaps in concepts, enhance proposals, or structure thoughts before implementation planning. Triggers on "brainstorm", "explore this idea", "find holes in", "help me think through", "what am I missing", or when presenting rough concepts that need refinement. Output integrates with create-plan skill.
context-saver
Write the current session's in-flight work state to a human-readable handoff doc on disk (docs/context/CONTEXT-{topic}.md) so a future chat session — or another person — can pick up exactly where this one stops. Distinct from Claude Code's built-in memory system, which captures long-lived facts and preferences; this skill captures **active session context** (what's being built right now, which files are mid-edit, what's been tried, what's next). Use when the user says "save context", "checkpoint", "save progress", "preserve state", "save before I step away", "dump this so I can continue tomorrow", or before ending a long session with incomplete work. Optimizes for correctness, completeness, minimal size, and trajectory preservation.
create-plan
Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "plan the implementation", "design how to implement", or when given a feature/task that needs structured planning before implementation.
workflow-guide
Recommend which workflow mode fits the task at hand — solo (implement-plan), small team (team-implement-plan with Implementer + Reviewer), full team (team-implement-plan-full with parallel per-phase implementers + shared Reviewer), or a dynamic workflow (the Workflow tool — deterministic parallel fan-out across tens-to-hundreds of background agents for large read/analyze/audit/research jobs, e.g. /tt-workflow-audit). Factors in task complexity, risk, parallelism, work shape (analyze vs implement), and token budget. Use when the user asks which workflow to pick, is unsure whether to go solo or team-based, mentions "which mode should I use", asks "solo or team for this", "should I use a workflow", "parallel audit", or is about to kick off execution without having chosen a mode. Triggers on "/workflow-guide", "which workflow mode", "solo or team", "pick a workflow", "dynamic workflow or team".
verification-loop
Comprehensive 6-check verification framework for validating implementation quality across build, types, lint, tests, security, and diff review. This skill ensures code meets all quality gates before phase completion. Triggers on "verify implementation", "run verification", "/verification-loop", or automatically as part of implement-phase Step 2.
user-story
Generate hierarchical user stories (epics, features, tasks) with formal Given/When/Then acceptance criteria. Works from brainstorm output or standalone. Produces structured requirements that feed directly into create-plan. Triggers on "create user stories", "write stories", "define requirements", "user story", or when presenting features that need requirements decomposition.
tt-workflow-run
Tasktracker-native autonomous build-loop orchestrator. Drives a first-class `workflow_run` end-to-end — create the run (Gate 1 lifecycle completeness + Gate 2 zero-defects-in), then loop while `getNextReadyTask(projectId)` returns a slice — `setActiveTask` → record a pre-slice `scanArchitectureDrift` baseline → delegate the slice to `/tt-implement-phase` (which does the code work, registers the architecture delta in-slice, and auto-logs defects/learnings/frictions) → re-scan drift (Gate 3 architecture-followed) + re-read `getDefectStats` (Gate 2 delta) → read `getTimeSummary` for measured time + classify the slice's layer → `workflow_recordIteration` (appends an immutable by-layer measured-only projection version) → `pauseActiveTask` before any human gate — until the backlog drains, then `workflow_completeRun`. Loose coupling (brainstorm Fork B): the run is pure tasktracker data driven by a thin skill over EXISTING MCP tools + `/tt-implement-phase`; there is NO backend-callable Workflow API and `/loop` is only an optional outer cadence. The skill logs the RUN'S OWN insights too — a "no data" friction when heartbeating was off for a slice (principle #11), a learning on notable patterns, a defect for any new error above baseline. Use whenever the user wants to "run the workflow", "start an autonomous build loop", "drive the backlog to done", "dogfood the run", or "/tt-workflow-run" AND the work is tracked in tasktracker with a passable lifecycle. Triggers on "tt workflow run", "/tt-workflow-run", "start a workflow run", "run the build loop", "autonomous loop (tasktracker)", "drive the next-ready backlog". Prefer this over /tt-implement-plan when you want measured-time projection + per-slice drift/defect gates + a versioned remaining-effort series on top of phase execution; /tt-implement-plan just runs phases in order with no run entity, no projection, no per-slice gate ledger.
tt-workflow-build
Tasktracker-native trigger for a PARALLEL build via the Claude Code Workflow tool. Thin by design — it does two things, then drives to done: (1) ensure a tasktracker project exists (use the existing one, or create one), then (2) start a dynamic `Workflow` that builds it, tracking the work in tasktracker and using the build + verify skills. It does NOT analyze parallelism up front, ask the user to choose a mode, hand back, or fall back to a sequential skill — get a project, start the workflow, drive autonomously to done (pausing only at real human gates like deploy). Use when the user wants a build driven by the parallel Workflow engine — typically after /tt-brainstorm + /tt-create-plan, or standalone. Triggers on "/tt-workflow-build", "build this with a workflow", "parallel build (tasktracker)", "fan out the build". Prefer /tt-implement-plan or /tt-workflow-run only when the WHOLE job is irreducibly sequential; prefer /tt-workflow-audit for read-only analysis.
grumpy-reviewer
A single grumpy, nitpicky structural code reviewer that runs as an isolated subagent and treats the code as third-party work submitted by a junior programmer for validation. It cares about exactly one thing — maintainability — judged through separation of concerns, service-oriented design, helper-method extraction, small files, and the rule of 7 (as any grouping nears 7 members, it pushes for sub-groupings). It is deliberately kept OUT of the implementation flow: it never learns how the code was produced, only a one-line statement of what it is supposed to do, and its report is plain and factual — the grumpiness is in the scrutiny, not the prose. Use before merging, or any time the user wants a harsh structural / maintainability / "is this well-factored" opinion: when a file, class, function, or parameter list feels too big or over-stuffed; when responsibilities look tangled or a layer (controller, handler, component) is doing too much; when the user asks whether to split or break up a unit, whether helpers should be extracted, where the code "will rot", or whether it is maintainable; or for a grumpy / pedantic / nitpicky / curmudgeon second opinion that ignores how the code came to be. Triggers on "/grumpy-reviewer", "grumpy review", "nitpicky review", "structural review", "is this well factored", "too many responsibilities", "where will this rot", "should I split this up", "this file/class/method feels too big", "check separation of concerns", "review my structure", "rule of 7". Do NOT use it for correctness or behavior reviews — "does it work", "will it crash", "find bugs", "review under load", "is it reliable" — that is /adversarial-reviewer; nor for security reviews — injection, auth, secrets, OWASP — that is /security-review; nor for the per-phase architectural-compliance / ADR gate inside implement-phase — that is /code-review. This skill is one opinionated maintainability reviewer, nothing else.
design-language
>-
eval-harness
Build evaluation harnesses for AI-assisted implementations — capability evals, regression tests, graders (exact-match, LLM-judge, code-exec, rubric), and standardized metrics (pass@k, accuracy, latency, cost). Use when the user wants to set up or run evals, benchmark agents/skills, create regression test suites for prompts or AI features, compare model/prompt variants, or measure implementation quality. Triggers on "set up evals", "create eval harness", "benchmark this skill", "regression test the prompt", "run evals", "/eval-harness", or any request to systematically measure AI output quality.
e2e-testing
Comprehensive E2E testing skill using Playwright MCP for systematic web application testing. This skill should be used when users need to test web-based systems end-to-end, set up test regimes, run exploratory tests, or analyze test history. Triggers on requests like "test my webapp", "set up E2E tests", "run the tests", "what's been flaky", or when validating web application functionality. The skill observes and reports only - it never fixes issues. Supports three modes - setup (create test regime), run (execute tests), and report (analyze results).
adversarial-reviewer
Adversarial code review that breaks the self-review monoculture by spawning three independent subagent personas (Saboteur, New Hire, Security Auditor) in parallel isolated contexts. Each subagent has no knowledge of the author's intent or Claude's prior conclusions — Claude cannot replicate that isolation on its own. Default mode reviews a diff (staged/unstaged, or explicit ref/file); `--codebase` mode reviews an entire repo or subtree for tech debt, attack surface, and knowledge silos. Use before merging a PR, when the user asks for a hostile/harsh/adversarial/critical/brutal/skeptical review, when the user admits fatigue after a long session, when an earlier /code-review came back too easily clean, when the user trusts a gut feeling that something is off, or when the user wants a whole-codebase audit of an inherited / unfamiliar repo. Triggers on "/adversarial-reviewer", "/adversarial-review", "adversarial review", "hostile review", "critical review", "harsh review", "review this PR harshly", "second-opinion review", "pre-merge review", "adversarial audit of this repo", "what am I inheriting". Different from /code-review (routine per-phase review; no subagent isolation) and /security-review (OWASP-specific single-lens depth).
code-quality-audit
Run code quality audits covering test coverage, cyclomatic complexity, module sizes, dependency structure (cycles, fan-in/out), and mutation testing. Produces a prioritized report and acts as a quality gate. Use whenever the user wants to audit code quality, check coverage, find complex or oversized modules, detect dependency cycles, run mutation tests, assess technical debt, or gate a phase on quality thresholds. Triggers on "audit code quality", "check coverage", "run mutation testing", "find complex modules", "check for cycles", "/code-quality-audit", or automatically before marking an implementation phase complete.
code-review
Systematic code review for implementation phases verifying architectural principles, framework standards, ADR compliance, and code quality. This skill is invoked by implement-phase as part of its quality gate pipeline, or manually when reviewing code changes. Triggers on "review code", "code review", "/code-review", or automatically as Step 3 of implement-phase.
implement-plan
Orchestrate the execution of complete implementation plans, delegating each phase to implement-phase skill. This skill manages the full plan lifecycle including phase sequencing, user confirmation between phases, and overall progress tracking. Triggers on "implement the plan", "execute the implementation plan", or when given a path to a plan file.
codebase-audit
Long-running comprehensive adversarial audit of an entire codebase. Orchestrates partition-by-partition adversarial reviews by delegating to /adversarial-reviewer --codebase <partition>, then synthesizes a cross-partition risk register and a written remediation report. Unlike /adversarial-reviewer --codebase (which samples strategically from the whole repo in one pass), this skill methodically covers the full scope over a long session, is resumable after crashes, and produces a consulting-style deliverable. Use for onboarding audits of inherited codebases, pre-acquisition code due diligence, periodic tech-debt health checks, or when the user asks for a "comprehensive / thorough / exhaustive / deep / no-stone-unturned review of the codebase". Triggers on "/codebase-audit", "comprehensive codebase review", "full codebase audit", "thorough audit", "code due diligence", "tech debt audit", "what am I inheriting (comprehensive)". Different from /adversarial-reviewer --codebase (strategic sample, single pass) and /code-quality-audit (metrics-based: coverage/complexity/cycles/mutation).
codebase-research
Orchestrates comprehensive codebase research by decomposing user queries into parallel sub-agent tasks and synthesizing findings. This skill should be used when users ask questions about how code works, where functionality exists, how components interact, or need comprehensive documentation of existing implementations. It focuses exclusively on documenting and explaining the codebase as it exists today.
continuous-learning
Promote valuable session learnings into reusable, triggerable skill files in ~/.claude/skills/learned/. Unlike Claude Code's built-in memory (which captures conversational facts and preferences), this skill extracts structured patterns — error resolutions, user corrections, workarounds, debugging techniques, project conventions — that future sessions can match against specific triggers. Use at end of a session (typically via Stop hook), after solving a hard bug, when the user says "save what we learned", "remember this for next time", or "extract patterns from this session".
deep-brainstorm
Multi-session, resumable deep brainstorming with mindmap-on-disk structure. Explores ideas across multiple dimensions using creative methodologies (Morphological Analysis, TRIZ, Lateral Thinking, Lotus Blossom, Assumption Mapping). Sessions persist to filesystem and can span days. Triggers on "deep brainstorm", "deep dive brainstorm", "multi-session brainstorm", "brainstorm deeply", or when the user wants extended, resumable idea exploration. Higher depth than brainstorm or team-brainstorm but spread across sessions.
agent-creator
|
adr
Document architectural decisions in standardized ADR format. This skill should be used when making significant technical decisions, choosing between approaches, establishing patterns, or when other skills (create-plan, implement-plan, brainstorm) identify decisions that need documentation. Triggers on "document decision", "create ADR", "architectural decision", or automatically when invoked by other skills during planning and implementation.
clodex-workflow
Use when coordinating Claude Code CLI planning with Codex CLI implementation and dual adversarial audit.
beatflow-skill
Compose, arrange, revise, validate, compare, inspect, and export original multi-track music as Standard MIDI with Codex and BeatFlow's style-neutral Python DSL. Use for translating a musical brief into coordinated instrumental roles, writing complete songs in any genre, diagnosing rhythm or phrasing problems, or working with BeatFlow Composition 1.1 and MIDI files.
codex-delegator
Automatically delegate complex, logic-intensive tasks to OpenAI Codex CLI via `codex exec --full-auto`. Claude Code uses this skill to invoke Codex for complex backend logic, intricate algorithms, or persistent bugs. Enables seamless AI-to-AI collaboration where Claude Code analyzes and Codex executes.
gh-cli
This skill should be used when working with GitHub CLI (gh) for any task including code search, workflow debugging, GitHub Pages deployment, or general GitHub operations. Use this skill for enhanced code search capabilities, analyzing failed workflow runs, managing GitHub Pages, or any gh command usage.
github-actions-writer
This skill should be used when users need to create, modify, optimize, or troubleshoot GitHub Actions CI/CD workflows. Use when users ask about automating builds, tests, deployments, or any GitHub Actions-related tasks. Triggers include requests like "create a CI workflow", "deploy to AWS", "automate testing", "setup GitHub Actions", or when debugging workflow failures.
conference-scheduler
Generate optimized conference schedules using Google OR-Tools CP-SAT solver. Use when the user needs to create conference schedules from CSV data with constraints like speaker conflicts, track distribution, room assignments, educational flow, and speaker availability. Supports both single-day and multi-day conferences. Handles inputs from Google Sheets CSV exports with talks (ID, title, summary, track, level, speakers, availability) and schedule slots (day, times, rooms). Outputs CSV and Markdown schedules.
thymer-capture
Capture notes, logs, and journal entries to Thymer. Use when user says "note this", "log this", "capture this", "add to journal", "inbox this", "save this conversation", or wants to save content to their Thymer workspace.
skill-loader
Skill-Loader standards and best practices for Skill Loader. Includes implementation guidelines, common patterns, and testing strategies.
legacy-bridge
Backward compatibility bridge that translates legacy @load patterns to new Skills format. Enables seamless migration with zero breaking changes during 6-month transition period.
nist-compliance
NIST 800-53r5 control implementation, tagging, evidence collection, and compliance automation for security frameworks
security-practices
Modern security standards including Zero Trust Architecture, supply chain security, DevSecOps integration, and cloud-native protection
coding-standards
Comprehensive coding standards and best practices for maintainable, consistent software development across multiple languages and paradigms
testing
Comprehensive testing standards including unit, integration, security, and property-based testing with TDD methodology
annotate
Create flexible annotation workflows for AI applications. Contains common tools to explore raw ai agent logs/transcripts, extract out relevant evaluation data, and llm-as-a-judge creation.
pi-extension-builder
Use when user says "create pi extension", "build extension for pi", "extend pi", or wants to customize pi agent behavior with tools, commands, events, or UI components.
teach-me
Teach the user a new skill or concept, within this workspace.
tmux
Use when you need a persistent terminal environment for long-running processes, programs requiring a TTY, REPLs, debuggers, TUI apps, or concurrent terminals — while the agent continues executing other commands.
clear-writing
Use when writing or editing any prose humans will read — documentation, commit messages, error messages, UI text, reports, or explanations. Also use when user says "write clearly", "clear writing", or "improve writing".
jira
Manage JIRA tickets. Use it when the user mentions JIRA with ticket IDs like FOO-123.
continuous-learning
Review a finished session for reusable knowledge, then, with user consent, update shared skills and project AGENTS.md guidance.
learning-opportunities
Use when finishing a feature or bugfix with new files, modules, schema changes, refactors, design decisions, or unfamiliar patterns, or when the user asks to learn, practice, understand the reasoning, or says "teach me", "help me understand", "walk me through", or "quiz me".
napkin
Use at session start and whenever updating `.sandbox/napkin.md`. Owns the durable runbook: what belongs there, what stays out, and how hard to prune it.
writing-skills
Use when creating new skills, editing existing skills, or verifying skills work before deployment
pattern-toggling-package-extension-tools
Use when a Pi extension must enable or disable tools that come from another installed extension or package, especially when the tool definitions should disappear from prompts without disabling slash commands or forking the upstream package.
llm-wiki
Use when initializing a new personal knowledge base (wiki) from the LLM Wiki pattern — a structured markdown repo where the LLM incrementally builds and maintains interlinked pages between raw sources and a persistent wiki layer
kibana-elasticsearch
Use when querying an Elasticsearch index via the Kibana console proxy, filtering logs by field values, or investigating errors from job or application logs.
journal
Use at session start, after context compaction, and before session end. Owns session journals in `.sandbox/journals/`: when to create one, what prior context to read, what to log, and how to leave a resumable handoff
Page 1007 of 1732 · 86567 results
