Menü
Graph-first codebase discovery → project-map.md. Use at session start on an unfamiliar project, or /explore. Not for root-cause analysis (analyze) or deriving a spec (reverse-document).
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Divergent idea generation — many candidate ideas across several frames with judgment deferred, then a clustered shortlist. Use to open a solution space wide, or /brainstorm. Not for developing one idea (ideate) or picking one (propose).
Develops ONE chosen direction into a shaped concept — the core idea, how it works, what it needs, the open questions. Use to deepen a single idea, or /ideate. Not for generating many (brainstorm) or deciding among them (propose).
Structures a presentation narrative — the story arc, a slide-by-slide outline, and speaker notes — from results or receipts. Use to shape a talk or deck, or /present. Not for prose reports (report) or rendering visuals (asset).
Converges to a recommended approach — the options, their tradeoffs against stated criteria, a pick, and the rationale (plus what would change the call). Use to decide among approaches, or /propose. Not for generating options (brainstorm) or deep-diving one (ideate).
Plans a throwaway proof-of-concept to answer ONE feasibility unknown — the question, the smallest build that answers it, the success signal, and the discard plan. Use to de-risk before committing, or /prototype. Not for the real build (executor) or deciding (propose).
Produces a REDTEAM-FINDINGS.md probing your OWN AI app for jailbreak/injection/exfil/tool-abuse susceptibility, each reproduced and paired with a hardening, after a blocking authorization+ownership check. Use to red-team an owned AI system defensively.
Basierend auf der SOC-Berufsklassifikation
| name | explore |
| description | Graph-first codebase discovery → project-map.md. Use at session start on an unfamiliar project, or /explore. Not for root-cause analysis (analyze) or deriving a spec (reverse-document). |
You map an unfamiliar project so everything downstream can route. You traverse graph-first — start
at the high-value nodes (entry points, manifests, configs, test files, the dependency surface) and
follow edges outward — rather than reading every file. The output is one durable project-map.md plus
memory drawers, so the second session in this codebase does not re-discover it. Domain-neutral: the
"codebase" may be source, a data project, a content repo, or a research corpus.
Does: seed from high-value nodes, traverse to a bounded depth, write a project-map.md (structure,
entry points, conventions, risk files, where things live) and FRESH finding drawers, and a receipt.
Does not: derive a spec from the code (that is reverse-document), diagnose a failure (analyze),
modify any file, or read the whole repo when the high-signal subset answers the question.
reverse-document, not a map.project-map.md already exists for this codebase and nothing has changed — reuse it (check
staleness) instead of re-traversing.| Situation | Reference |
|---|---|
| Drawer write delegation | library/systems/memory/drawer-writer.py |
| Receipt write delegation | engine/shared/references/script-delegation-contract.md |
| Avoid reading the whole repo (attention budget) | engine/shared/references/context-degradation.md |
| Field | Required | Description |
|---|---|---|
root | yes | the project root to map |
depth | no | traversal bound (default: shallow — entry points + one hop) |
refresh | no | force re-traverse even if a recent project-map.md exists |
Identify the entry points and the dependency surface first: manifests (package/build files), configs, the main entry module(s), the test directory, the docs index. These are the graph's hubs — they reveal structure faster than a flat file walk.
Follow imports/links/references from the seeds to depth. Record what you read (the evidence base).
Respect the attention budget (context-degradation.md): read high-signal nodes, note the unread scope —
do not load the whole tree.
project-map.mdEmit a map: directory structure with purpose, entry points, conventions observed (naming, error handling, test layout), risk/complex files, and "where to put X" guidance. Mark inferences as such.
Write the durable facts (conventions, architecture decisions observed, risk files) as FRESH memory
drawers via drawer-writer.py, so they accrete (the next session benefits). Category by type
(architecture / implementation / quality).
Write the explore receipt (what was mapped, what was skipped, drawer count, staleness).
explore receipt (<workspace>/receipts/explore-receipt-<timestamp>.json): base + map_path,
entry_points (array), conventions (array), risk_files (array), drawers_written, unread_scope,
confidence. persistence: Spec-First. Second output: project-map.md at map_path.
depth; map the high-signal subset and record unread_scope — never
attempt a full read (lost-in-the-middle degrades the map).project-map.md exists but is STALE: re-traverse only the changed surface; do not discard the map.Done when: project-map.md exists with entry points, structure, conventions, and risk files; finding
drawers are written; a receipt records the mapped + unread scope.
Not done if: the whole repo was read into context instead of the high-signal subset; inferences were asserted as fact; no drawers were written (the map did not accrete); no receipt.
Next step: intake/recipe routes on the map; reverse-document can derive a spec from it; analyze
can root-cause within it.