A Field Guide to Talking to AI

You ask a question. The AI responds with something about medieval swordsmithing when what you needed was Excel formulas.

The machine isn’t broken. Your instruction was imprecise.

These systems operate through pattern recognition - they observe what came before and predict what follows. Your words constitute the data, and vague data produces vague output.

The problem is mechanical, which means the solution is precision.

Before you can handle complexity, you need foundation. These techniques establish the minimum structure required for the model to understand what’s being asked. Skip them and everything that follows becomes guesswork - and that’s not acceptable.

1 Structure Your Input

Unstructured thought confuses the model. Use XML-style tags to impose order on chaos.

Unclear:

Can you help me with my code it’s not working right and I think there’s a bug somewhere in the login function but I’m not sure what’s wrong with it

Clear:

<question>Why is my login function failing?</question>
<context>JavaScript, returns undefined instead of user object</context>
<code>
function login(email, password) {
  const user = database.find(email)
  return user
}
</code>

Tags establish boundaries. <question> signals intent. <context> provides environment. <code> designates what requires analysis. The model no longer has to guess where one concept ends and another begins. That’s crucial.

For multi-word labels, underscores maintain structure: <target_audience>software_engineers</target_audience>

2 Set the Context

Roles shape perspective. A security researcher examines for vulnerabilities. A UX designer evaluates experience. Same code, entirely different analysis. That matters more than you think.

Act as a {{role}} reviewing this authentication system.
Focus on {{focus}}.

{{code}}

Save this as a Migi template with dropdowns:

• {{role}}: Single Selection (security researcher, UX designer, performance engineer)
• {{focus}}: Single Selection (vulnerabilities, user experience, performance bottlenecks)
• {{code}}: Multi-line Text

The role calibrates the lens. With Migi’s dropdowns, selection replaces retyping. That’s efficient hierarchical organization.

3 Constrain the Output

Open questions invite sprawl. Boundaries force focus, and focus is what separates competent work from mediocre work.

Specify length. Specify format. Specify audience. The model conforms to structure.

A functional prompt produces output. A refined prompt produces the right output. The difference between the two lies in teaching the model what excellence looks like - through demonstration, through exclusion, through dialogue. This is where competence separates itself from mere activity.

4 Show Examples

Pattern-matching systems learn from demonstration. Show them what good looks like.

Write a product description matching this tone:

<example>
"Built for developers who refuse to waste time on configuration. Zero setup. Pure function."
</example>

Product: {{product_name}}
Features: {{feature_list}}

This becomes a Migi template. {{product_name}} and {{feature_list}} change. The example anchors style. The AI mirrors what it observes - that’s how these systems work at the fundamental level.

5 Define What to Avoid

Negative space shapes output. Tell the model what NOT to do, and you define the boundaries of acceptable behavior.

Vagueness fails. “Don’t make it corporate” means nothing. List specific patterns to exclude - be precise about the boundaries.

6 Use Multi-Pass Processing

Complexity demands iteration. You don’t build a cathedral in one pass, and you shouldn’t expect perfection from a single prompt.

1. First pass: Generate rough draft without polish
2. Second pass: Refine structure, remove redundancy
3. Third pass: Review for accuracy and tone

Breaking work into phases produces better results than demanding perfection immediately. That’s a fundamental principle.

7 Add Metadata for Structured Tasks

Code generation, tables, technical content - these benefit from inline annotations. Give the model the metadata it needs to understand the hierarchy of your request.

Generate a comparison table of authentication methods.

<!-- table: include columns for security level, implementation complexity, user experience -->
<!-- format: markdown -->
<!-- audience: technical decision-makers -->

The model reads these annotations and adjusts accordingly. Structure matters.

Even well-structured prompts fail. The question isn’t whether failure occurs - it will - but whether you diagnose and correct it. These patterns address the most frequent points of breakdown. Pay attention to them.

8 Force Step-by-Step Reasoning

Logic requires exposition. Force the model to show its work, because that’s where errors reveal themselves.

Explanation either reveals accuracy or exposes error. Either way, you know where you stand.

Writing the same prompt repeatedly is ritual without reason. Templates transform individual solutions into repeatable systems. Variables turn rigid text into adaptable instruments. This is how you build competence that scales.

9 Build Reusable Templates

Repetitive tasks demand reusable forms. That’s basic organizational hierarchy.

Migi’s {{variableName}} syntax creates placeholders. Use a template, fill the form.

Review this {{language}} code for {{focus_area}}.

Code:
{{code_snippet}}

Analysis requirements:
- Flag potential bugs
- Identify performance issues
- Suggest improvements
- Explain reasoning for each point

Configure variable types:

Hit ⌥+Space. Type three letters. Fill the form. Press Enter. Prompt copied to clipboard. Five seconds instead of reconstruction. That’s the difference between chaos and order.

10 Define Success Criteria

Tell the model what acceptable output looks like. Be explicit about the standards.

Summarize this document.

Requirements:
- {{word_limit}} words maximum
- {{reading_level}} reading level
- Highlight {{key_points}} key points in bold
- Include {{example_count}} concrete example(s)

Document:
{{document}}

Make this a Migi template. Requirements become variables. Constraints adjust per-use without editing the base prompt. That’s systematic efficiency.

11 Let the AI Ask Questions

Sometimes the problem space isn’t fully defined. That’s not a failure - that’s reality. Let the model ask clarifying questions.

This surfaces gaps before generation and prevents building on assumptions. Assumptions are dangerous.

12 Chain Related Prompts

Complex work splits into phases. That’s hierarchical decomposition - a fundamental principle of problem-solving.

1. Analysis: "Identify the main performance bottlenecks in this code"
2. Solution: "Propose optimizations for the bottlenecks identified above"
3. Implementation: "Write refactored code implementing optimization #2"
4. Validation: "Explain how to test this refactored code"

Sequential operations produce better results than requesting everything simultaneously. Break down the dragon into manageable pieces.

13 Keep Your Prompts Modular

Build from reusable blocks. Migi templates combine standard components with dropdowns - that’s organizational structure that actually works.

Write {{content_type}} about {{topic}}.

Target audience: {{audience}}
Technical level: {{expertise_level}}
Voice: {{tone}}
Output format: {{format}}
Length: {{word_count}} words

{{additional_context}}

Configure variables:

• {{content_type}}: Single Selection (blog post, technical doc, email, social post)
• {{audience}}: Single Selection (developers, executives, general public)
• {{expertise_level}}: Single Selection (beginner, intermediate, expert)
• {{tone}}: Single Selection (professional, conversational, technical, casual)
• {{format}}: Single Selection (markdown, plain text, HTML)
• {{word_count}}: Single-line Text
• {{topic}} and {{additional_context}}: Multi-line Text

One template. Infinite variations. Dropdowns prevent typos and maintain consistency. That’s competent system design.

Some problems cannot be solved in a single pass. They require orchestration - multiple prompts working in sequence, metadata guiding generation, iterations refining toward precision. This is advanced territory, but it’s where real power lies.

14 Avoid Double Negatives

“Don’t make it not too formal” confuses everyone, including AI systems.

Use direct statements. “Keep the tone conversational” instead of “Don’t use formal language.” Be clear about what you want, not just what you don’t want.

15 Debug Failed Prompts

When output fails, iterate systematically. Treat this like debugging code, because that’s exactly what it is.

1. Identify the gap: What part of the prompt was unclear?
2. Add constraints: What information was missing?
3. Test variations: Rephrase unclear parts
4. Compare results: Which phrasing produces better output?

Locate error. Correct. Test. That’s the method.

Reality Check

AI generates wrong answers confidently. Always verify technical details, code output, factual claims. This is crucial - don’t skip this step.

It’s pattern-matching software. Not truth. Use it to accelerate work, not replace verification. You’re still responsible for the output.

How Migi Templates Eliminate Friction

Every technique here works better without retyping. Friction accumulates, and accumulated friction destroys productivity.

The manual workflow:

1. Remember where that good prompt lives (Notes? Browser? Text file?)
2. Find it
3. Copy it
4. Manually edit variables
5. Hope nothing was missed
6. Paste into ChatGPT

The Migi workflow:

1. Press ⌥+Space
2. Type three letters
3. Fill the form
4. Press Enter

Prompt engineering is iterative. Templates evolve. With Migi, edit the template once. Every future use inherits the improvement. That’s how you build competence that compounds.

The Pattern

Good prompts follow structure:

1. Set role and context
2. Provide clear, structured input
3. Define constraints and requirements
4. Specify output format
5. Show examples when needed
6. Request step-by-step reasoning for complex tasks

This isn’t manipulation. It’s precision instruction for a system that operates on patterns. Respect the architecture of the tool you’re using.

Be specific. Structure input. Define requirements. Verify output.

Save proven prompts as templates with {{variables}}. Use dropdowns for frequent choices. Let the form handle mechanics.

That’s the system. Now use it.