912 skills · sorted by relevance
Extract an Allium specification from an existing codebase. Use when the user has existing code and wants to distil behaviour into a spec, reverse engineer a specification from implementation, generate a spec from code, turn implementation into a behavioural specification, or document what a codebase does in Allium terms.
The English summary is being prepared. Showing the original description.
Generate tests from Allium specifications. Use when the user wants to propagate tests, generate test files from a spec, write tests for a specification, create property-based tests, produce state machine tests, check test coverage against spec obligations, or understand what tests a specification requires.
The English summary is being prepared. Showing the original description.
Write the executable feature specification — the WHAT and WHY artifact that agents and reviewers treat as source of truth. Owns both /specify and /clarify modes. Load when the user asks to write a feature spec, write a specification, write an executable spec, define functional requirements, capture acceptance criteria as Given/When/Then, or when the spec-driven-development orchestrator routes here. Also triggers on "feature spec", "executable spec", "/specify", "/clarify", "write the spec for this feature", "specification for", "spec-driven", "machine-readable spec". Output: docs/specs/YYYY-MM-DD-<slug>-feature-spec.md. Hard gate: cannot Approve while [NEEDS CLARIFICATION] markers remain.
The English summary is being prepared. Showing the original description.
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.
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.
Turn recurring work or life activities into workflow specifications through focused questions with recommended answers. Clarify triggers, human review, and decision summaries so an implementation agent can build the workflow without further questions.
Turn a specification and its tickets into code by coordinating multiple agents around task dependencies. Combine their work on one integration branch, use test-driven development, review the result, and close tickets through the issue tracker’s workflow.
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.
Turn plans, specifications, or conversations into small development tickets that each deliver verifiable behavior. Identify which tickets must finish first, review the breakdown together, and publish approved tickets to local files or the configured issue tracker.
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.
Turn unclear feature requests or high-impact changes into acceptance criteria: observable conditions for judging completion. Define scope, assumptions, risks, and verification methods, or review an existing specification so another agent or team can implement it with clearer requirements.
Coordinate parallel frontend, backend, or service development around one shared, machine-checkable interface specification. Generate consumer types, validate mocks and real responses against the same specification, and review changes together to prevent mismatched fields and incompatible integrations.
Carry out an implementation plan by assigning each task to a fresh subagent, a separate agent with its own context. Review specification compliance first, then code quality, repeat fixes as needed, and finish with an integration review.
Co-write proposals, specifications, and decision documents through a guided process. Gather background, draft and refine each section, then test the document with a fresh Claude conversation to find unclear explanations and missing context.
Turn a vague request into a precise specification through five phases and file it as a GitHub issue. Optionally start a Claude Code agent in a separate working directory to begin implementation.
Carry out Docupost tasks through Rube MCP, an agent connection to external tools. Discover supported actions, check their required inputs and the service connection, then execute operations according to the specifications returned by tool search.
Turn specifications into pseudocode, a language-independent outline of program logic. Define data structures, handle edge cases, analyze time and memory requirements, and document design patterns and optimization opportunities before implementation.
Organize new features, complex implementations, and architecture changes into the SPARC stages: specification, pseudocode, architecture, refinement, and completion. Define requirements and acceptance criteria, consult existing patterns, and record lessons for future work.
Turn specifications and algorithm outlines into a system architecture. Define components, interfaces, data structures, and deployment plans, then document technology choices, security measures, failure handling, and plans for supporting increased usage.
Turn specifications and designs into working code using test-driven development: write failing tests, implement enough code to pass, then refactor. The workflow also covers error handling, performance improvements, documentation, and coordinated changes across components.
Review implemented features against their requirements, add missing tests, and check performance constraints. Produce documentation, a table linking requirements to code and tests, and evidence showing whether the feature is ready for deployment.
Turn an approved specification into pseudocode, a plain outline of program logic, and an architecture defining module responsibilities and API inputs and outputs. After user confirmation, proceed with implementation and unit tests based on those designs.
Archive several OpenSpec changes together after reviewing their documents and task progress. The skill checks code to resolve overlapping specification updates, syncs the selected updates, and reports which changes were archived, skipped, or failed.
Compare an implementation with its OpenSpec specifications, tasks, and design decisions before archiving the change. Get a report on completion, requirement coverage, and consistency, with prioritized issues, actionable recommendations, and explicit limits where evidence is missing.