openspec-explore

Explore ambiguous software problems and map architecture tradeoffs from repository files.

Updated Apr 13, 2026
One-click install
npx skills add https://github.com/soyrochus/vulgata --skill openspec-explore-soyrochus
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/soyrochus/vulgata/tree/main/.claude/skills/openspec-explore
Command: npx skills add https://github.com/soyrochus/vulgata --skill openspec-explore-soyrochus

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provides a collaborative, exploratory thinking mode to help teams and individuals investigate problems, surface tradeoffs, and clarify requirements before committing to design or implementation decisions. It reduces premature implementation, helps map unknowns, and grounds conversations in the actual codebase and project artifacts.

Core Features & Use Cases

  • Open-ended exploration: Ask questions, reframe the problem, and brainstorm multiple directions without producing implementation code.
  • Codebase investigation: Read repository files, map architecture, find integration points, and surface hidden complexity relevant to a proposed change.
  • Decision support & visualization: Produce ASCII diagrams, compare options, surface risks, and summarize open questions and next steps.
  • OpenSpec-aware capture: When requested, capture proposals, designs, and task lists as OpenSpec artifacts while avoiding direct code changes.
  • Use cases: early-stage feature design, troubleshooting messy subsystems (e.g., auth), evaluating storage or architecture tradeoffs, and preparing scoped change proposals.

Quick Start

Enter explore mode and help me think through adding real-time collaboration by mapping options, risks, and repository integration points while avoiding any implementation.

Frequently Asked Questions about openspec-explore

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

FAQPage Schema
How do I explore software architecture and map integration points before writing code?

To explore software architecture, you can use an exploratory design mode that reads repository files, maps integration points, and surfaces hidden complexity without producing implementation code. It helps ground conversations in the actual codebase before committing to design decisions.

What is the best way to compare design tradeoffs for ambiguous software problems?

Comparing design tradeoffs is best handled by generating ASCII diagrams and decision summaries that surface risks and open questions. This approach reframes ambiguous problems and evaluates multiple directions while avoiding premature implementation.

How do I investigate a messy codebase subsystem like authentication without implementing changes?

Investigating a messy codebase subsystem involves mapping architecture, finding integration points, and surfacing hidden complexity relevant to a proposed change. You can troubleshoot subsystems like auth by reading repository files for context while avoiding direct code changes.

Can I capture exploratory design proposals as OpenSpec artifacts without writing implementation code?

Yes, you can capture exploratory design proposals as OpenSpec artifacts on request while avoiding implementation code. This feature allows you to record designs, proposals, and task lists directly from the investigation mode.

Does this exploratory design mode work for early-stage feature discovery and requirements clarification?

Yes, this exploratory design mode works for early-stage feature discovery by asking questions, reframing problems, and clarifying requirements. It reduces premature implementation and helps map unknowns before committing to design or implementation decisions.

When should I not use exploratory design for codebase investigation?

You should not use exploratory design when you need to produce implementation code, as this mode explicitly avoids generating code changes. It is intended for discovery, architecture mapping, and decision support rather than direct development tasks.