Skip to content
Skills Library
Programming · Analysis

explore

/explore

Map the terrain before designing. Use before any substantive design or planning step. Codebase changes, doc drafting, strategy decisions, anything with non-trivial structure. Trigger when the user invokes the explore skill, says "explore first", "what's already there", "map the codebase", or "survey the landscape". The output is mostly for my own grounding. Only surprises, hard constraints, and gotchas surface to the user. If exploration was uneventful, that itself is the report.

Licence
MIT
Last repository change
20.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 20.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Map the terrain before designing. Use before any substantive design or planning step. Codebase changes, doc drafting, strategy decisions, anything with non-trivial structure. Trigger when the user invokes the explore skill, says "explore first", "what's already there", "map the codebase", or "survey the landscape". The output is mostly for my own grounding. Only surprises, hard constraints, and gotchas surface to the user. If exploration was uneventful, that itself is the report.

Triggers from the description

explore firstwhatmap the codebasesurvey the landscape
Original author description

Map the terrain before designing. Use before any substantive design or planning step. Codebase changes, doc drafting, strategy decisions, anything with non-trivial structure. Trigger when the user invokes the explore skill, says "explore first", "what's already there", "map the codebase", or "survey the landscape". The output is mostly for my own grounding. Only surprises, hard constraints, and gotchas surface to the user. If exploration was uneventful, that itself is the report.

How it works

  1. Tooling
  2. The four phases
  3. What to surface
  4. After exploration
  5. Common pitfalls
Original SKILL.md headings · 48 lines, 498 words
SKILL.md preview
---
name: explore
description: Map the terrain before designing. Use before any substantive design or planning step. Codebase changes, doc drafting, strategy decisions, anything with non-trivial structure. Trigger when the user invokes the explore skill, says "explore first", "what's already there", "map the codebase", or "survey the landscape". The output is mostly for my own grounding. Only surprises, hard constraints, and gotchas surface to the user. If exploration was uneventful, that itself is the report.
---

# Explore: map the terrain before designing

Designing without exploring produces options grounded in general priors rather than the actual terrain. They look reasonable in the abstract but don't fit how this codebase / client / domain actually works.

This skill enforces a discipline: **before any design step, systematically map what's already there.** Existing patterns, hard constraints, hooks, and things that would surprise you if you weren't looking.

## Tooling

Match the tool to the operation, not the domain:

- **Autonomous broad exploration.** When the host offers fresh, read-only exploration workers, spawn one when scope is known and several in parallel when scope is uncertain or spans subsystems. Give each worker a *distinct* search focus. If no worker channel exists, perform the same focused passes with the host's search and file-reading capabilities.
- **Targeted lookups.** Use the host's search and file-reading capabilities directly when you need raw content in your own context.
- **Non-codebase sources.** File reads against notes/docs, web search, MCP queries.

## The four phases

The phases apply across domains. Adapt depth and tooling. The *questions* generalize even when the artifacts don't.

### 1. Locate: find what's relevant
What artifacts, sources, prior work, or context are in play? Don't accept the user's framing as the boundary. Adjacent material often turns out to be critical.

### 2. Trace: follow how things connect
Where does data/argument flow? What depends on what? Which derivations are critical? A trace is complete when you followed the primary artifact end to end: ingress, persistence, consumption.

### 3. Pattern: identify conventions
What recurring shapes and established ways of doing things exist? Fighting them creates friction; fitting them removes it.

### 4. Constrain: name the hard limits
What would create problems if violated? Knowing these upfront prevents proposing options that get killed in review.

## What to surface

Most findings stay in your context. Surface only **surprises**, **hard constraints**, **gotchas**, and **genuine ambiguities** that need user input before design can proceed. If exploration was uneventful, say that plainly. The detailed terrain map stays in your context for the next phase.

## After exploration

Findings are grounding for the next step, typically design. If you're proceeding in a way that ignores something from exploration, surface it: *"I'm doing X despite Y. The reason is..."*

## Common pitfalls

- **Performative exploration.** Reading material to look thorough, without tying findings to design implications.
- **Dumping the reading list.** "I read these 12 files". They want surprises and constraints, not the catalog.
- **Confusing locate with trace.** Listing artifacts isn't tracing how things connect. The phases build on each other.
- **Skipping because the terrain feels familiar.** Map it anyway when the work is non-trivial. The finding you'd skip past is often the one that reshapes the design.
- **Treating exploration as a deliverable.** It's grounding, not a research project. Time-box it.
- **Fanning out the same prompt to multiple exploration workers.** Each worker should have a distinct search focus, otherwise you're paying 3× for the same answer.

Versions

RepositoryScoreLicence
This page · pandysp/claude-plugins90MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
rapiddweller/archkeel100MIT
zimoliao/scholaraio100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT

Database snapshot: 13.11.2026 · package version b581db8bc778 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90explore-codebase
    Explore codebase files, patterns, and structure for a given topic. USE WHEN gathering implementation context before planning or executing tasks, when asked to research the codebase, or when a planning agent needs a Sub-Agent A (Codebase Research). Returns a Codebase Research…
  • 95codebase-explore
    Read-only codebase exploration and analysis. Use when the user asks "analyze codebase", "explore code", "what does this project do", "find files related to", "understand architecture", or needs to research the codebase before making changes. Cannot modify any files.
  • 100design-exploration
    Explore codebase and design approaches before implementation. Use when asked 'explore the design', 'how would this fit', 'design exploration', 'what patterns exist for', 'how is X implemented', or when another skill (brainstorm, nf) needs codebase context to ground a design…
  • 100design-exploration
    Explore codebase and design approaches before implementation. Use when asked 'explore the design', 'how would this fit', 'design exploration', 'what patterns exist for', 'how is X implemented', or when another skill (brainstorm, nf) needs codebase context to ground a design…
  • 100codebase-onboarding
    Use this skill when the user asks to \"explore this codebase\", \"understand this repo\", \"map the architecture\", \"review our stack\", \"get up to speed\", \"break ground\" on an unfamiliar project or research field, \"what is the state of this project\", \"audit the…
  • 100plan
    This skill should be used when the user asks to explore a codebase and design implementation plans without making any changes. Trigger when users say 'plan how to implement X', 'design an approach for Y', 'explore the codebase before changing Z', 'create an implementation…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.