Intent Discovery

Turning Ideas Into Actionable Designs

Overview

Guide raw ideas through structured dialogue into fully specified, validated designs. Begin by surveying the existing project landscape, then iteratively refine understanding through targeted questions. Once the design crystallizes, present it for approval.

The Prime Directive

NO IMPLEMENTATION WITHOUT A VALIDATED DESIGN FIRST

No exceptions. No workarounds. No shortcuts.

When to Use

Required for:

• Creating new features or components
• Extending existing system capabilities
• Changing how existing code behaves
• Launching new projects or modules
• Rearchitecting or redesigning existing systems

Skip for:

• Correcting typos or spelling mistakes
• Updating imports the user has specified exactly
• Configuration changes dictated verbatim by the user
• Removing files the user has explicitly identified
• Executing commands the user has provided exactly

<MANDATORY-CHECKPOINT>
Do NOT invoke any implementation skill, generate any code, scaffold any project, or take any implementation action until a design has been presented and the user has signed off. This applies to EVERY project regardless of apparent simplicity.
</MANDATORY-CHECKPOINT>

Cognitive Traps

Every project passes through this process. A todo list, a utility function, a config tweak -- all of them. "Simple" projects are precisely where unchallenged assumptions generate the most wasted effort. The design can be brief (a few sentences for genuinely simple work), but you MUST present it and receive approval.

Checklist

You MUST create a task for each of these items and complete them sequentially:

1. Survey project landscape -- examine files, documentation, recent commits
2. Locate reference material -- invoke reference-engine skill to route to the appropriate reference system (github-search for external repos and libraries, codebase-research for internal patterns, design-research for visual themes, ux-patterns for UI, or built-in libraries for APIs/schemas/testing/infrastructure)
3. Ask clarifying questions -- one per message, understand purpose/constraints/success criteria
4. Present 2-3 approaches -- as labeled options (A/B/C) with trade-offs, star the recommendation
5. Present design -- in sections proportional to complexity, get user confirmation after each section (YoloMode: present and proceed)
6. Record design document -- save to docs/plans/YYYY-MM-DD-<topic>-design.md and commit
7. Hand off to implementation -- invoke task-planning skill to build the implementation plan

Workflow Diagram

digraph intent_discovery {
    "Survey project landscape" [shape=box];
    "Ask clarifying questions" [shape=box];
    "Present 2-3 approaches" [shape=box];
    "Present design sections" [shape=box];
    "User confirms design?" [shape=diamond];
    "Record design document" [shape=box];
    "Invoke task-planning" [shape=doublecircle];

    "Survey project landscape" -> "Ask clarifying questions";
    "Ask clarifying questions" -> "Present 2-3 approaches";
    "Present 2-3 approaches" -> "Present design sections";
    "Present design sections" -> "User confirms design?";
    "User confirms design?" -> "Present design sections" [label="no, revise"];
    "User confirms design?" -> "Record design document" [label="yes"];
    "Record design document" -> "Invoke task-planning";
}

The terminal state is invoking task-planning. Do NOT invoke ui-engineering or any other implementation skill. The ONLY skill you invoke after intent-discovery is task-planning.

Detailed Process

Exploring the idea:

• Review the current project state first (files, documentation, recent commits)
• Pose questions one at a time to sharpen understanding
• Favor multiple-choice questions when practical, but open-ended questions are acceptable
• Limit each message to one question -- if a topic needs deeper exploration, split it across messages
• Concentrate on: purpose, constraints, success criteria

Researching existing solutions:

• REQUIRED SUB-SKILL: Use godmode:reference-engine to route to the appropriate reference system
• The reference-engine skill routes to: github-search (external repos and libraries), codebase-research (internal codebase patterns), design-research (visual themes), ux-patterns (UI), or its own built-in libraries (APIs, schemas, testing, CI/CD, infrastructure)
• Summarize findings: "Found references from [sources]: [what is relevant]"
• Incorporate into proposals: which references to build on, extract from, or study

Evaluating approaches:

• Propose 2-3 distinct approaches as labeled options (A, B, C) with trade-offs
• Mark the recommended option with a star (⭐)
• Lead with the recommended option and explain the rationale
• Reference findings: "Approach A is inspired by github.com/x/y (5k stars, MIT license)"
• If YoloMode is active: Still present all options and wait for user selection. Approach selection is never auto-picked.

Presenting the design:

• Once you believe the design is clear, present it
• Scale each section to its complexity: a few sentences for straightforward parts, up to 200-300 words for nuanced areas
• Ask after each section whether it looks correct so far
• Cover: architecture, components, data flow, error handling, testing strategy
• Be prepared to revisit and clarify if something is unclear
• If YoloMode is active: Present the full design in one pass and proceed to recording, without per-section confirmation. The user trusts the recommendation.