openspec-explore

Investigate codebases to clarify requirements and map architecture before implementation.

Updated Jul 6, 2025
One-click install
npx skills add https://github.com/wishx127/mirror-server --skill openspec-explore-wishx127
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/wishx127/mirror-server/tree/main/.codebuddy/skills/openspec-explore
Command: npx skills add https://github.com/wishx127/mirror-server --skill openspec-explore-wishx127

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you think through software questions before making changes, especially when requirements are fuzzy, the architecture is unfamiliar, or multiple implementation paths are possible.

Core Features & Use Cases

  • Explore requirements: Clarify goals, constraints, and hidden assumptions.
  • Investigate codebases: Read files, trace flows, and map the relevant parts of a repository.
  • Compare options: Weigh tradeoffs, surface risks, and sketch alternative approaches.
  • Use case: A developer can ask whether an auth refactor should use a new module, and the Skill will help analyze the current system and outline the implications.

Quick Start

Ask the assistant to enter explore mode and inspect the relevant repository area before you decide on a change.

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 map architecture before implementing changes in an unfamiliar codebase?

To clarify requirements and map architecture in an unfamiliar codebase, use an exploratory analysis approach that reads files, traces dependencies, and summarizes findings without writing application code. This clarifies goals, constraints, and hidden assumptions before implementation.

What is the best way to compare design options and evaluate tradeoffs in an existing repository?

Comparing design options in an existing repository involves investigating the current architecture, tracing flows, and sketching alternative approaches. This allows you to weigh tradeoffs and surface risks before committing to implementation.

How do I debug an unfamiliar system by tracing flows and dependencies?

Debugging unfamiliar systems requires reading files and tracing dependencies to map the relevant parts of the repository. This investigation clarifies how the architecture operates and highlights potential risks without modifying application code.

Can I analyze an auth refactor to outline implications without writing application code?

Yes, you can analyze an auth refactor by exploring the current system architecture and tracing dependencies. This outlines the implications of using a new module and surfaces risks without writing application code.

Does this codebase exploration approach write or modify application code during analysis?

No, this codebase exploration approach does not write or modify application code. It strictly reads files, traces dependencies, and summarizes findings to clarify requirements and compare design options before implementation.