Before you read anything: make a call
A platform asks you to write a demonstration response to this prompt:
“Summarize the Q3 revenue results for two products, and flag any caveat a reader should know about.”
Here are two responses. Which one would a model learn more from?
Response A:
The results are: Product A: Revenue: 0.8M, Growth: -3%
Note: these figures are from Q3 only.
Response B:
## Q3 Revenue Results
| Product | Revenue | Growth |
|-----------|---------|--------|
| Product A | $1.2M | +12% |
| Product B | $0.8M | -3% |
**Note:** These figures reflect Q3 only and are not annualized.Which is the better training signal?
See the answer
Response B. The gap matters more than it looks.
Response A carries all the right information. To a model it reads as ambiguous noise. The figures run together as colon-separated text with no table behind them, so nothing marks Product A and Product B as two rows of the same thing. The caveat sits in a line of plain text that looks identical to every other line.
Response B carries structure the model can learn. The heading marks a section. The pipe table becomes a real table with columns that line up. The bold label sets the caveat apart from the prose around it.
Train a model on Response A and it learns that shapeless output is fine. Train it on Response B and it learns to produce output a reader and a machine can both follow.
Formatting is part of what the model learns from you.
This module teaches you to inspect formatting, and it assumes no coding background
Everything below is about reading output and deciding whether it holds up. You will see code samples in these examples, and your job is to look at how they are wrapped and labeled rather than to judge what they do or to write any of your own. Spotting a missing quotation mark takes no more programming knowledge than spotting a missing full stop.
Two of these checks lean on a habit worth naming early. Some AI output borrows small pieces of Python syntax where a strict data format is required, and those pieces break things silently. You will learn the three or four shapes this takes and how to catch them on sight.
Every response you touch teaches the model how to format
Every demonstration response you write, and every AI response you evaluate, teaches the model something about what good output looks like. When expert demonstrations use real headings for sections and real code blocks for code, the model learns that pattern. When demonstrations are inconsistent, the model learns the inconsistency and reproduces it.
The failures that matter most are the silent ones. Markdown that reads fine as raw text but collapses when rendered, and data that passes a quick visual scan but breaks the system reading it, both slip through review unless someone is looking for them. That someone is you.
Platforms enforce a narrow slice of Markdown
You do not need the full specification. Three checks cover the overwhelming majority of what review turns up.
Headings have to be headings
A heading starts with one or more hash marks, and the count sets the level:
# Page title
## Major section
### SubsectionThe common mistake is a bold label standing in for a heading, like **Summary** at the top of a section. Rendered, the two look close enough to pass a glance. Underneath, a bold label creates no section at all, so it never appears in a table of contents and no tool reading the document can find it. When the task asks for sections, the response needs headings.
Code has to be marked as code
Any code in a response belongs inside a fenced block with a language label on the opening fence:
```python
def hello(name):
return f"Hello, {name}"
```You are checking two things and neither requires reading the code. Is the sample wrapped in a block, and does the opening fence name the language. Code pasted as loose text, or wrapped without a label, is a weaker signal even when the code itself is perfect. Short references inside a sentence use single backticks instead, as in “use the groupby() method here.”
Tables need their separator row
A Markdown table takes a header row, a row of dashes, then the data:
| Column A | Column B |
|----------|----------|
| Value 1 | Value 2 |Drop the row of dashes and the whole table stops being a table. It falls through as plain text stuffed with pipe characters, with no error to warn anyone. Any time a response contains a table, confirm the dashes are there.
Try It: is a bold label the same as a heading?
A task instruction says: “Write a structured response with three sections: Summary, Key Findings, and Recommendations.” The AI produces:
Summary The analysis covers Q3 performance across five product lines…
Key Findings Revenue increased 12% year-over-year…
Recommendations Prioritize investment in product lines 2 and 4…
Is this a formatting violation or a style choice you should let through?
See answer
This is a formatting violation.
The task asks for sections, and a section in a Markdown document is made with a heading. Bold text produces something that resembles one on screen and behaves nothing like one underneath. Three consequences follow.
Nothing can find the sections. Headings get picked up by tables of contents, by screen readers, and by any tool that processes the document. A bold line is visual weight and nothing else.
The model learns the substitution. If this response becomes training data, the model learns that a bold line is how you mark a section, and it will produce bold labels wherever real headings are expected.
The structure the task asked for was never delivered. The response looks compliant and fails the instruction.
The correct format:
## Summary
...
## Key Findings
...
## Recommendations
...One exception is worth knowing. If the style guide for the task explicitly says to use bold labels rather than headings, then bold is what compliance looks like. Absent that instruction, treat it as an error.
Invalid data breaks everything downstream of it
JSON is the format platforms use for structured output, and it is strict in ways that plain writing is not. One wrong character makes the whole thing unreadable to the system consuming it, and there is no warning along the way. The system simply fails.
Three checks cover nearly everything you will meet.
Quotes. Every key and every text value sits inside double quotes. {name: "Alice"} fails because the key is bare. {'name': 'Alice'} fails because single quotes are not JSON. {"name": "Alice"} is right.
Values. True and false are written true and false, lowercase and unquoted. An empty value is null. The capitalized True, False, and None come from Python, and a strict parser rejects all three. This is a rule of the format rather than a preference, so there is no version of the file where True is tolerated.
Punctuation. No comma after the last item in a list or object. No comments anywhere, in any style. Comments are ordinary in programming languages and they break JSON without exception, so a // in a data response is always a flag.
Try It: how many errors are in this data?
You are reviewing a response that was asked to return a structured user profile. It produced:
{
'name': 'Jordan Lee',
'age': 29,
'active': True,
'tags': ['finance', 'analyst'],
}Find every error. How many are there?
See answer
There are three.
1. Single quotes where double quotes belong, on every key and every text value. JSON wants "name", "Jordan Lee", "finance".
2. A capitalized True. JSON booleans are lowercase. True is Python and it stops the parser dead.
3. A trailing comma after the tags line, sitting just before the closing brace. Nothing may follow the last value.
Corrected:
{
"name": "Jordan Lee",
"age": 29,
"active": true,
"tags": ["finance", "analyst"]
}The mental checklist is short enough to run from memory every time: double quotes throughout, lowercase true and false and null, no trailing comma, no comments.
Tool-use responses get checked the same way
Some tasks ask the AI to produce a structured instruction that another system then acts on. It looks like this:
{
"tool": "search_database",
"parameters": {
"query": "annual revenue 2023",
"filters": {
"industry": "technology"
}
}
}Review it with the same three checks, plus two more that read off the task instructions rather than the format. Does the tool name match one the task offered, and is every parameter the task requires present. Nesting adds no new rules, so a structure inside a structure gets the same treatment as a flat one.
Try It: classify the failure
A task requires a response in this shape: a result that holds text or nothing, and a success that holds true or false. The AI returns:
{"result": None, "success": True}What is wrong, and is it a style issue or a correctness error?
See answer
This is a correctness error, and it fails twice.
None is Python, and JSON writes an empty value as null. A parser hits None, finds no such thing in the format, and stops. Whatever waited on this response gets nothing.
True is Python, and JSON writes true. Same outcome.
Corrected:
{"result": null, "success": true}There is no reading of this where the response is merely informal. The format permits null and true, and it permits nothing else in their place, so the error class is “invalid” rather than “close enough.” When a task asks for structured output, run the three checks over it before you accept it as valid.
Markdown and JSON flashcards
- Your job here is inspection. Every check in this module is something you can run by looking at a response. None of it asks you to write code, and the code samples you meet are there to be checked for wrapping and labeling rather than understood line by line.
- Formatting teaches the model. Inconsistent structure in a demonstration response trains the model to reproduce that inconsistency, which is why a bold label standing in for a heading is worth flagging rather than waving through.
# marks a heading, and the number of hash marks sets the level. A bold label does not create a real section, so no tool reading the document can find it.
Wrap code in a fenced block with a language label on the opening fence. Code pasted as loose text is a weaker signal even when it is correct.
A table needs a header row, a row of dashes, then the data. Drop the dashes and the table falls through as plain text full of pipe characters. No error appears.
Every key and text value sits inside double quotes. {name: "Alice"} fails because the key is bare. Single quotes fail the same way.
JSON writes true, false, and null in lowercase. Python's True, False, and None come from a different language, and a parser rejects all three.
No comma follows the last item in a list or object. No comments exist in JSON at all, so a // in a response always breaks it.
- Where to go next: Final Practice Simulation puts data auditing next to nine other task types with no labels telling you which is which. If you want to go further and evaluate what code actually does rather than just check its formatting, that’s a separate skill covered in the Technical track, starting with Python for AI Training.
