Menü
Use when an agent needs full context before beginning work on a Spec or Plan. Gathers the document chain from plan through spec to RFC.
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.
Basierend auf der SOC-Berufsklassifikation
Use when carrying out the work a delivery document describes -- the build loop -- against its task breakdown and acceptance criteria.
Use as the entry point for any work, including reported bugs, defects, and unexpected behaviour. Reads the configured DAG and the user's position, then dispatches the right verb -- advancing within the current document automatically but stopping at type boundaries.
Use when moving a document to its next status along the type's lifecycle DAG, maintaining links and checking gates at the transition.
Use when drafting a document of a configured type collaboratively -- AI proposes a draft body, the human edits, iterate -- up to the type's authorship ceiling.
Use when adding a new custom document type to a lazyspec project. Interviews the user to co-author the type's methodology -- intent, authorship, lifecycle, gates, relations -- then writes its enriched template and `[[types]]` config via the config-write CLI. One type per run.
Use when running a criteria-based review (health check, security audit, accessibility review, pen test, bug bash, spec compliance). Creates an Audit document with findings and presents them to the user for triage.
| name | resolve-context |
| description | Use when an agent needs full context before beginning work on a Spec or Plan. Gathers the document chain from plan through spec to RFC. |
NO IMPLEMENTATION WITHOUT FULL CONTEXT
If you haven't read the Spec -> existing Plan chain (and RFC if one exists), you cannot write code.
Do NOT begin implementation without completing this skill. Read the full document chain (Spec -> Plan, and RFC if linked) before writing any code. After completion: use the `/create-plan` skill.[!IMPORTANT] Read
_common.mdin the skills directory for CLI usage, forbidden actions, and subagent tiers.
lazy -> write-rfc -> create-spec -> resolve-context -> create-plan -> build
resolve-context.style.fill: "#4A9EFF"
resolve-context.style.font-color: "#FFFFFF"
lazy.style.opacity: 0.4
write-rfc.style.opacity: 0.4
create-spec.style.opacity: 0.4
create-lazy.style.opacity: 0.4
build.style.opacity: 0.4
Identify target doc -> Resolve chain -> Read bodies if needed -> Check for existing work -> State context back -> Context complete
Context complete.shape: double_circle
lazyspec show <id> --json| Operation | Agent Type | Tier | Context to provide |
|---|---|---|---|
| Discover relevant codebase files | Explore | Medium | Type names, module paths from spec documents |
| Summarize context | (inline) | - | Main agent synthesizes findings |
Identify the document: Use lazyspec list --json or lazyspec search <query> --json to find the target document.
Resolve the chain: Run lazyspec context <id> --json to get the full implements chain (Spec -> Plan, and RFC if linked) in one call.
Read document bodies: The context command shows frontmatter only. For documents where you need the full body (typically the Spec contracts and RFC design intent if an RFC exists), follow up with lazyspec show <id> --json on those specific documents.
Check for existing work: Run lazyspec status --json to get all documents, relationships, and validation results in one call. Look for existing plans, ADRs, or related documents that cover the same ground.
Discover relevant code: The spec documents often name exact files and symbols -- use those as starting points rather than guessing at file paths.
Assemble context: You now have the full chain: Spec (contracts) -> existing Plans (prior work) -> relevant codebase locations. If an RFC exists: RFC (intent) -> Spec -> Plans.
State it back: Before proceeding, summarise the context chain: what the RFC intends (if one exists), what contracts the Spec defines, what prior plans have already done, and which parts of the codebase are involved. This forces you to confirm you actually understood it.
| Red Flag | Reality |
|---|---|
| "I already know this codebase" | Knowledge decays. Prior plans may have changed assumptions. |
| "I'll read the Spec and skip the RFC" | If an RFC exists, read it -- it explains why. Standalone specs are fine without one. |
| "I'll look things up as I go" | Ad-hoc context gathering misses the big picture. Resolve the full chain. |
Before claiming this skill is complete:
lazyspec context <id> --json has been run on the target documentlazyspec show --json has been run on documents where the body is needed (Spec contracts, RFC design)lazyspec status --json or search)