Coding standards, frameworks, refactoring, and code review (16.4K skills)
Carry a coding task through requirements interviews, a written specification, task tickets, and implementation. The workflow records user approvals, runs real tests, and retains review evidence, with execution state preserved so interrupted work can resume.
Turn a plan, specification, or conversation into small development tickets that each deliver a verifiable feature. Identify prerequisite tickets, review the breakdown with the user, and publish approved tickets as local files or tracker issues.
Review code changes from a chosen Git reference against both project coding standards and the original requirements. Separate agents examine each perspective in parallel, and the results stay separate so specification gaps and coding issues are visible.
Turn an existing conversation and knowledge of the codebase into a specification, then publish it to the project's issue tracker. It organizes the problem, user stories, implementation and testing decisions, and scope without a new requirements interview.
Turn an initial idea into an agreed design before coding. The skill clarifies goals and constraints through focused questions, compares possible approaches, and produces a reviewed specification ready for implementation planning.
Evaluate code review feedback against the actual codebase before making changes. Clarify ambiguous requests, check compatibility and existing behavior, explain disagreements with evidence, and implement valid fixes one at a time with individual tests.
Finish completed development work by checking tests and the Git workspace, then choosing a local merge, pull request, preservation, or discard. The skill follows the selected workflow and handles branch and workspace cleanup where appropriate.
Carry out a written implementation plan in a separate session. Review it for gaps, track each task, follow its verification steps, and hand completed work to the development branch finishing workflow, pausing when blockers require clarification.
Archive several OpenSpec changes together after checking their documents and task completion. Compare overlapping specification updates against the code, determine which updates to apply, and report successful, skipped, or failed archives.
Request a code review from a separate agent using a focused summary of the implementation, requirements, and commit range. Use the feedback to address critical and important issues before continuing development or merging changes.
Start or resume a development workflow by checking the request and current change state. Routes work through proposal, design, implementation, verification, and archiving, with separate paths for bug fixes and smaller changes and pauses for required user decisions.
Investigates bugs, failing tests, and unexpected behavior before proposing fixes. Guides the agent through reproducing the issue, gathering evidence, comparing working examples, testing one hypothesis at a time, and verifying a focused repair.
Merge proposed specification changes into the main specifications while keeping the change active. Add, revise, remove, or rename requirements, preserve unaffected content, and receive a summary of the updates.
Explore ideas, investigate code, and clarify requirements before or during development. Use diagrams and comparisons to understand options, tradeoffs, and unanswered questions, with findings saved to OpenSpec documents when requested.
Turn a feature or fix request into an OpenSpec change proposal with design, specifications, and implementation tasks. Generate documents in dependency order and check that the materials required to begin implementation are complete.
Convert specifications or requirements into a detailed implementation plan. Break work into small, testable tasks with exact file paths, code, test commands, expected results, and commit steps so developers can work with minimal prior context.
Turn a feature or fix request into the OpenSpec documents required to begin implementation. Create files in dependency order using the workflow’s templates, track progress, and summarize what is ready for the implementation stage.
Execute an implementation plan by assigning each independent task to a fresh subagent, a separate AI worker. Review each task for requirements and code quality, then review the complete set of changes before finishing.
Split independent tasks or unrelated failures among agents working in parallel. Gives each agent a focused, self-contained assignment, then reviews their findings, checks for conflicting edits, and validates the combined changes with the full test suite.
Create and improve agent skills by testing behavior before and after adding instructions. The guide covers SKILL.md structure, discoverable descriptions, supporting files, and ways to check whether agents follow guidance in realistic situations.
Set up a new OpenSpec change for a feature, fix, or modification. The skill creates the change folder, shows the workflow and document status, and presents the first document template so work can begin in a defined order.
Finalize an implemented OpenSpec change by checking deliverables, unfinished tasks, and specification updates. Review any warnings, choose whether to sync specification changes, and move the change into a dated archive with a completion summary.
Learn OpenSpec by completing a small change in a real codebase. Get explanations while choosing a task, writing a proposal, specifications, design, and task list, implementing the change, and archiving its decision record.
Continue an OpenSpec change by checking its progress and creating the next required document. Follow the workflow’s document order and dependencies, then show completion progress and which documents can be created next.