openspec-explore

Explore codebase requirements and options without writing code.

Updated Feb 12, 2021

Search Tags:#requirements #exploration #guardrails #tradeoff analysis #non-implementation #architecture mapping #debugging support

Ready to run

npx skills add https://github.com/echowaves/WiSaw.cdk --skill openspec-explore-echowaves

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/echowaves/WiSaw.cdk/tree/main/.roo/skills/openspec-explore
Command: npx skills add https://github.com/echowaves/WiSaw.cdk --skill openspec-explore-echowaves

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you clarify goals, question assumptions, and investigate the codebase or requirements without jumping straight into implementation.

Core Features & Use Cases

Explore mode guidance: Encourages deep thinking, reframing, and surfacing multiple directions.
Codebase-grounded investigation: Supports mapping architecture, finding integration points, and identifying existing patterns.
Option comparison & visualization: Promotes tradeoff tables, risk/unknown surfacing, and ASCII diagrams to make complexity legible.
Guardrails for safe behavior: Explicitly instructs that you must not write code or implement features, and to exit explore mode first if the user requests implementation.

Quick Start

Use openspec-explore when you want to investigate an idea or requirement and think it through before making any changes.

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 explore codebase architecture before starting implementation?▼

Requirement clarification and architecture exploration involve questioning assumptions and mapping integration points to surface multiple directions. This iterative discovery process prevents premature implementation by enforcing safety constraints that disallow code writing.

What is the best way to analyze tradeoffs for ambiguous change requests across a codebase?▼

The best way to analyze tradeoffs for ambiguous change requests is by generating tradeoff tables and ASCII diagrams to visualize complexity. This investigation surfaces risks and unknowns to ensure safe, well-informed architectural decisions.

How do I investigate debugging options without accidentally modifying the codebase?▼

Investigating debugging options without modifying the codebase requires strict guardrails that disallow code writing and feature implementation. You can map existing patterns and find integration points safely by maintaining an explicit non-implementation stance.

Can I visualize architecture mapping and integration points without writing any feature code?▼

Yes, you can visualize architecture mapping and integration points without writing feature code by using an explicit non-implementation stance. This approach promotes ASCII diagrams and option comparison to make complexity legible while enforcing safety constraints.

When should I not use an exploration mode for requirement analysis?▼

You should not use exploration mode for requirement analysis when you are ready to write code or implement features. If implementation is requested, you must exit explore mode first, as strict guardrails disallow code writing and unauthorized changes.