openspec-explore

Identify uncertainties in codebases and requirements through exploration techniques.

1|Updated Mar 26, 2026
One-click install
npx skills add https://github.com/duonghuan2122000/sora-piggy --skill openspec-explore-duonghuan2122000
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/duonghuan2122000/sora-piggy/tree/main/.github/skills/openspec-explore
Command: npx skills add https://github.com/duonghuan2122000/sora-piggy --skill openspec-explore-duonghuan2122000

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enter explore mode as a thinking partner to surface questions, map options, and visualize ideas before making changes.

Core Features & Use Cases

  • Guided thinking: read files, search code, and investigate the codebase without implementing.
  • Visual reasoning: ASCII diagrams and open threads to surface risks, unknowns, and alternatives.
  • Collaboration for planning: helps structure change proposals or design artifacts when users want to explore.

Quick Start

Engage in deep thinking with the user, read files, and visualize ideas without writing code.

Frequently Asked Questions about openspec-explore

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

FAQPage Schema
How do I explore a codebase to identify design constraints before writing code?

To explore a codebase before implementation, you can use a guided thinking partner that reads files, searches code, and articulates uncertainties to align understanding. This approach surfaces constraints and trade-offs without writing any code.

What is the best way to visualize requirements and map alternatives during the planning phase?

Visualizing requirements during planning involves generating ASCII diagrams and open threads to surface risks and unknowns. This technique helps map alternatives and structure change proposals before committing to an implementation.

Can I analyze requirements and produce design artifacts without modifying the source code?

Yes, you can analyze requirements and produce design artifacts without modifying source code. This non-implementation workflow focuses on generating reasoning, questions, and proposal artifacts to support planning and alignment.

How do I surface unknowns and trade-offs when reviewing complex project requirements?

Surfacing unknowns and trade-offs in complex requirements requires applying exploration techniques across scenarios. This process produces reasoning and questions that clarify constraints and align team understanding before development begins.

Does this exploration approach support building change proposals for an existing codebase?

Yes, this exploration approach supports building change proposals for an existing codebase. It acts as a collaboration tool to structure design artifacts and visualize ideas while investigating the codebase without implementing changes.

When should I use a thinking partner instead of directly writing code for a new feature?

Use a thinking partner instead of directly writing code when scenarios require clarity and trade-off analysis before implementation. It helps you articulate uncertainties, map options, and align understanding prior to making any changes.