make-plan
Scannednpx machina-cli add skill thedotmack/claude-mem/make-plan --openclawMake Plan
You are an ORCHESTRATOR. Create an LLM-friendly plan in phases that can be executed consecutively in new chat contexts.
Delegation Model
Use subagents for fact gathering and extraction (docs, examples, signatures, grep results). Keep synthesis and plan authoring with the orchestrator (phase boundaries, task framing, final wording). If a subagent report is incomplete or lacks evidence, re-check with targeted reads/greps before finalizing.
Subagent Reporting Contract (MANDATORY)
Each subagent response must include:
- Sources consulted (files/URLs) and what was read
- Concrete findings (exact API names/signatures; exact file paths/locations)
- Copy-ready snippet locations (example files/sections to copy)
- "Confidence" note + known gaps (what might still be missing)
Reject and redeploy the subagent if it reports conclusions without sources.
Plan Structure
Phase 0: Documentation Discovery (ALWAYS FIRST)
Before planning implementation, deploy "Documentation Discovery" subagents to:
- Search for and read relevant documentation, examples, and existing patterns
- Identify the actual APIs, methods, and signatures available (not assumed)
- Create a brief "Allowed APIs" list citing specific documentation sources
- Note any anti-patterns to avoid (methods that DON'T exist, deprecated parameters)
The orchestrator consolidates findings into a single Phase 0 output.
Each Implementation Phase Must Include
- What to implement — Frame tasks to COPY from docs, not transform existing code
- Good: "Copy the V2 session pattern from docs/examples.ts:45-60"
- Bad: "Migrate the existing code to V2"
- Documentation references — Cite specific files/lines for patterns to follow
- Verification checklist — How to prove this phase worked (tests, grep checks)
- Anti-pattern guards — What NOT to do (invented APIs, undocumented params)
Final Phase: Verification
- Verify all implementations match documentation
- Check for anti-patterns (grep for known bad patterns)
- Run tests to confirm functionality
Key Principles
- Documentation Availability ≠ Usage: Explicitly require reading docs
- Task Framing Matters: Direct agents to docs, not just outcomes
- Verify > Assume: Require proof, not assumptions about APIs
- Session Boundaries: Each phase should be self-contained with its own doc references
Anti-Patterns to Prevent
- Inventing API methods that "should" exist
- Adding parameters not in documentation
- Skipping verification steps
- Assuming structure without checking examples
Source
git clone https://github.com/thedotmack/claude-mem/blob/main/plugin/skills/make-plan/SKILL.mdView on GitHub Overview
Make Plan acts as an ORCHESTRATOR to produce an LLM-friendly, phased plan for a feature, task, or multi-step implementation. It starts with Documentation Discovery using subagents to identify actual APIs, patterns, and constraints, then outputs phase-bound tasks with exact references. This approach ensures alignment with docs, reproducibility, and verifiable results across new chat contexts.
How This Skill Works
An orchestrator frames tasks by copying patterns from docs, not rewriting code. Subagents gather facts (docs, signatures, examples) and return a Contract with sources and copy-ready snippets. Phases are self-contained, start with Phase 0 Documentation Discovery, and include What to Implement, References, Verification, and anti-pattern guards.
When to Use It
- When asked to plan a feature, task, or multi-step implementation to ensure a concrete, phase-by-phase plan grounded in documentation.
- Before executing with do, to guarantee each phase has verification checks and anti-pattern guards.
- When integrating with external APIs or services to extract exact signatures and usage from official docs.
- For complex migrations or multi-stage workflows that benefit from explicit phase boundaries and copy-ready phase specs.
- When you must avoid inventing APIs or undocumented parameters by requiring explicit documentation references.
Quick Start
- Step 1: Run Documentation Discovery by deploying subagents to collect docs, identify allowed APIs, examples, and anti-patterns.
- Step 2: Draft Phase 0 output and outline Phase 1+ tasks with exact document references and concrete What to Implement statements.
- Step 3: Execute phases in new chat contexts with do commands, validating results against the verification checklist and doc references.
Best Practices
- Always start with Phase 0: Documentation Discovery to gather sources, APIs, examples, and anti-patterns.
- Cite exact files and line ranges for every pattern or API referenced in a phase.
- Copy tasks directly from docs (patterns, signatures, examples) rather than transforming existing code.
- Attach a verification checklist and anti-pattern guards to every phase.
- Ensure each phase is self-contained with its own document references and clear boundaries.
Example Use Cases
- Plan a feature flag rollout by identifying toggle APIs, rollout steps, and rollback docs, all cited from official docs.
- Plan a REST API integration by extracting endpoint signatures, auth flows, and error handling from API docs.
- Design a data export pipeline with phased steps tied to data schema specs and sample configs from docs.
- Orchestrate a UI component enhancement with phase-specific references to design docs and testing patterns.
- Migrate a plugin architecture to a new model, detailing phase-by-phase changes with cited sources and tests.
