openspec-explore

Name: openspec-explore
Availability: InStock
Author: joannanowakowska

Clarify requirements and investigate codebase questions before implementation.

10|Updated Jul 7, 2026

Search Tags:#architecture #investigation #requirements #exploration #openspec #tradeoffs

Ready to run

npx skills add https://github.com/joannanowakowska/plannning-poker-app --skill openspec-explore-joannanowakowska

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/joannanowakowska/plannning-poker-app/tree/main/.github/skills/openspec-explore
Command: npx skills add https://github.com/joannanowakowska/plannning-poker-app --skill openspec-explore-joannanowakowska

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you think through ideas, investigate problems, and clarify requirements before making changes. It is designed for situations where the right next step is exploration, not implementation.

Core Features & Use Cases

Deep Exploration: Investigate code, architecture, and open questions to understand what is really happening.
Requirement Clarification: Uncover hidden assumptions, risks, and tradeoffs when a request is still evolving.
Option Comparison: Compare approaches, sketch diagrams, and weigh constraints before choosing a path.
Use Case: A user wants to add real-time collaboration, troubleshoot a messy auth flow, or decide between two technical options and needs a thoughtful partner to explore the space first.

Quick Start

Ask the openspec-explore skill to help you investigate the problem, read the relevant files, and compare possible approaches before proposing 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 clarify requirements and investigate architectural tradeoffs before writing code?▼

To clarify requirements and investigate architectural tradeoffs before writing code, you can use exploration techniques to read repository context, surface hidden risks, and reason through open-ended software changes without producing implementation files.

What is the best way to compare technical options for adding real-time collaboration features?▼

Comparing technical options for real-time collaboration involves reading relevant codebase files, sketching architectural diagrams, and weighing constraints to surface hidden assumptions and risks before committing to a specific implementation path.

How do I diagnose problems in a messy authentication flow without changing application code?▼

Diagnosing messy authentication flows without writing application code requires reading the repository context to investigate what is really happening, surfacing risks, and reasoning through the problem during early-stage planning.

When do I need architectural exploration instead of immediate implementation?▼

You need architectural exploration instead of immediate implementation when a request is still evolving, hidden assumptions exist, or you must choose between multiple technical paths and want to understand tradeoffs before making changes.

Can I use codebase investigation to uncover hidden risks in early-stage planning?▼

Yes, codebase investigation uncovers hidden risks in early-stage planning by reading repository context, diagnosing problems, and reasoning through open-ended software changes to clarify requirements before any application code is written.

What are the limitations of using exploration for early-stage architectural planning?▼

The limitation of early-stage architectural exploration is that it focuses strictly on reasoning, reading context, and surfacing risks, meaning it does not write application code or directly implement the software changes it analyzes.