Development skills

Help a new contributor prepare the Chops development environment, generate its Xcode project, and build the app. The skill also explains the main code areas and common tasks, such as adding a tool source or changing skill parsing and the UI.

• Preparing a Mac for Chops development
• Generating and building the Xcode project
• Learning where app features are implemented

Use this skill to verify that a change meets the original request before reporting it as complete. It guides agents to run the project’s real checks, read the output, look for side effects, and state clearly what remains unverified.

• Checking a fix before calling it done
• Reviewing project checks before a commit or pull request
• Reporting work with unverified parts

Assess code and systems to separate deliberate technical debt from accumulated mess, outdated assumptions, or personal taste. Measure where debt costs delivery time or causes incidents, then prioritize incremental fixes and explain their business value to decision makers.

• Prioritizing technical debt by its ongoing cost
• Deciding whether to fix or accept an awkward system
• Explaining remediation value to non-engineers

Turn a specification or requirement into a step-by-step implementation plan with explicit changes, proof of completion, and review checkpoints. Then track execution in order, updating the plan when real conditions differ from expectations.

• Planning a change that spans several files
• Preparing a task for another agent or teammate
• Keeping a growing implementation within scope

Use this skill to assess architecture, technology choices, delivery capacity, infrastructure, and technical debt in business terms. It helps compare build and buy options, surface costs and assumptions, and judge a technical plan before committing.

• Comparing whether to build or buy a capability
• Reviewing an architecture or technology choice
• Assessing delivery capacity and project risk

Use this skill to isolate repository work in a separate branch or worktree, keep it aligned with its base, and prepare it for review. It guides clean integration through merging, rebasing, or splitting work into smaller branches.

• Isolating a feature from current work
• Running parallel efforts in one repository
• Preparing a finished change for review

Shape a system or major component around real constraints such as load, latency, data obligations, and team capacity. Compare architectural options, explain their costs and trade-offs, and record decisions so future teams understand the reasoning.

• Designing the structure of a new system
• Comparing architectural options and their trade-offs
• Reviewing where component boundaries should sit

Use a red, green, refactor workflow: write a test that fails for the intended behavior, make the smallest change that passes, then clean up. Apply it to features, bug fixes, regression tests, and decisions about what behavior needs coverage.

• Starting feature implementation with a failing test
• Reproducing a bug before fixing it
• Changing difficult code with behavior checks

Investigate bugs, failing tests, and unexpected behavior by reproducing the issue, narrowing where it originates, and testing a specific hypothesis. Then verify that the proposed fix addresses the proven cause, rather than only hiding the symptom.

• Investigating a failing test
• Tracing an error after a code change
• Finding the cause of intermittent behavior

Review code changes for correctness, downstream impact, security and data risks, tests, and design. It also helps assess feedback on your own work, decide which suggestions to implement, and explain a reasoned disagreement with evidence before a change is merged.

• Reviewing a diff or pull request before merging
• Checking a change for correctness and security risks
• Deciding how to address review comments

Design and review APIs around the concepts their users need. Shape resources, errors, pagination, and versioning, and assess whether a proposed change could break existing consumers so teams can plan compatibility and deprecation clearly.

• Design a new API interface
• Review an API before release
• Assess whether a change breaks consumers

Clarify the outcome behind a request before implementation, then compare genuinely different approaches by cost, tradeoffs, and assumptions. It helps teams make a reasoned recommendation for a feature or behavior change, especially when the request is ambiguous.

• Clarifying an ambiguous feature request
• Comparing approaches before implementation
• Pressure-testing a design decision

Design a repository’s multi-agent structure by assigning exclusive file areas, defining builder and reviewer roles, and checking ownership rules with a CI script. Use it to divide work, prevent overlapping edits, and decide whether another agent is needed.

• Dividing repository work among agents
• Defining agent roles and file ownership
• Auditing overlapping agent responsibilities

Use this skill to add Redis-based rate limiting to a TypeScript application. It covers SDK setup and basic usage, then points to guidance on algorithms, features, pricing, and traffic protection so you can choose and apply an appropriate limiter.

• Setting up a Redis rate limiter in a TypeScript app
• Choosing a rate-limiting algorithm
• Checking Redis pricing and operating costs

Visually inspect desktop frontend component changes by mounting them in a temporary Vite page. This lets you check the rendered UI in a browser without starting the Tauri app or a live model, then clean up the temporary harness files.

• Checking a desktop component's visual changes
• Previewing frontend work without launching Tauri
• Inspecting a component in a temporary Vite page

Read a text file from a given path so an agent can inspect configuration values, review code, or analyze data. It uses UTF-8 encoding and is intended for text files; binary files need separate handling.

• Checking values in a configuration file
• Reviewing the contents of a code file
• Reading text data for analysis

Retrieve detailed instructions for a specified MCP server, including its capabilities, tool usage guidance, examples, and best practices. Use the returned information to learn how that server works and how to apply its tools in a task.

• Learning what a particular MCP server can do
• Checking how to use a server's tools
• Finding server-specific examples and practices

Reload a skill that is already loaded after you edit its SKILL.md or scripts. The skill is unloaded, its instructions are parsed again, and it is registered with the updated changes. Use this to refresh a skill configuration during development.

• Applying edits to a skill's SKILL.md
• Refreshing a skill after updating scripts
• Re-registering an existing skill

Search file contents across directories with a regular expression and get matching lines with their file paths and line numbers. Filter by filename, ignore case, limit results, or include nearby context. It uses Python and needs no external search tools.

• Finding function or class definitions across a project
• Locating TODO or FIXME markers, including mixed case
• Viewing matching lines with surrounding context

Modify an existing file by replacing an exact text match with new text, optionally changing every match. This focused editing method supports Windows and Unix line endings and is suited to small, targeted updates such as renaming a function or variable.

• Renaming a function in an existing file
• Replacing a variable name throughout a file
• Making a targeted text change while preserving other content

Turn an early idea into an agreed design before implementation. The skill reviews project context, asks focused questions, compares possible approaches, and records the approved design so work can move into planning.

• Clarifying requirements before building a feature
• Comparing design approaches for a project
• Preparing an approved design document

Delete a specified file or an empty directory. The skill rejects non-empty directories, so removing a directory tree requires a separate shell command. Use it for targeted cleanup when you know the exact file or empty folder to remove.

• Removing a temporary output file
• Deleting an empty folder after cleanup
• Deleting a specific file by path

Create interactive, multi-component web artifacts with React, TypeScript, Tailwind CSS, and shadcn/ui. The workflow initializes a project, supports state and routing, and bundles the finished work into one shareable HTML file for Claude conversations.

• Building an interactive multi-screen demo
• Creating a web artifact with state and routing
• Bundling a React project into one HTML file

Turn a specification or requirements for a multi-step development task into a detailed implementation plan. Break work into small actions and identify files, code, tests, documentation, and commands needed for each step.

• Planning implementation from a feature specification
• Breaking a large development task into small steps
• Listing files and tests needed before coding