Bullets, Lists, and Outlines — Make Your Model Actually Follow the Plan

Hook: Why your model keeps giving paragraph soup

Ever prompt a model for a crisp checklist and get back an essay about the emotional journey of a checklist instead? Welcome to the thrilling world of output structuring. You already learned when to give examples (zero, one, few-shot), how order affects behavior, and why selection bias will sabotage neat outputs. Now we learn the next epic skill: making the model spit out the exact shape you want — bullet lists, numbered steps, outlines, nested trees, CSV, JSON — without the interpretive theater.

Structuring outputs is the difference between getting a usable API response and getting a novella you now have to parse in Python. One is efficient. The other deserves an agent name.

---

What this is and why it matters (quick)

Structuring outputs means specifying the precise format and organization for model responses so downstream systems, humans, or graders can consume them reliably. This reduces ambiguity, cuts post-processing, and improves reproducibility when combined with your few-shot strategies.

Imagine you're building a pipeline: Prompt -> Model -> Extractor -> Action. If the prompt doesn't nail the list or outline style, the extractor fails. That's wasted tokens and developer tears.

---

Patterns and when to use them

1) Bulleted lists (unordered)

• Best when the order doesn't matter and you want concise items.
• Use for: features, pros/cons, ideas, non-ranked tasks.

Prompt tip: Ask for a bullet list and give one exemplar bullet in few-shot if tone matters.

Example prompt snippet:

Return an unordered list of 5 concise features, each 6 words max:
- Feature sample: "fast inference on small models"

Why it works: the sample sets rhythm and length. If you skip sample, depend on clear constraints (length, count).

2) Numbered lists (ordered)

1. Use when sequence matters.
2. Great for step-by-step instructions.
3. The model tends to honor order more reliably when you number examples in few-shot.

Prompt tip: For multi-step processes, explicitly request numbers and cardinality: "Return steps 1-6." That clamps the decision boundary.

3) Outlines (headings + nested bullets)

• Use for hierarchical content: plans, essays, multi-part designs.
• Ask for heading levels (e.g., I, A, 1 or #, ##, ###) to control parsing.

Example:

Return an outline with 3 sections. Use roman numerals for sections, uppercase letters for subsections, and numbers for points.

Hierarchy reduces ambiguity and helps automated parsers map nodes to actions.

4) Tables

• Use when you need structured comparisons: columns map to fields.
• Prefer CSV or Markdown tables depending on downstream reader.

Table vs JSON: table = human-readable; JSON = machine-native.

5) JSON / CSV / YAML

• When you need strict schema. Always provide a minimal schema example in the prompt.

Example JSON template in prompt:

Return a JSON array of objects like:
[ { id: 1, title: "", priority: "low|med|high" } ]

If you need exact types or keys, show them in a one-shot example to avoid key drift.

---

Practical rules: concise, explicit, and demonstrated

1. Be explicit about the container. Tell the model Return a markdown bulleted list or Return valid JSON array.
2. Clamp the cardinality. Say how many items. Order effects matter here; if you want 4 items, ask for 4.
3. Give an exemplar when style matters. Few-shot with 1 example often changes format reliably. Remember earlier: exemplars can create selection bias, so pick a representative example, not an extreme one.
4. Limit verbosity per item. Use character/word limits if you want terse bullets.
5. Use separators or tokens. If you need parsing safety, ask for ---BEGIN--- and ---END--- wrappers.
6. Guard against hallucinated list items. Ask the model to justify items or provide sources if accuracy is critical.

---

Order effects redux (linking to previous topic)

You learned how few-shot examples influence decision boundaries. The same is true for list formats: the order and phrasing of your exemplar bullets can nudge the model into producing hierarchical vs flat lists, or into ranking importance vs presenting options neutrally.

Ask yourself: did your exemplar imply ranking? If so, the model will likely infer an ordinal scale. If you want a neutral unordered list, show an unordered example.

---

Pitfalls and how to dodge them

• Selection bias in examples: If all your examples are long, the model will produce long bullets. Mix exemplar lengths if you need variety. (Tie-back to Avoiding Selection Bias.)
• Ambiguous instructions: "List steps to do X" invites a variable number. Clamp it.
• Extra commentary: Models like explaining their choices. If you want only data, specify "No commentary, only the list."
• Token waste: Huge nested outlines can use many tokens. If you only need keys, request a shallow outline.

---

Bite-sized templates you can copy-paste

1. Bullet list, exact count, terse:

Return a markdown unordered list of exactly 5 items. Each item max 8 words. No intro or commentary.

2. Step-by-step numbered process:

Return a numbered list of 6 steps to accomplish X. Each step one sentence. Include no extra text.

3. JSON with schema:

Return a JSON array of objects with keys: id (int), task (string), priority ("low"|"med"|"high"). Example format: [{id:1,task:"",priority:""}]

---

Quick table: when to use which format

Use case	Format	Why
Human checklist	Bullets	Fast scanning, flexible order
Procedure	Numbered list	Clarity of sequence
Structured data	JSON/CSV	Easy programmatic parsing
Comparative summary	Table	Compact side-by-side

---

Closing — TL;DR and a tiny motivational rant

• Be explicit about the container, the count, and the verbosity.
• Use a one-shot example to lock style when necessary, but avoid biased exemplars.
• For pipelines, prefer machine formats (JSON/CSV) and provide a schema.

Final thought: teaching a model to speak your format is like teaching someone to fold a fitted sheet. It seems mystical at first, but with a clear method and one or two good demonstrations, it stops being chaos and starts being reliable craftsmanship.

Go forth. Make your models tidy, parsable, and merciful to your downstream scripts.