Specs in Product

Guide structured workflows for writing docs, proposals, and technical specs collaboratively.

Build protocol servers that connect language models to external APIs and services.

Guide collaborative document creation through context gathering, refinement, and reader testing.

Generate professional architecture and workflow diagrams as HTML files with dark/light themes and image export.

Run plans through adversarial debate to find weak spots and defensible insights.

Test fixture demonstrating SKILL.md compatibility for legacy plugin installations.

Assess whether furniture fits in a room based on measured dimensions and clearances.

Format Linear or Superset tickets with a standardized three-section structure.

Look up CLI commands and documentation for managing skills.

Turn rough ideas into approved plans with validated structure before coding.

Open annotation UI for files, folders, or URLs to review and address feedback.

Annotate and revise your last message based on user feedback.

Generate an AI design contract and evaluation strategy for system development phases.

Ask clarifying questions before starting work on ambiguous requests.

Create reusable templates for design, slides, and video projects.

Build structured specifications from multi-AI research and consensus.

Scope project requirements using multiple AI providers in parallel.

Create a detailed work plan from your request before coding begins.

Generate CFO briefings and financial analysis from accounting data with anomaly detection.

Generate a complete product feature specification with acceptance criteria and dependencies.

Generate interactive HTML diagrams to visualize relationships, sequences, and structures.

Convert source material into a structured HTML plan for inspection and action.

Generate low-fidelity HTML wireframes to test layout, navigation, and task flow before design.

Manage development workflows using OpenSpec specifications and Superpowers execution framework.

Create, edit, and publish custom skills for agents on SkillHub.

Retrieve structured product details from Amazon using an ASIN number.

Guide for building custom skills that extend Codex with specialized knowledge and workflows.

Rewrite rough prompts into high-quality ones using domain-specific standards.

Turn ideas into designs through guided questions and collaborative dialogue.

Ask clarifying questions before implementing to avoid misaligned work.

Merge verified spec changes and archive them following OpenSpec delta semantics.

Generate design documents and specifications through structured brainstorming.

Explore ideas and clarify requirements to create a structured change proposal.

Refine your idea into a complete design through collaborative questions and feedback.

Create and refine project specifications through guided analysis and documentation-driven development workflows.

Read, write, and manage your Obsidian vault as an evolving knowledge base that auto-reconciles contradictions.

Capture, clarify, and review product requirements before development starts.

Review architecture specs and design docs using multiple independent AI reviewers to surface consensus issues.

Generate multiple competing explanations for an observed problem or signal.

Generate 3–5 distinct solution approaches with explicit weaknesses for each.

Manage project governance charters, interviews, and doctrine artifacts in Spec Kitty.

Create flowcharts, architecture diagrams, and visual sketches with Excalidraw.

Ask clarifying questions before implementing to prevent building the wrong thing.

Archive completed tasks and record your coding session progress.

Understand and customize your local Trellis project architecture and configuration.

Start or continue implementing tasks from an OpenSpec change.

Think through ideas and investigate problems before making changes.

Finalize and archive a completed change in your experimental workflow.

Guide collaborative planning before implementation with questions and scope discovery.

Resume an in-progress task by loading the current phase and step details.

Convert a Claude skills repository into an installable marketplace with auto-updates.

Work through problems systematically with structured planning, evidence gathering, and outcome-first reporting.

Transform feature briefs into structured design briefs with context and constraints.

Identify ambiguities in task specs and rewrite them with clear acceptance criteria.

Convert product requirements into structured epics with user stories and spec documents.

Search the web and compile structured findings before starting to code.

Audit your app store metadata for keyword gaps and optimization opportunities.

Connect to MCP servers and call tools, resources, and prompts from the shell.

Clarify project goals, scope, and success criteria before you start building.

Convert planning documents into an executable contract for implementation.

Create and review technical documents using PRD, ADR, and design templates.

Explore and pressure-test new features, designs, and architecture before implementation.

Create a shared glossary of domain terms and definitions for your project.

Convert conversations into Flow Next spec files with review before saving.

Review specification completion and requirements alignment for Flow Next projects.

Interview users deeply about specs and tasks to extract complete implementation details.

Ask users questions and present choices via interactive forms during conversations.

Convert a conversation into a reusable system prompt.

Create flowcharts, sequence diagrams, and other visual charts.

Generate self-contained HTML artifacts for Solo tasks and threads.

Create, edit, test, and optimize skills with performance benchmarking and accuracy improvements.

Break down project scope into epics, stories, and prioritized tasks.

Run multiple solution attempts in parallel and merge the best parts into one optimized result.

Explore ideas and clarify what to build before you start coding.

Plan and validate your design before building anything.

Classify incoming work requests and route them to the appropriate workflow skill.

Research complex topics thoroughly with verified sources and structured findings.

Initialize a new project or onboard an existing codebase into a spec graph.

Split epics into detailed feature documents with scope and acceptance criteria.

Convert goals and artifacts into execution packets for downstream processing.

Coordinate and recover multi-stage research projects with checkpoints and state management.

Interview your game idea and create a design document before coding.

Manage game assets by tracking gaps, coordinating production, and updating asset manifests.

Surface expert frameworks for creating and evaluating skills, hooks, and agents.

Create a clear implementation plan before coding complex features or changes.

Create and manage Jira tickets from requirements and requests.

Generate a comprehensive UX architecture bible by auditing your app's code and design patterns.

Plan UI features with design specs, accessibility, and navigation before coding.

Generate multiple design variations for users to review and react to before building.

Log deviations and edge cases discovered during development for future reference.

Convert an approved GRACE change spec into an executable plan with tasks and verification gates.

Execute approved GRACE change plans with recovery safeguards and centralized tracking.

Understand GRACE 4 methodology, artifacts, semantic anchors, and change management.

Break down objectives into focused, scoped work units with clear success criteria.

Convert user requests into structured goals and objectives.

Explore ideas and tradeoffs through interactive conversation before implementation.

Get grilled on your plan or design through tough questioning.

Audit a skill through multiple personas to find real behavioral gaps and inconsistencies.

Transform feature ideas into annotated stories with automated greenfield or brownfield detection.

Create surveys, forms, and sign-up sheets that multiple people can access and fill out online.

Define product scope and generate PRDs, epics, and user stories.

Attack any document or plan to find flaws, gaps, and weak points you'd miss otherwise.

Turn rough ideas into approved specs with testable acceptance criteria before coding.

Transform source material into a structured mental model with evidence tracking and clear next actions.

Guide a greenfield project through structured architecture planning before coding.

Stress-test your plan with relentless questions until you reach shared understanding.

Ask probing questions to stress-test your plan before building.

Turn feature specs into approved task plans with optional ADRs and branches.

Turn product specs into design prompts for web UI generators like Figma and v0.

Turn vague feature ideas into structured product requirements through guided questions.

Interview you to create project specs, charters, and acceptance criteria.

Break design documents into atomic parallel tasks with dependencies and acceptance criteria.

Create reusable skills by analyzing your conversation history and learning from what worked.

Structure writing for executives using pyramid, MECE, and bold-bullet frameworks.

Convert raw work notes into structured YAML timeline entries with business context.

Generate a custom checklist to validate requirement quality and completeness.

Analyze consistency and quality across spec, plan, and task documents.

Analyze evaluation results to identify signal patterns and guide prompt improvements.

Guide two agents through parallel research and joint design before implementation.

Plan and document design decisions before writing code.

Guide structured writing of documentation, proposals, and technical specs with iteration and testing.