openspec-explore

Explore ideas and clarify requirements in OpenSpec mode without writing code.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps users clarify requirements, explore options, and investigate the codebase before making any changes, so uncertainty doesn’t turn into risky implementation.

Core Features & Use Cases

  • Exploration-first guidance: Acts as a thinking partner to reframe problems, surface assumptions, and expand the solution space.
  • Grounded codebase investigation: Reads existing OpenSpec artifacts and repository files to map architecture and integration points.
  • Decision capture without forcing execution: Offers to document insights as proposals/designs/specs when they crystallize, while explicitly avoiding code changes.
  • Use Case: You’re unsure how to implement a new auth flow; explore failure modes, evaluate integration points, and decide what to propose next—without writing code.

Quick Start

Use the openspec-explore skill when you want to reason about a change request without implementing it yet.

Frequently Asked Questions about openspec-explore

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

FAQPage Schema
How do I explore and clarify codebase requirements before writing any implementation code?

To explore requirements without writing code, you need a guided discovery process that reads existing files and maps architecture to surface assumptions. This approach lets you investigate problems and evaluate design options while enforcing guardrails that prohibit code changes.

What is the best way to map integration points for a new feature without modifying the codebase?

Mapping integration points safely requires reading existing repository files and artifacts to understand architecture. You can reframe problems and expand the solution space as a thinking partner, ensuring you capture decisions as proposals or specs without forcing execution.

How do I capture design options and decisions during pre-implementation discovery?

Capturing design options during pre-implementation discovery involves documenting insights as OpenSpec artifacts when they crystallize. You evaluate failure modes and integration points, then produce proposals or designs that clarify what to implement next.

Can I investigate failure modes for an auth flow without actually implementing the changes?

Investigating failure modes without implementation is exactly what this exploration process supports. It guides you to evaluate integration points and decide what to propose next, explicitly avoiding code changes while allowing you to read files and produce design artifacts.

Does requirement exploration work with existing OpenSpec artifacts in the repository?

Requirement exploration works directly with existing OpenSpec artifacts by reading them to ground the investigation. It maps architecture and integration points from your current repository files, ensuring your decision capture is based on actual codebase analysis.

When should I not use an exploration-first approach for codebase analysis?

You should not use an exploration-first approach when you are ready to execute implementation changes immediately. This mode strictly prohibits code writing and is designed only for pre-implementation discovery, requirement clarification, and option comparison.