How do I get ChatGPT to follow the format I asked for?

Published 7 September 2026 by PrecisionPrompts. Every figure on this page is a direct count over the 455 prompts we publish, measured on that date.

Name the parts of the output instead of describing its shape. Across the 455 prompts we publish, 276 specify the answer as a numbered list of labelled parts, and only 16 contain an instruction of the "format it as" kind at all. The format is not something you ask for. It is something you write down and hand over.

The failure people report is always the same. The first answer comes back in a reasonable shape, the next one comes back in a different reasonable shape, and neither is the shape they wanted. That is not the model ignoring an instruction. It is the model filling in a decision that was never made. "Give me a structured breakdown" leaves the section count, the section names and the contents of each section open, so all three get chosen fresh every run.

What follows is a census of our own library: how 455 prompts that people paid for and kept using actually pin an output down. It describes a house style that survived contact with buyers. It is not a controlled test of whether one method beats another, and where that limit matters we say so.

What do working prompts do instead of asking for a format?

They enumerate the deliverable. 276 of our 455 prompts specify the output as a numbered list where each item names one part of the answer. The instruction people reach for first, some variation of "format it as" or "present this as", appears in only 16 prompts across the entire library.

Read the top and the bottom of that table together and the thesis falls out. The methods that dominate all do the same thing: they remove a decision by making it in advance. The methods that barely appear are the ones that describe a quality of the output and leave the model to work out what satisfies it.

What does a specified output actually look like?

Here is one from our Ecommerce pack, complete. It runs 1,070 characters, close to the library median, and it contains no formatting instruction of any kind.

Write copy that frames the price of [PRODUCT NAME] as a good deal WITHOUT
discounting.

Product: [DESCRIPTION].
Price: [PRICE].
Target customer: [PERSONA].
Competitive alternatives: [WHAT THEY'D BUY INSTEAD AND AT WHAT PRICE].

Generate 5 price-framing strategies, each as a ready-to-use copy block
(2-3 sentences):

1. **Cost-per-use**: Break the price down by expected usage
2. **Comparison anchor**: Compare to what they're currently spending on the
   inferior alternative
3. **Opportunity cost**: What does NOT solving this problem cost them?
4. **Category reframe**: Position the product in a more expensive category
5. **Investment language**: Frame as an investment with a return, not an expense

For each, note where it works best (product page, ad, email, checkout) and
which customer mindset it targets (bargain-hunter, quality-seeker, skeptic).

Count what has been decided before the model starts. The number of outputs is 5. Each one has a name. Each one has a length, which is 2 to 3 sentences. Each one has two mandatory annotations. Nothing is left for the model to choose except the words, which is the only part you actually wanted from it.

Note also what the labels do. "Cost-per-use" is not decoration. It makes the fifth item checkable against the first, so you can see at a glance whether the model produced five different strategies or one strategy phrased five ways. 149 of the 276 enumerated prompts label their items this way, and 108 use bold on the first item specifically.

How many parts should I ask for?

Between four and seven. The distribution is tight and it does not run to the extremes people expect.

Both tails are informative. Under four parts, the specification usually is not doing its job, because a two item answer leaves most of the content unallocated and the model decides what belongs in each half. Over eight, the answer spreads: a fixed response budget gets divided among more headings, and each one thins to a couple of sentences. If you want depth on ten things, ask for five and run the prompt twice rather than asking for ten once.

One more number worth having. Prompts that enumerate their output run longer than prompts that do not, with a median of 1,259 characters against 885. That is the cost of the method, and it comes to about four extra lines.

Where in the prompt does the format specification go?

In the middle. After the inputs, before the rules.

Be careful with the start figure on its own, because part of it is mechanical: a list of five items takes up room, so it cannot begin at 90 percent of the way through. The span is the honest measure, and the span says the specification is roughly half the prompt and it sits between the two other blocks.

That ordering has a reason behind it. The inputs come first because the list refers to them. The list comes next because it is the thing being built. The prohibitions come last because a ban is a modifier, and it needs the thing it modifies to already exist on the page. Put the deliverable list first, ahead of your inputs, and every item in it points at variables the model has not been given yet.

What if the output is one piece of writing, not a list of parts?

Then cap its length and name what it opens and closes with. Our Real Estate pack is the cleanest example of this in the library, and it is a near perfect inversion of everything above.

Every Real Estate prompt caps length and almost none of them enumerate, because the deliverable is a single continuous listing description. There is nothing to enumerate. So the specification moves to the only dimensions a continuous artifact has: how long it runs, what it leads with, and what it ends on. "Keep it under 250 words. Lead with the single most compelling feature." "Keep to 200 words. End with clear application instructions."

The image pack goes further and specifies nothing about output shape at all, because a prompt that describes the picture already is the specification. That is worth stating as the general rule rather than as an exception: the specification names the dimensions the output actually has. A report has parts, so you list them. A listing has a length and two ends, so you fix those. A picture has contents, so you describe them.

Across the whole library, 183 of 455 prompts carry a length cap: 132 in words, 76 in sentences and 21 in characters. Characters show up almost entirely where a platform enforces one, such as a subject line or a meta description.

How do I make ChatGPT output a table?

Draw the header row and let the model fill it in. Only 29 prompts in the library ask for a table or named columns, and 8 of them include the pipe delimited header directly in the prompt body, like this one from the Legal Professional pack:

For each requirement, provide:
| Requirement | Regulation | Action Required | Deadline/Frequency | Risk Level | Status |
|-------------|-----------|-----------------|--------------------|------------|--------|

Also include:
1. **Documentation requirements**: What records must be maintained and for how long
2. **Filing/registration obligations**: State-by-state registrations required
3. **Common violations**: The 5 most frequently cited violations in this industry

Asking for "a table" leaves the column count, the column order and the column names all open, which is three fresh decisions on every run and the reason two runs of the same prompt produce tables you cannot paste into the same spreadsheet. A drawn header closes all three at once. It is the same principle as the numbered list, applied sideways.

Notice the second half of that example as well. The table handles the repeating rows, and a numbered list handles the parts that appear once. Mixing the two is normal: 58 of the 276 enumerated prompts nest sub-bullets inside their list items for exactly this reason.

Should I ask for JSON or markdown?

Only when a program is reading the output. In all 455 prompts we publish, JSON appears once, CSV appears once, and markdown is never named. These prompts are written for people who paste the result into a document, a listing, an email or a slide, and for that reader a machine readable wrapper is a step backwards.

When you do need JSON, the method above gets stronger rather than weaker: give a filled example object instead of a description of the schema. A description of a schema is a shape you are asking for. An example object is the parts, named, with their types visible. The failure mode is identical to the one this whole page is about.

Does "no preamble" work?

It works, and it is a patch. One prompt out of 455 uses it.

The preamble is what a model produces when it has a task and no output specification, because the gap gets filled with a narration of what it is about to do. If the answer is required to open with a section named "Cost-per-use", there is no gap. So the instruction stops being necessary rather than stops being effective, which is why prompts written by people who do this daily almost never carry it. Keep it for a short throwaway prompt where you did not specify a shape. Reach for it repeatedly and the real problem is upstream.

A prompt that turns the format you want into a specification

Paste in the format request that keeps not sticking. This converts it into an enumerated deliverable, and it will tell you which parts of your request could not be converted, which is usually the informative bit.

Here is how I keep asking for output, and I keep getting a different shape:
[PASTE YOUR REQUEST, e.g. "give me a structured competitor breakdown"]

Turn it into an output specification. Produce:

1. **Part list**: between 4 and 7 numbered parts, each with a short label and
   one line saying what goes in it
2. **Sizing**: for each part, either a sentence count or a word count
3. **Repeating structure**: if any part repeats per item, write it as
   "For each [item], provide:" with its own sub-list, or as a table header row
   with the columns named
4. **Leftovers**: anything in my request you could not turn into a named part,
   and what you would need to know to convert it

Then output the specification as a block I can paste at the end of a prompt.
Do not write the answer itself.

The last two lines of that block are the page's own method turned on itself. "Do not write the answer itself" is a prohibition, so it sits at the end, and everything above it names a part rather than describing a shape.

What this measures, and what it does not

These are counts over prompts we publish and believe work. They describe a house style that has survived contact with buyers, and they are not a controlled comparison of one specification method against another. Nothing here should be read as "an enumerated list produced a better answer than a described format", because we did not run that test. Where we have run a controlled test, on a single build with the markers fixed in advance, it is reported separately in does telling ChatGPT to act as an expert actually work, including the part of the result that went against us.

The detection is a pattern match over each prompt's text and it has one known blind spot: a prompt that specifies its output entirely in prose, with no numbered list, no table and no length figure, is counted as having no specification. 101 prompts fall into that bucket. 28 of them are the whole image pack, where the description of the picture is the specification, leaving 73 text prompts that either specify loosely or not at all. A different reasonable rule would move these totals by a few percent, not by an order of magnitude.

Questions people ask about output formats