explore

Clarify vague ideas and technical problems before implementation planning.

1|Updated Apr 14, 2026
One-click install
npx skills add https://github.com/materkey/cc-plugins --skill explore-materkey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: explore
Source: https://github.com/materkey/cc-plugins/tree/main/plugins/explore/skills/explore
Command: npx skills add https://github.com/materkey/cc-plugins --skill explore-materkey

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you investigate ideas, ambiguous problems, and early requirements before committing to an implementation plan. It creates space for structured thinking when the right approach is still unclear.

Core Features & Use Cases

  • Idea Exploration: Work through vague concepts, tradeoffs, and possible directions without jumping into execution.
  • Codebase Investigation: Read files, map architecture, and uncover constraints or integration points that shape the decision.
  • Plan Readiness: Clarify the problem, surface risks, and determine when the discussion is mature enough to hand off to a formal implementation plan.
  • Use Case: When a team is considering a new feature like real-time collaboration or trying to untangle a messy subsystem, this Skill helps frame the options and sharpen the next step.

Quick Start

Ask the explore skill to help you think through a feature idea, compare approaches, or investigate how a relevant part of the codebase currently works before planning implementation.

Frequently Asked Questions about explore

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

FAQPage Schema
How do I clarify vague technical requirements before implementation begins?

Clarifying vague technical requirements involves structuring early exploration to map architecture and surface constraints before implementation. This process resolves ambiguity by framing options and tradeoffs, ensuring the problem is fully understood before committing to a plan.

What is the best way to investigate a messy subsystem and map architecture?

Investigating a messy subsystem requires reading contextual code and mapping architecture to uncover integration points. This approach highlights structural constraints and tradeoffs, sharpening the next step without writing or modifying any implementation code.

How do I analyze tradeoffs for a new feature like real-time collaboration?

Analyzing tradeoffs for a new feature requires exploring possible directions and constraints without jumping into execution. This structured thinking frames the options, evaluates architectural impacts, and determines when the discussion is mature enough for formal planning.

Can I use this approach to discover integration points in a codebase?

You can use codebase exploration to discover integration points by reading files and mapping architecture. This contextual code reading uncovers structural constraints and shapes the decision-making process before any implementation changes are made.

When should I avoid starting implementation and focus on architecture investigation?

You should avoid implementation and focus on architecture investigation when the right approach is still unclear. A non-implementation workflow creates space for structured thinking, allowing you to surface risks and clarify problems before planning begins.