openspec-explore

Guide exploratory thinking through requirements, codebases, and design discussions.

17|7|Updated Mar 30, 2026
One-click install
npx skills add https://github.com/gqcn/openspec-practice --skill openspec-explore-gqcn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/gqcn/openspec-practice/tree/main/.agents/skills/openspec-explore
Command: npx skills add https://github.com/gqcn/openspec-practice --skill openspec-explore-gqcn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

openspec-explore offers a collaborative thinking partner to help users think through ideas, investigate problems, and clarify requirements before any implementation, ensuring careful, iterative exploration.

Core Features & Use Cases

  • Collaborative exploration of requirements, codebases, and design discussions.
  • Visualization and surface-risk tooling to surface unknowns and dependencies.
  • Guided questioning and multi-direction thinking to surface tradeoffs and options.
  • Ability to surface artifacts or proposals without writing code.

Quick Start

Describe your exploration objective and ask the partner to surface questions and diagrams to clarify requirements.

Frequently Asked Questions about openspec-explore

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

FAQPage Schema
How do I explore requirements and clarify user needs before writing any code?

Requirements exploration clarifies user needs by using a thinking partner to guide ideation, surface questions, and visualize dependencies before implementation. You describe your objective, and the partner iteratively surfaces tradeoffs and diagrams.

What is the best way to evaluate a codebase during design discussions?

Evaluating a codebase during design discussions involves collaborative exploration where a thinking partner surfaces risks, unknowns, and architectural tradeoffs. This approach applies multi-direction thinking to clarify design options without writing implementation code.

Can I use a thinking partner to investigate architecture problems without generating code?

Yes, a thinking partner facilitates deep exploratory thinking to investigate architecture problems while explicitly avoiding code implementation. It provides stance-based guidance and visualization to surface proposals and risk artifacts across discussions.

How do I surface unknowns and dependencies when analyzing a new feature design?

To surface unknowns and dependencies in feature design, apply guided questioning and visualization tooling during exploratory discussions. This multi-direction thinking approach clarifies tradeoffs and reveals hidden architectural risks before development.

Does collaborative exploration work for clarifying requirements across multiple discussions?

Collaborative exploration works across discussions, designs, and architectures by acting as a patient thinking partner to clarify requirements iteratively. It meets activation rules to provide stance-based guidance for ongoing problem analysis.

When should I not use a thinking partner for codebase exploration?

You should not use a thinking partner for codebase exploration when you need actual code implementation or concrete programming solutions. This approach explicitly avoids writing code, focusing solely on ideation, risk surfacing, and requirement clarification.