Coding standards, frameworks, refactoring, and code review (14.9K skills)
Delegate feature development, large code refactors, and pull request reviews to Codex, Claude Code, or OpenCode as background workers. Use isolated project checkouts, monitor progress, and arrange completion or failure notifications.
Turn GitHub issues into pull requests, proposed code changes ready for review. Filter issues, avoid duplicate work, and assign background agents to implement fixes, run tests, and optionally address review comments.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
Turn an existing discussion and codebase knowledge into a specification, then publish it to the project's issue tracker. Organize the problem, user needs, implementation decisions, testing approach, and work excluded from scope.
Review a codebase for structural problems that make understanding and testing difficult. Compare refactoring candidates in an HTML report with before-and-after diagrams, then explore the chosen option through questions about constraints, design, and tests.
Turn a course plan into numbered exercise folders with problem, solution, and explanation variants. Create starter readme files, check naming and links with the project’s linter, and fix structural errors before committing.
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.
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.
Review a coding session and identify improvements to the agent’s working environment. Examine file navigation, automated checks, instructions, tool use, and information access, then present proposed changes in order of severity.
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.