<mission_control> <objective>Refine vague or unclear prompts into precise, actionable instructions using L1/L2/L3/L4 methodology.</objective> <success_criteria>Prompt refined to appropriate L-level with sufficient context and clear intent</success_criteria> </mission_control>

The Path to High-Quality Prompts

1. Match Complexity to Structure

Prompt structure should reflect task complexity. Simple tasks with complex templates waste tokens; complex tasks with simple prompts miss requirements.

Select L-level by purpose:

• •L1 (Single-sentence): Quick clarifications, straightforward outcomes
• •L2 (Context-rich paragraph): Default choice—balances clarity and efficiency
• •L3 (Structured bullets): Complex tasks with multiple constraints
• •L4 (Template/framework): Reusable patterns, repeatable workflows

Why this works: Right-sized structure ensures Claude understands requirements without over-constraining creativity or under-specifying deliverables.

2. Enrich Context, Reduce Ambiguity

Add relevant background, technical constraints, and success criteria. Context prevents wrong assumptions and reduces clarification rounds.

Essential context elements:

• •Technical stack/platform/environment
• •Forbidden approaches ("no external deps")
• •Compliance requirements
• •Output format specifications
• •Measurable success targets

Why this works: Context acts as guardrails—Claude navigates within boundaries instead of guessing requirements.

3. Preserve What Matters, Delete What Doesn't

Keep only constraints that actually change the answer. Remove tone fluff, obvious best practices, and redundant examples.

Keep these non-negotiables:

• •Tech stack/platform constraints
• •Forbidden approaches
• •Compliance requirements
• •Hard output format (JSON, word limits)
• •Measurable success targets

Delete these inefficiencies:

• •Step-by-step instructions (Claude knows how to work)
• •Tone guidance ("be professional," "be creative")
• •Obvious best practices
• •Redundant examples

Why this works: Minimal-yet-sufficient prompts achieve clarity with maximal efficiency. Every word should earn its place.

4. Specify Outputs Precisely

Define deliverables explicitly—format, structure, completeness. Ambiguous outputs produce ambiguous results.

Output specification patterns:

• •"Complete deployable website with HTML/CSS/JS"
• •"JSON array with objects containing id, name, timestamp"
• •"≤500 words summary with key findings"
• •"Unit tests achieving 90%+ coverage"

Why this works: Precise output specifications set clear expectations. Claude knows exactly what "done" looks like.

Operational Patterns

• •Tracking: Maintain a visible task list for prompt refinement
• •Consultation: Consult the user when L-level is unclear
• •Management: Manage task lifecycle for context enrichment

Core Methodology

FROM_SCRATCH method: Convert user's goal/topic into outcome + minimal context + hard constraints

REFINE method: Delete fluff, keep only constraints that actually change the answer

Default: Produce prompts as a single plain-text paragraph (L2 format)

Escalate: Use keypoints (L3) and templates (L4) only when justified

Execution Process

When user provides prompt to refine:

STEP 1: Parse Input

• •Extract user's raw prompt text
• •Determine if FROM_SCRATCH or REFINE scenario
• •Identify missing context, constraints, or deliverables

STEP 2: Apply Refinement

• •FROM_SCRATCH: Convert goal → outcome + context + hard constraints
• •REFINE: Remove step-by-step instructions, obvious best practices, tone fluff, redundant examples
• •Keep: Only constraints that actually change the answer

STEP 3: Structure Output

Generate exactly:

• •L1: One-sentence outcome statement
• •L2: Context-rich paragraph with constraints (no Markdown)
• •L3: Structured bullets (Task/Constraints/Output)
• •L4: Template/framework (only if complex/reusable)
• •Rationale: 2-4 sentences explaining minimal-yet-sufficient approach

STEP 4: Deliver

Output ONLY the refined prompt in the exact format:

L1: [outcome statement]
L2: [context-rich paragraph with constraints]
L3:
- **Task:** [description]
- **Constraints:** [key constraints]
- **Output:** [deliverables]
L4:

[TEMPLATE ONLY IF JUSTIFIED - use ```code blocks for templates]

Rationale: [2-4 sentences explaining approach]

Example

Input: "Create a marketing website"

Output:

L1: Create a conversion-optimized landing page
L2: You are a senior web developer creating a high-converting landing page for [PRODUCT]. Focus on clear value proposition, social proof placement, and frictionless CTA design. Use modern CSS Grid/Flexbox layouts with mobile-first approach. Ensure WCAG 2.1 AA accessibility compliance. Prioritize page speed optimization and SEO fundamentals. Output a complete, deployable website with semantic HTML, optimized images, and conversion tracking setup.
L3:
- **Task:** Create landing page for [PRODUCT] with conversion optimization
- **Constraints:** Mobile-first responsive design; WCAG 2.1 AA accessibility; <3s load time; semantic HTML; SEO-ready
- **Output:** Complete deployable website with HTML/CSS/JS files + performance audit + accessibility report
L4:

Landing Page Requirements

Value Proposition

• •[Clear benefit statement in headline]
• •[Supporting subheading]
• •[Visual hero element]

Conversion Elements

• •[Primary CTA placement]
• •[Secondary CTA for hesitant users]
• •[Social proof testimonials]

Technical Specs

• •Responsive breakpoints: 320px, 768px, 1024px
• •Performance budget: <150KB total, <3s load
• •Accessibility: WCAG 2.1 AA checklist

Rationale: The refined prompt provides clear technical constraints (mobile-first, WCAG compliance, performance budget) while maintaining creative flexibility. The L4 template ensures consistent deliverable structure across different landing pages while allowing product-specific customization.

Execution Best Practices

Deliver clean, focused output:

• •Output ONLY the refined prompt—never methodology explanations
• •Use L4 templates only for complex or reusable scenarios
• •Maintain all non-negotiable constraints from original input
• •Ask at most ONE question if ambiguity blocks producing useful refinement

Pattern contrast:

Good: Output L1→L2→L3→L4→Rationale format
Good: Remove fluff, keep constraints that change answers
Bad: Include methodology explanation in output
Bad: Use L4 when simple prompt suffices

Validation check: Refinement succeeds when it includes: 1) L1 outcome statement, 2) L2 context with constraints, 3) L3 structure, 4) L4 template if needed, 5) Clear rationale.

Common Mistakes to Avoid

Mistake 1: Using Wrong L-Level for Task Complexity

❌ Wrong: "Build a complete authentication system with JWT tokens, refresh tokens, password hashing, email verification, and rate limiting." → L1 response

✅ Correct: Identify complexity first. For multi-constraint tasks, use L3 or L4:

• •L3: Use bullet structure for multiple requirements
• •L4: Use template for repeatable patterns

Mistake 2: Keeping Tone Guidance and Fluff

❌ Wrong: "Be professional, creative, and thorough. Remember best practices. Be sure to use modern approaches."

✅ Correct: Remove all tone guidance. Keep only constraints that change outcomes:

• •"No external dependencies"
• •"Use TypeScript strict mode"
• •"Output must be deployable"

Mistake 3: Missing Output Format Specification

❌ Wrong: "Create a summary of the findings."

✅ Correct: Specify exact format and structure: "JSON array with objects: {id, name, timestamp, severity}. Max 100 items."

Mistake 4: Over-Constraining with Step-by-Step Instructions

❌ Wrong: "First read the file, then parse the JSON, then validate each field, then output the results."

✅ Correct: State the outcome, let Claude determine the approach: "Validate all fields in JSON file. Output errors as: {field, error, line_number}."

Mistake 5: Refining Already Clear Prompts

❌ Wrong: User: "Create a Python function that adds two numbers" Claude: "Let me refine this by adding context..."

✅ Correct: If prompt already has L1-L4 appropriate structure, proceed directly: "Already clear. Here's the function:"

def add(a, b):
    return a + b

Validation Checklist

Before claiming prompt refinement complete:

L-Level Selection:

• • L-level matches task complexity (not over-constraining, not under-specifying)
• • L1 for simple single-outcome tasks
• • L2 for default context-rich prompts
• • L3 for multi-constraint complex tasks
• • L4 for reusable patterns

Context Enrichment:

• • Technical stack/platform specified
• • Forbidden approaches identified
• • Compliance requirements noted
• • Output format clearly defined

Constraint Quality:

• • Only non-negotiable constraints kept
• • Tone guidance and fluff removed
• • Obvious best practices deleted
• • Step-by-step instructions replaced with outcomes

Output Specification:

• • Exact format specified (JSON, markdown, code)
• • Structure defined (array, object, bullets)
• • Completeness criteria clear (max items, coverage %)

Best Practices Summary

✅ DO:

• •Match L-level to task complexity
• •Add technical constraints, platform, environment
• •Keep only constraints that change outcomes
• •Specify exact output format and structure
• •Use L4 templates for repeatable patterns
• •Validate all 5 components: L1 outcome, L2 context, L3 structure, L4 template, rationale

❌ DON'T:

• •Use high L-level for simple tasks (wastes tokens)
• •Keep tone guidance ("be professional", "be creative")
• •Include step-by-step instructions (Claude knows how)
• •Add obvious best practices (Claude knows these)
• •Refine already clear prompts
• •Forget output format specification

<critical_constraint> Portability Invariant:

This component must work standalone with zero external dependencies. All necessary philosophy and patterns are contained within. </critical_constraint>