Structured Output Requests

Structured output prompting is the technique of explicitly specifying the format, schema, and organization of the AI's response. This is essential when you're using AI output in workflows, feeding it into code, or need consistent formatting across multiple generations.

Why Structure Matters

Without format instructions, AI models make their own choices — and those choices are inconsistent. One response might be a numbered list, the next a series of paragraphs, the third a table. For any workflow that requires predictable output, this is a problem.

Structured output prompting solves this completely.

The Spectrum of Structured Outputs

Level 1 — Basic formatting:

"Respond using this exact format:
**Recommendation:** [one sentence]
**Reasoning:** [two sentences]
**Next step:** [one action]"

Level 2 — Markdown structure:

"Structure your response as:
## Summary (2-3 sentences)
## Key Findings
- Finding 1
- Finding 2
- Finding 3
## Recommended Actions
1. [Action]
2. [Action]
## Risks to Consider"

Level 3 — JSON output (for developers):

"Analyze this product review and return ONLY valid JSON
with this exact schema — no other text:

{
  'sentiment': 'positive' | 'neutral' | 'negative',
  'score': number,  // 1-10
  'topics': string[],  // max 5
  'strengths': string[],  // max 3
  'weaknesses': string[],  // max 3
  'is_verified_purchase': boolean | null,
  'summary': string  // max 50 words
}

Review: [paste review text]"

Structured Output for Data Extraction

One of the most valuable applications — turning unstructured text into structured data:

Extract all events from this text and return as a JSON array:

[{
  'event_name': string,
  'date': 'YYYY-MM-DD or null if unclear',
  'location': string or null,
  'attendees': string[] or null,
  'action_required': boolean,
  'deadline': 'YYYY-MM-DD or null'
}]

Text: "The team standup is every Monday. Sarah needs the
Q1 report by March 31st. Board meeting on April 15th in
Conference Room A. Client demo with TechCorp TBD."

Markdown Tables

Tables are one of the most useful formats — clear, scannable, and easy to copy:

Compare [Topic A] vs [Topic B] in a markdown table with these columns:
| Feature | [Topic A] | [Topic B] | Winner |
|---|---|---|---|

Include 8-10 rows covering the most important dimensions.
End with a one-paragraph verdict.

Controlling Output Length

Precise length control is part of structured output:

Instruction	Effect
"In exactly 3 bullet points"	Hard limit on count
"In under 100 words"	Hard word limit
"In one sentence"	Maximum conciseness
"Write 500 words"	Approximate length target
"Write between 400-600 words"	Range with flexibility

Important: AI models are better at "under X words" constraints than "exactly X words." For precise word counts, verify and ask for revision.

Nested Structure for Complex Documents

"Create a project plan using this nested structure:

# Project Name
**Goal:** [one sentence]
**Timeline:** [start date] to [end date]
**Owner:** [name]

## Phase 1: [Name] (Weeks 1-[N])
### Deliverables
- [ ] [Item]
### Dependencies
- [Item]
### Success Criteria
- [Item]

[Repeat Phase structure for each phase]

## Risks
| Risk | Probability | Impact | Mitigation |

## Budget Summary
| Category | Estimated Cost |"

The "Return ONLY" Pattern

When feeding AI output into code or other systems, end your prompt with explicit instructions:

[Your full prompt here]

Return ONLY the [JSON/CSV/code/table]. Do not include any explanation,
preamble, or text outside the requested format. The output should be
directly parseable/usable without modification.

This prevents the model from adding "Here is the requested JSON:" before the output, which would break JSON parsing.

Combining Techniques

The most powerful structured output prompts combine:

A clear role (establishes expertise)
Specific task description (what to do)
Explicit schema/format (how to present it)
Examples (few-shot anchoring)
"Return ONLY" instruction (enforces clean output)

Practice

Take one task you do regularly with AI and redesign the prompt to produce perfectly structured output. Build a template you can reuse. Structured templates are force multipliers — you write them once and benefit from them thousands of times.