openspec-explore

Explore software ideas and clarify requirements using OpenSpec artifacts.

3|1|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/accidental-hedge-fund/agent-pipeline --skill openspec-explore-accidental-hedge-fund
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/accidental-hedge-fund/agent-pipeline/tree/main/.claude/skills/openspec-explore
Command: npx skills add https://github.com/accidental-hedge-fund/agent-pipeline --skill openspec-explore-accidental-hedge-fund

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Jumping into software implementation without fully exploring ideas, clarifying requirements, or investigating existing code often leads to rework, missed requirements, and poor design choices. This skill eliminates that risk by providing a dedicated thinking partner for pre-development discovery and problem exploration.

Core Features & Use Cases

  • Thinking Partner Stance: Acts as a curious, non-prescriptive collaborator to explore vague ideas, challenge assumptions, and reframe problems without pressure to reach a fixed conclusion.
  • Grounded Codebase Investigation: Reads and maps existing code, architecture, and patterns to ground discussions in reality, surfacing hidden complexity and integration points.
  • Visual Option Comparison: Uses ASCII diagrams to sketch state machines, data flows, and tradeoff tables to compare implementation approaches and surface risks.
  • Use Case: If you have a vague idea to add real-time collaboration to your app, use this skill to explore the collaboration spectrum, map your current auth architecture, and compare CRDT vs. cursor-based sync tradeoffs before writing any code.

Quick Start

Use the openspec-explore skill to explore your idea for adding real-time collaboration to the app and compare the tradeoffs of different implementation approaches.

Frequently Asked Questions about openspec-explore

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I clarify software requirements before jumping into implementation?

Clarifying software requirements before implementation involves acting as a thinking partner to explore vague ideas, challenge assumptions, and reframe problems. This skill grounds pre-development discovery by mapping existing code and surfacing hidden complexity.

What is the best way to investigate a codebase for technical tradeoff analysis?

Technical tradeoff analysis during a codebase investigation involves reading existing architecture and mapping integration points to ground discussions in reality. You can sketch data flows and compare implementation approaches visually using ASCII diagrams.

How do I explore technical options and compare approaches before writing code?

Exploring technical options before writing code requires comparing implementation approaches using visual tradeoff tables and state machine sketches. This skill surfaces risks and clarifies decisions by acting as a non-prescriptive collaborator.

Can I use this for mid-implementation problem solving or only for pre-development discovery?

Mid-implementation problem solving is fully supported alongside pre-development discovery and requirement refinement. The skill functions as a thinking partner throughout the software change lifecycle without enforcing fixed workflows or mandatory outputs.

Does codebase investigation require integrating with OpenSpec artifacts?

Codebase investigation integrates with OpenSpec artifacts to capture insights when decisions crystallize during exploration. This integration grounds the technical option comparison but does not enforce mandatory outputs or fixed workflows.

Why should I explore ideas before implementing software changes?

Exploring ideas before implementing software changes eliminates the risk of rework, missed requirements, and poor design choices. Jumping into implementation without investigating problems or clarifying requirements often leads to hidden complexity surfacing late.