Output Format Mastery: JSON, Tables & Parseable Results

Most prompt failures are not about the model being wrong. They are about the shape being wrong. You ask for "a comparison" and get three paragraphs of prose you cannot parse. You ask for "some options" and get a wall of text where a numbered list belonged. If the next step in your workflow is code that reads the output, loose prose is a bug.

The structured use case in VantagePrompt exists to fix that. It pins the output to a predictable shape — json, markdown, prose, code, table, or list — so the result is reliable, reusable, and machine-parseable. This guide covers when to reach for structured, how shapes map to real downstream needs, and how to get output you can pipe into the next tool without cleanup.

When should I use the structured use case?

Reach for structured whenever something other than a human reads the output, or whenever a human needs to scan it fast. Concretely: you are feeding the result into a script, a spreadsheet, an API call, a config file, or a UI that expects a fixed schema. The structured use case optimizes the prompt around the output schema itself — field definitions, validation rules, and the exact response shape — instead of around tone or narrative.

• You need JSON your code can JSON.parse without a try/catch and a prayer.
• You need a table you can paste into a sheet with columns that line up.
• You need a ranked list a teammate can skim in five seconds.
• You need a code skeleton with a fixed signature, not an essay about the code.

If you are unsure which use case fits your prompt at all, start with the use-case overview guide — structured is one of six textual use cases, and it is the one whose whole job is the output contract.

What are the six output shapes?

VantagePrompt resolves your prompt to one of six output shapes and injects a shape-specific directive that pins how the refined prompt's output format section is filled in. Each shape produces a different skeleton in the optimized prompt:

How does VantagePrompt choose the output shape?

You do not hand-pick the shape with a dropdown. VantagePrompt reads your wording. Comparison and schema language ("compare", "versus", "criteria", "fields", "schema") leans json. Words like "table" or "matrix" force a table. "Write code", a function name, or a language name forces code. "Steps", "checklist", or "options" forces a list. "Top 5", "best", or "give me a list of" leans markdown. Anything with no signal falls back to prose.

The practical takeaway: say the shape out loud in your raw input. The clearer your wording, the more deterministic the shape. "Return a JSON object with one entry per library" is unambiguous; "tell me about some libraries" is not.

This page is about which shape you get. Getting a good result inside a shape is a separate craft with separate failure modes — a JSON response that parses every time, a table whose rows agree about their columns, markdown that lands cleanly in the page it is pasted into, code that runs — and each of the four has its own guide below.

What does a structured prompt look like end to end?

Suppose you want machine-readable data comparing three HTTP clients. A vague prompt invites prose. Here is the rough input you would paste into the structured use case:

Compare axios, ky, and native fetch as a JSON object. For each library
include: name, bundle_size_kb (number), supports_interceptors (boolean),
and a one-line note. I need to parse this in a script.

Structured wording ("compare", "JSON object", explicit fields with types) resolves the shape to json. The optimized prompt VantagePrompt produces will carry an output format section that pins a concrete schema for the downstream model to follow — names, types, and an example — so the answer comes back parseable:

{
  "libraries": [
    {
      "name": "axios",
      "bundle_size_kb": 13,
      "supports_interceptors": true,
      "note": "Batteries-included, larger footprint."
    }
  ]
}

The optimized prompt is XML-structured (that is how all six textual use cases are built), but the answer the downstream model returns conforms to the JSON schema pinned in the output format section. Note the distinction: VantagePrompt produces the prompt, not the final answer. The shape directive flows downstream so that whichever model you paste the prompt into honors the schema.

Do I still need to validate the output myself?

When the resolved shape is json, code, or table, VantagePrompt also folds a shape-aware self-check into the optimized prompt — for example, that JSON validates and parses, that code is runnable as written, or that every table row has a consistent column count. That self-check raises the odds the downstream output is clean on the first pass. Still, treat any machine-bound output as untrusted at the boundary: parse it, validate the fields, and handle the failure case in your own code. A schema in the prompt reduces drift; it does not replace validation in your pipeline.

One scope note: getting parseable structure is about format, not factual freshness. If your structured prompt also needs current, verifiable facts inside those fields, grounding with web search is a separate lever — see the grounding guide for when that helps.