Intent Compiler

Use this skill to turn raw user thought into the most useful next artifact. A prompt is only one possible output. Your job is to infer intent, choose the right artifact and depth, generate it, and lightly check that it is neither too shallow nor overbuilt.

Triggers

Use this skill when the user asks or implies:

• "think through this"
• "make this Codex ready"
• "turn this into a prompt"
• "build a plan"
• "can this be a skill or agent?"
• "make this clearer"
• fragmentary notes that need expansion, routing, or structure

Task Types

Classify the request as one primary type:

• direct-answer
• rewrite-polish
• prompt-generation
• codex-task
• product-thinking
• research-planning
• architecture-design
• workflow-design
• agent-design
• skill-design
• communication-draft
• debugging-plan
• decision-support
• documentation
• evaluation-design

Depth Ladder

Use the lowest depth that creates a useful artifact.

• Depth 0: direct answer
• Depth 1: rewrite/polish
• Depth 2: prompt generation
• Depth 3: structured plan
• Depth 4: workflow/spec
• Depth 5: agent or system architecture
• Depth 6: execute, evaluate, revise, and package

Examples:

• "ack with sounds good" -> Depth 0 or 1, a tiny acknowledgement.
• "make this Codex ready" -> Depth 4, an implementation prompt with files, steps, tests, and acceptance criteria.
• "think through this product idea" -> Depth 3 or 4, a structured analysis, not just a prettier prompt.

Procedure

1. Infer the user's real intent from fragments, shorthand, tone, and constraints.
2. Classify the task type.
3. Select the depth. Escalate only when ambiguity, scope, or execution complexity justifies it.
4. Fill reasonable gaps. Do not ask clarifying questions unless a missing fact blocks progress. If blocked, ask at most one question and still provide a useful partial artifact when possible.
5. Optionally form this internal representation:

{
  "intent_summary": "...",
  "task_type": "...",
  "depth": 0,
  "target_artifact": "...",
  "constraints": [],
  "assumptions": [],
  "missing_context_nonblocking": [],
  "success_criteria": [],
  "workflow": []
}

Show the representation only when the user is designing a system, debugging ambiguity, or explicitly asks for structure.

6. Produce the artifact. Make the main output immediately useful.
7. Evaluate lightly before finalizing:
   • Did the artifact satisfy the inferred intent?
   • Is it too shallow?
   • Is it overengineered?
   • Are assumptions clear?
   • Is the next action obvious?

Codex Task Pattern

For Codex-ready tasks, include:

• Goal
• Context
• Repo/file expectations
• Implementation steps
• Edge cases
• Tests
• Documentation updates
• Acceptance criteria
• "Do not ask unless blocked" instruction
• Final response requirements

Output Patterns

Usually start with one sentence:

I'm treating this as a request for <artifact> at Depth <n>.

Then provide the artifact. Avoid extended meta-commentary unless the user is exploring the skill itself.

For very small requests, skip the classification sentence if it would be more noise than value.

Anti-Patterns

• Do not turn every small request into a framework.
• Do not produce a giant prompt when a direct answer is enough.
• Do not ask three clarifying questions when one lightweight assumption works.
• Do not expose internal JSON by default.
• Do not claim novelty where the work is packaging and procedure.
• Do not optimize for maximal abstraction; optimize for useful action.

When To Load References

• Read references/depth-ladder.md for tricky depth selection.
• Read references/artifact-recipes.md when generating a specific artifact type.
• Read references/usability-principles.md when the task is UX or product oriented.
• Read references/philosophy.md when the user asks about the idea itself.
• Read references/prior-art.md when the user asks about novelty, history, research, or similar ideas.
• Read references/future-work.md when asked for roadmap or extensions.