Development skills

Review a pull request for code quality, correctness, security, tests, and documentation. Receive structured findings ranked by severity, with file references, approval status, positive highlights, and questions that need clarification.

• Reviewing a pull request before merging
• Checking changes against the original plan
• Auditing error handling and validation of AI output

Turn an agreed product direction into a technical specification before coding. Create architecture and flow diagrams, define failure handling and input validation, and map tests to the behavior engineers need to implement.

• Define architecture before implementing a complex feature
• Map background jobs and external API interactions
• Check failure recovery paths and test coverage

Suggests running verbose shell commands through RTK, a tool that condenses command output, and executes them after confirmation. It helps reduce the text an AI agent processes when reviewing Git history, tests, builds, and files.

• Reducing output when reviewing Git history and diffs
• Condensing long test and build results
• Reading large files with less command output

Turn a feature request into an implementation plan before coding. Five planning phases cover requirements, interface design, technical choices, research, and metrics, producing ordered tasks, a test plan, and records explaining major decisions.

• Planning a feature that touches several files
• Resolving unclear requirements before implementation
• Recording architecture and interface decisions

Turns Git commits and pull request details into release notes for CHANGELOG.md, a release pull request, and Slack. It categorizes changes, explains user impact in plain language, and flags database migrations that need attention.

• Preparing release notes since the last release
• Summarizing changes across a specified version range
• Drafting a release pull request body

Diagnose failures in an application or while it is running. Use it to investigate an application problem or a runtime error, meaning an error that occurs during execution.

• Investigating an error during execution
• Diagnosing an application failure
• Asking an agent to examine a running application's problem

Measure code patterns such as casts to any or disabled lint rules, then run repeated, targeted edits. Keep changes that improve the chosen metric, revert unsuccessful changes, and track results for each improvement loop.

• Finding code patterns to prioritize for cleanup
• Preparing measurement files for an improvement loop
• Repeating targeted edits to reduce casts to any

Trace how AI tooling developed in a Git repository by identifying configuration file origins, monthly commit activity, major changes, and relevant releases. Produce a Markdown report that explains adoption phases and turning points using Git evidence.

• Finding when AI configuration files were first introduced
• Reviewing monthly activity around AI tooling changes
• Tracing major integrations and workflow changes

Troubleshoot Claude Code problems by comparing reported symptoms with configuration scans and a troubleshooting guide. It asks follow-up questions when needed and proposes targeted fixes for permission prompts, tool connections, hooks, installation errors, and performance issues.

• Investigating repeated permission prompts
• Diagnosing MCP server connection failures
• Checking why settings or hooks are ignored

Explain code, design concepts, and system behavior at a chosen level of detail. Get a brief overview or a deeper walkthrough covering execution flow, design choices, alternatives, usage examples, and related code.

• Understanding an unfamiliar file or function
• Tracing authentication or data flow
• Comparing design choices and alternatives

Clean up Git worktrees, separate working folders for branches, by identifying merged branches and reviewing unmerged ones. Preview deletions, preserve protected branches, and receive a report of removed folders and reclaimed disk space.

• Clean up worktrees after merging branches
• Preview deletions and potential disk savings
• Review unmerged worktrees individually

Sort open GitHub issues by category, risk, inactivity, and possible duplication. Examine selected reports in detail, identify missing information, and prepare comments, labels, or closures for user approval before taking action.

• Sort accumulated bug reports and feature requests
• Check possible duplicates against open and closed issues
• Review inactive issues for follow-up or closure

Analyze code, database queries, or systems for performance problems involving speed, memory, and frontend file size. Get prioritized recommendations with code examples, expected impact, implementation effort, risks, and a roadmap for improvements.

• Investigate a slow function or module
• Review memory usage and possible leaks
• Find inefficient database queries

Remove a specific Git worktree, a separate working directory for a branch, after checking uncommitted work and merge status. Clean up branches and stale references, protect important branches, and provide reminders for related database cleanup.

• Remove a worktree after finishing a task
• Check for unmerged or uncommitted work before removal
• Remove a worktree while keeping its branch

Create a separate Git working directory for feature development without switching your current branch. The skill checks branch names and ignore settings, prepares dependencies, and starts background checks, with options for separate dependency installation.

• Starting feature work in a separate working directory
• Preparing a workspace for a bug fix
• Testing dependency upgrades with a fresh installation

Coordinate feature development from product direction through architecture, planning, validation, and implementation. Run the whole workflow or start at a selected stage, with saved decisions, review checkpoints, and a final pull request.

• Take a feature idea through planning and implementation
• Review architecture before writing an implementation plan
• Validate an existing plan before execution

Audit a collection of agent skills for valid settings, clear activation conditions, complete workflows, and required files. Get scores for each target platform, prioritized fixes, and a separate record of whether activation was actually tested.

• Checking skill quality before publication
• Reviewing an imported skill collection
• Investigating excessive or missing automatic activation

Create a reusable command with explicit preconditions, numbered actions, checks after each step, and error handling. This template provides a structure to customize so Claude verifies the required context before starting a defined workflow.

• Turning a recurring task into a reusable command
• Defining checks for files, permissions, and configuration before work
• Adding validation after each workflow step

Analyze files or modules for duplicated code, excessive complexity, and violations of SOLID, five software design principles. Get prioritized refactoring suggestions with affected locations, risks, estimated effort, and testing needs to guide code improvements.

• Reviewing responsibilities in oversized files and classes
• Finding duplicated code and deeply nested logic
• Prioritizing refactoring by impact, risk, and effort

Rebuild project context after clearing a conversation or returning to work. Review recent Git history, uncommitted changes, and TODO markers to get a structured summary of project status and suggested next steps.

• Restoring project context after /clear
• Reviewing recent changes after a long break
• Checking unfinished work before choosing the next task

Analyze changed files and commits before opening a pull request, a proposed code change for review. Identify oversized or unrelated changes, suggest splits, and create a GitHub PR with a summary, description, and checklist.

• Prepare a pull request for review
• Check whether large changes should be split
• Create a draft PR with labels

Investigate bugs by tracing symptoms through code and recent changes, reproducing failures, and testing a specific cause before fixing it. Produce a focused correction, a regression test to catch recurrence, and an evidence-based debugging report.

• Investigate errors that keep returning after fixes
• Trace a regression through recent changes
• Analyze failures that occur only in certain environments

Audit Claude Code instruction rules against actual project files to find broken settings, overly broad scopes, and loading issues. Review each rule’s usefulness with the user, then apply confirmed changes or produce an audit report.

• Setting up Claude Code rules for the first time
• Investigating rules that apply too often or never
• Reviewing outdated instructions

Compare alternative ways to solve a coding problem, including when each approach fits and its advantages and drawbacks. Get a comparison table and a recommendation based on the current context, with code examples in detailed mode.

• Compare authentication approaches
• Choose how to manage form state
• Evaluate data fetching or styling options