14.9K skills · sorted by popularity
Test an idea before committing to full development by building a small, disposable prototype. Compare approaches under equal conditions, try a failure case, and report feasibility with commands, results, or measurements supporting the verdict.
Manage GitHub issues and pull requests, proposed code changes, using the gh command-line tool. Create and inspect discussions, check automated test results, investigate failed logs, rerun jobs, and track authorized merges through to their verified status.
Investigate Node.js bugs by pausing execution, examining variables, and stepping through code. Diagnose stalled asynchronous work and unreliable tests, or collect memory snapshots and CPU profiles to investigate growing memory use and slow execution.
Investigate performance bottlenecks in REA analysis workflows and improve caching, queries, or shared processing. Compare completed tasks before and after changes while preserving correct results, examined coverage, and access to supporting evidence.
Design or change REA investigation tools by defining responsibilities, inputs, results, and CLI or MCP interfaces. Produce a proposal that explains how Evidence records should be interpreted, compares the nearest existing alternative, and outlines verification.
Investigate shipped applications, binaries, packages, and firmware with REA to explain features, compare versions, or guide reconstruction. Use decompiled code and runtime observations where needed, keeping observed facts, inferred behavior, and unresolved questions clearly separated.
Finish completed development work by checking the full test suite and presenting integration choices: merge locally, create a Pull Request, or keep the branch. It carries out the selected path and handles workspace cleanup accordingly.
Requests a code review from a separate agent after implementation or before merging. It provides the change summary, requirements, and commit range, then guides follow-up work according to the severity of the findings.
Turn specifications or requirements into an implementation plan before coding begins. Break work into testable tasks with exact files, function definitions, test assertions, and verification commands, so another developer or agent can follow the plan.
Create, revise, and validate agent skills through tests that compare behavior with and without the instructions. It helps identify unclear guidance, choose an appropriate document structure, and refine wording before deployment.
Carry out an implementation plan by assigning each task to a separate agent, then reviewing specification compliance and code quality. Keep progress in files and review the complete set of changes after all tasks are finished.
Carry out an existing implementation plan in one session, task by task. Verify each step with tests, record progress and decisions in a file, and finish with a review of all changes on the branch.
Prepare a separate workspace for feature development using platform tools or git worktree, which gives a branch its own working directory. It checks existing isolation, prepares dependencies, and runs tests before implementation begins.
Evaluate code review feedback against the actual code, supported environments, and existing behavior. Clarify uncertain requests, respond with technical evidence, and implement valid changes one at a time with tests for each fix.
Investigate bugs, failing tests, and unexpected behavior using reproduction steps, logs, and recent changes. Follow a structured process to identify the root cause, test a specific explanation, and verify the resulting fix.
Examine superpowers session records to document repeated work, departures from plans, delays, and token usage. Produce an evidence-based report with file and line references, and prepare bug-report material when requested.
Assign independent bugs or test failures to separate agents that work at the same time. Define each agent’s scope and expected report, then check for conflicting changes and run the full test suite before integrating fixes.
Design modules that offer substantial behavior through a small interface, the rules callers must understand. Use shared design terms to simplify usage, contain complexity, choose where implementations can vary, and make behavior easier to test.
Clarify a project's business concepts and terminology through concrete scenarios and comparisons with code. Record agreed definitions in a glossary and document significant design trade-offs in ADRs, records explaining why a decision was made.
Write a pull request description that helps reviewers understand a code change. Use a compact diagram or diff, show before-and-after evidence, and explain how reversible the change is and what areas it may affect.
Sort issues and external pull requests, which are proposed code changes, by category and readiness. Verify reports, identify missing information, and record clear briefs so an agent or a person can take the next step.
Sharpen a plan or design through persistent questioning while creating documentation along the way. The resulting documents include architecture decision records, which capture design choices, and a glossary of terms used in the discussion.
Implement work described in a specification or tickets, checking types and running tests along the way. Review the completed changes with the code-review skill, then commit the implementation to the current branch.
Review code changes from a chosen Git reference against two separate criteria: documented coding standards and the original requirements. Independent reviewers check each criterion, then present findings separately so convention problems and requirement gaps remain visible.