Coding standards, frameworks, refactoring, and code review (16.4K skills)
Design and review types in statically typed languages so the compiler can reject invalid states, mixed-up identifiers, and missing cases. Guide input parsing at system boundaries and derive types from the schemas that define the data.
Find recurring agent mistakes in a repository and prevent them through architecture, types, automated checks, or tests. Verify each safeguard against a real past mistake, and record how each rule is enforced in the agent instructions.
Organize migrations and repeated edits into small changes, checking each before moving on. Arrange commits and pull requests so reviewers can follow the evidence, such as a failing test followed by the fix that makes it pass.
Guide an internal API refactor by moving callers to the new interface and removing the old one in the same round of changes. Update tests for the new contract and remove tests tied only to obsolete implementation details.
Turn substantial editing, migration, analysis, or verification work into a small, reusable tool. Produce a script, generator, or shared agent skill that performs or checks the work and lets reviewers rerun it.
Guide an AI agent through development work with clear prose, simple code, deliberate delegation, and checks against real outputs. Task-specific workflows cover investigation, implementation, review, and delivery, with decision records for longer autonomous work.
Guide planned rewrites and migrations toward a verified target architecture. Define where temporary breakage is acceptable, keep focused checks during the work, and require full static and runtime verification when the plan is complete.
Configure which AI models pstack uses for each role, along with reasoning effort, the level of reasoning applied. Detects available models, writes settings for the current environment, and controls the session startup hook where supported.
Helps users set up pstack, understand model settings, and choose skills or task procedures. It answers questions with a usable example prompt and a source link, leaving the user to start the actual work.
Guides additions, refactors, and rewrites by removing unnecessary complexity first. It prioritizes deleting dead code, redundant checks, empty references, and repetitive prompt instructions, then building around observed usage and explicit requirements.
Guide refactoring and code changes toward the smallest solution that addresses the problem. Centralize repeated decisions, pass their results as simple flags, and reconsider extra layers or boilerplate that increase the amount of code changed.
Prepare a pull request for review by checking its description, commits, and changed files. Clarify intent, highlight important files and risks, and organize history when authorized, while verifying that cleanup preserves the intended code content.
Generate several candidate solutions in parallel, compare them against concrete criteria, and choose a base. Combine useful parts from other candidates, then verify the final artifact and document why each major choice was made.
Explore a codebase to explain how a feature or subsystem works, how execution flows, and which files or packages own each responsibility. Build understanding before changes and clarify where new code should belong.
Review a branch against main and clean up unnecessary AI-generated code, including excess comments, unusual defensive checks, type workarounds, and deep nesting. Make focused edits that match surrounding code while preserving behavior unless fixing a clear bug.
Guide validation and error handling toward system boundaries, where external data enters the application. Keep business rules in functions independent of frameworks, use validated types internally, and avoid repeating checks throughout the code.
Revisit an existing design as though a new requirement had been present from the start. Examine affected files, plan the overall redesign, and carry changes through types, documentation, examples, and design rationale in incremental steps.
Investigate what a code change could break beyond the edited files. Trace downstream effects, identify the key assumption behind its safety, and test that assumption with real code while clearly reporting unresolved risks.
Design a reviewable workflow for large migrations or complex changes without an existing playbook. Define testable completion criteria, verify small changes against real results, and record decisions so someone returning later can assess what worked and what remains open.
Design commands and processing loops that reach the same final state after retries or crashes. Use the current state to apply only necessary changes, and make leftover locks, files, or records recognizable during the next run.
Review code changes with several AI models working independently. Combine overlapping findings, highlight disagreements, and sort issues by whether they need action, further consideration, or no change, producing a reasoned review without automatically editing the code.
Design stateful code around data structures that reflect real rules. The skill helps choose state machines, typed models, or lookup tables to reduce scattered conditions, duplicated assumptions, and combinations of values that should never occur.
Resolve Git merge conflicts with minimal edits that preserve public behavior. Regenerate lockfiles using package manager tools, run compilation, lint checks, and relevant tests, then stage resolved files and summarize decisions and verification results.
Review code by examining how many layers readers must follow and how much changing state they must remember. Identify unnecessary wrappers and overly broad state, making values and the places that change them easier to trace.