Results for “specification”

Verify code correctness statically against specifications using type checking, contract verification, and formal methods. Use when: (1) Verifying type safety and null safety in Python, Java, or C/C++ code, (2) Checking design-by-contract specifications (preconditions, postconditions, invariants), (3) Validating code against formal specifications, (4) Ensuring code quality and correctness before runtime, (5) Finding potential bugs through static analysis. Supports Python (mypy, contracts), Java (javac, JML), and provides verification scripts and contract specification guidelines.

The English summary is being prepared. Showing the original description.

Generate implementation code and tests from written specifications. Use when the user provides specifications (natural language descriptions, formal specs, requirements documents, API specs) and asks Claude to implement the described functionality. Supports data structures, algorithms, classes, functions, and includes automatic test generation to validate implementation against specification.

The English summary is being prepared. Showing the original description.

Turn an unclear feature idea into a structured specification with goals, boundaries, and testable success criteria. Split broader requests into independent modules when needed, then move through planning, task breakdown, and implementation with human review.

• Clarify an idea before coding
• Draft requirements with testable completion criteria
• Split a broad request into independent modules

Create a product launch email in HTML with a brand wordmark, product visual, headline, specifications, and one main call-to-action button. The centered, single-column layout brings the product message together in a complete email design.

• Designing a product launch email
• Creating a branded newsletter template
• Presenting product specifications in an email

Finalize an implemented OpenSpec change by checking planning files, task completion, and specification differences. Review whether to merge specification updates, verify any requested merge, then archive the change and report its location and outstanding warnings.

• Archiving an implemented change
• Reviewing specification updates before archiving
• Checking unfinished work before closing a change

Turn a system description into REST API endpoints, the URLs and operations applications use to exchange data. Choose an endpoint list or detailed specifications covering authentication, request fields, responses, error codes, and pagination for lists.

• Listing the API endpoints a new system needs
• Drafting request and response specifications
• Designing authentication and error responses

Create API specifications, interactive documentation, and developer portals that explain how to use an API. The skill also covers authentication examples, SDK generation, example testing, and migration guides to help developers integrate and maintain their applications.

• Create API specifications with authentication examples
• Build interactive API documentation
• Generate SDKs from OpenAPI specifications

Guide a scoped coding task through specification, implementation, and review. Set acceptance criteria, verification checks, iteration limits, and approval gates, then correct identified gaps until the requirements pass or a stopping condition is reached.

• Build a small feature from specification through verification
• Modify a module against explicit acceptance criteria
• Repeat fixes and checks within an iteration limit

Turn an OpenAPI specification, a document describing an API, into an application using the chosen framework. Generate request handlers, data models, authentication, validation, tests, and setup instructions, with database access code where applicable.

• Build an API application from an existing specification
• Generate data models and request handlers together
• Prepare tests and setup documentation for a new project

Build an llms.txt file, a navigation guide for AI models, from a repository's structure. Summarize the project and organize links to essential documentation, specifications, examples, and configuration resources.

• Creating an AI-readable guide to a repository
• Organizing links to documentation and specifications
• Prioritizing essential project information

Compare specification requirements with the codebase and create GitHub issues for unmet requirements. Check existing issues for duplicates, then include requirement IDs, implementation guidance, context, and acceptance criteria in each new issue.

• Finding requirements missing from an implementation
• Turning unmet requirements into GitHub issues
• Checking for duplicate issues before creating tasks

Plan features before coding by defining requirements, acceptance criteria, and scope. Validate the specification, generate starter tests from expected behaviors, and guide implementation and review so each delivered feature can be checked against its agreed requirements.

• Define requirements before implementing a feature
• Turn acceptance criteria into starter tests
• Check specifications for missing requirements

Archive several OpenSpec changes together after reviewing their documents, task completion, and specification conflicts. The agent checks actual code to decide which specification updates to apply, asks for confirmation, and reports successes, skipped changes, and failures.

• Archiving several completed changes together
• Reviewing incomplete documents and tasks before archiving
• Resolving overlapping specifications using implementation evidence

Convert a Notion specification into a linked implementation plan and manageable tasks. Extract requirements and acceptance criteria, record uncertainties, and keep task statuses, checklists, blockers, and milestone updates aligned as the work progresses.

• Turn a Notion feature specification into a plan
• Break implementation work into one- or two-day tasks
• Link specifications, plans, and task pages

Turn game design documents and character profiles into asset specifications and image generation prompts. Define appearance, dimensions, file formats, and naming rules, then maintain an asset list that tracks progress and identifies shared assets.

• List the visual assets needed for a game
• Define consistent character and environment asset specifications
• Prepare image generation prompts from an art direction guide

Helps build custom code exporters from json-render UI specifications. Covers walking the UI tree, collecting components, state references, and actions, and formatting property values for JSX, the markup syntax used in React.

• Build a custom exporter for Next.js or Remix
• List components and actions used in a UI specification
• Convert property values into JSX attributes

Create HTML or plain-text emails from JSON specifications with React Email. This skill guides reusable email components, conditional content, server-side rendering, and browser previews for transactional messages such as signup notifications and marketing emails.

• Create signup notifications and other transactional emails
• Build marketing emails from JSON specifications
• Vary email content using state and conditions

Review patent claims and specifications with an AI acting as a patent examiner. It identifies clarity, novelty, and disclosure issues, applies revisions, and conducts a second review, producing a report of changes and remaining concerns.

• Check claims and specifications before filing
• Find unclear terms and missing technical explanations
• Review novelty against known prior art

Draft detailed patent embodiments, descriptions of how to make and use an invention. It organizes components, operating steps, conditions, and alternatives, aligns figure reference numbers, and checks that each claim element has supporting text.

• Draft detailed embodiments for a patent specification
• Turn a paper's technical setup into an operating description
• Align component reference numbers with patent figures

Convert a Notion specification into a linked implementation plan and manageable tasks. Extract requirements and acceptance criteria, record uncertainties, and keep task statuses, checklists, blockers, and milestone updates aligned as the work progresses.

• Turn a Notion feature specification into a plan
• Break implementation work into one- or two-day tasks
• Link specifications, plans, and task pages

Turn a feature idea into a specification through structured questions about users, business goals, and technical constraints. Produce requirements, user stories, testable acceptance criteria, and an implementation checklist, including performance, security, and error handling.

• Defining requirements for a new feature
• Clarifying vague feature requests
• Writing testable acceptance criteria

Design REST or GraphQL APIs by defining data relationships, requests, responses, and authentication. Produce OpenAPI specifications, machine-readable API descriptions, with consistent errors, pagination, and versioning plans, then validate contracts using a mock server.

• Designing a new API from business requirements
• Creating and validating OpenAPI specifications
• Standardizing errors and paginated responses

Create UI-SPEC.md, a document defining interface design decisions for a frontend phase. The skill coordinates UI research and specification checks, using a chosen phase or automatically selecting the next unplanned one.

• Preparing UI specifications for a frontend phase
• Researching UI before documenting design decisions
• Checking a UI specification after drafting it

Model distributed systems and concurrent algorithms in TLA+ or PlusCal, then check possible states with TLC. Use the results to investigate deadlocks, broken rules, and differences between specifications and implementation code.

• Model a distributed protocol before implementation
• Create a specification from existing concurrent code
• Investigate deadlocks and race conditions