axel-pm/watch-n-learn / examples/find-your-unknowns
find-your-unknowns
VerifiedBefore turning an agent loose on a coding task, surface the decisions you never specified — the gaps between your prompt (the "map") and the real codebase (the "territory"). Runs six prompt patterns (blind-spot pass, brainstorm/prototype, interview-me, reference-as-map, implementation-notes logging, quiz-me) to enumerate unknowns and shape the architecture up front. Use when the user says "help me scope this before I build it", "what am I missing", "find my blind spots", "interview me about this feature", "I don't know this codebase / this domain, help me prompt better", "de-risk this before the big run", or "surface the unknowns" — and BEFORE kicking off a large or architecture-shaping agent run on an under-specified task.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.2 KB |
| hooks/plan-mode-unknowns-nudge.shexecutable | script | 1.6 KB |
| references/prompt-patterns.md | markdown | 3.9 KB |
| settings-snippet.json | config | 747 B |
references/prompt-patterns.md
View on GitHub# prompt-patterns.md — the six templates
Copy-pasteable prompts for each pattern. Replace `{{...}}` placeholders. These are starting
points — adapt the wording to the task; the *shape* is what matters.
---
## 1. Blind-spot pass
**For:** unknown unknowns — you're new to this codebase or domain.
```
I'm working on {{task}} in this codebase, and I know little about how {{area/subsystem}}
works here. Do a blind-spot pass: read the relevant code and help me figure out my
unknown-unknowns — the decisions and constraints this task touches that I haven't mentioned.
Then suggest how I should prompt you to do this well. Don't start implementing.
```
Domain variant (learning a new field, not just a new repo): replace "in this codebase" with the
field, e.g. "I'm about to do {{color grading / payments / auth}} and know nothing about it — do a
blind-spot pass on what I'd need to decide."
---
## 2. Brainstorm & prototype
**For:** aesthetic / "know it when I see it" decisions you can't specify in words.
**Skip if:** the task's unknowns are data-model or behavioral, not visual.
```
I need {{a dashboard / landing page / component}} and I have no fixed visual taste here.
Make me a single HTML page showing {{3–4}} wildly different design directions side by side,
so I can react to them instead of specifying up front. Make them genuinely distinct, not
variations on one idea.
```
Then react: pick one, or splice ("the layout of A with the type of C"), and feed that back as the spec.
---
## 3. Interview me
**For:** under-specified requirements.
```
Interview me about {{task}} before we build it. Here's context: {{who I am / the stage /
constraints / what exists}}. Ask me questions one or a few at a time, and prioritize
questions whose answers would change the architecture. Keep going until the important
ambiguities are resolved.
```
The architecture-priority instruction is the key line — it stops the interview from burning turns on cosmetics.
---
## 4. Reference — give it another map
**For:** when pointing at an example is easier than writing a spec.
**Skip if:** you have no reference (code, system, or mockup) to point at — but offer it, since an
analogous feature often exists somewhere worth naming.
```
Instead of a written spec, use this as the map for what I want: {{path/URL to reference code,
another system, or an HTML mockup}}. Read it, understand the intent behind it, and use it as
the starting point for {{task}} — adapting it to this codebase / language. Tell me where the
reference doesn't map cleanly onto what we have.
```
The reference can be in a different language or system — you're transferring intent, not copying code.
---
## 5. Implementation notes
**For:** deviations that only appear once the agent is actually building. Inject this into the
**main build run**, not a scouting pass.
```
As you implement {{task}}: whenever you hit a decision the spec doesn't cover, or you deviate
from what I asked, log it — a short "IMPLEMENTATION NOTE: {{what}} — {{why}}" — before you
continue. I want a visible trail of every point where you left the plan.
```
Afterward, read the notes: each one is a place the territory differed from your map.
---
## 6. Quiz me
**For:** making sure *you* understand the result well enough to own it.
```
Quiz me on what you just built for {{task}}: the key decisions, how the main pieces fit, and
anything I'd need to defend in review. Ask one question at a time and tell me when I'm wrong.
```
Use before opening/approving the PR — if you can't answer, you're not really in the loop yet.
---
## Consolidation template
After running the chosen patterns, ask for one summary:
```
Consolidate everything we surfaced into: (1) an Unknowns list — open questions and blind spots;
(2) Architecture-shaping answers we've now settled; (3) a single logging instruction I can paste
into the main run so mid-build deviations keep surfacing. Then stop — I'll kick off the real build.
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |