openspec-explore

Investigate codebases and compare design options without implementing code.

32|7|Updated Apr 8, 2026
One-click install
npx skills add https://github.com/tbdavid2019/openclaw-docs-skill --skill openspec-explore-tbdavid2019
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: openspec-explore
Source: https://github.com/tbdavid2019/openclaw-docs-skill/tree/main/.github/skills/openspec-explore
Command: npx skills add https://github.com/tbdavid2019/openclaw-docs-skill --skill openspec-explore-tbdavid2019

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps you think through ambiguous software problems before committing to implementation, so you can clarify requirements, surface risks, and understand the codebase or design space more confidently.

Core Features & Use Cases

  • Idea exploration: Work through uncertain product or technical directions with a thinking partner.
  • Codebase investigation: Read repository files, map architecture, and identify relevant integration points.
  • Tradeoff comparison: Weigh multiple approaches, constraints, and risks before choosing a path.
  • Use case: A developer can use this Skill to unpack a messy feature request, inspect the existing system, and decide whether to refine the plan or create a change proposal.

Quick Start

Ask the assistant to enter explore mode for your problem and investigate the relevant codebase, options, and risks before any implementation begins.

Frequently Asked Questions about openspec-explore

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

FAQPage Schema
How do I investigate a codebase before implementing a new feature?

Codebase investigation involves reading repository files, mapping architecture, and identifying integration points to clarify ambiguous requirements. This skill supports exploratory analysis during early-stage or midstream design discussions to surface unknowns and compare options without writing code.

What is the best way to explore software architecture and tradeoffs?

Exploring software architecture involves weighing multiple approaches, constraints, and risks before choosing a path. This skill acts as a thinking partner to work through uncertain technical directions and compare tradeoffs before committing to a specific implementation plan.

Can I use this to clarify ambiguous software requirements?

Clarifying ambiguous software requirements is the core function of this skill. It investigates open-ended software problems, surfaces unknowns, and unpacks messy feature requests to help you decide whether to refine the plan or create a change proposal.

Does this skill generate code or only provide exploratory analysis?

This skill provides exploratory analysis only and does not generate code. It focuses on investigating design spaces, comparing architectural options, and surfacing risks during early-stage or midstream discussions before any implementation begins.

How do I create a change proposal after comparing design options?

Creating a change proposal follows comparing multiple approaches, constraints, and risks during exploration. This skill helps you unpack the problem, inspect the existing system, and decide whether to refine the plan or formulate a formal proposal for the next steps.

When should I not use exploratory analysis for software problems?

Exploratory analysis is not suitable when requirements are fully defined and implementation can proceed directly. This skill is designed for early-stage or midstream design discussions where unknowns, tradeoffs, and ambiguous requirements still need to be surfaced and resolved.