Lesson 6 of 30

Prompt Engineering Fundamentals

Q: A feature that summarizes user feedback into a fixed JSON shape works most of the time but occasionally returns inconsistent formatting. How would you approach fixing this through the prompt itself?

A strong answer covers: Identifies that the prompt currently under-constrains the output — asks what specifically is ambiguous rather than jumping to 'use a bigger model'; Proposes adding explicit output-format constraints and/or 1-2 few-shot examples showing the exact desired shape; Frames this as iterative: test against real/representative inputs, observe where formatting breaks, tighten the prompt to close that specific gap; Recognizes that inconsistency, not an outright error, is the expected failure mode of an under-specified prompt.

A vague prompt gets a vague, inconsistent answer for a specific reason: the model has no signal narrowing what a good response looks like. Prompt engineering is the discipline of giving it that signal on purpose.

12 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 3

Why does a vague prompt tend to produce inconsistent results across repeated runs rather than a single, clearly wrong answer?

The prompt leaves the response space unconstrained, so the model fills the gap differently each timeThe model deliberately randomizes vague prompts to appear more creativeVague prompts trigger a fallback mode that always returns a generic error

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Prompt Engineering Fundamentals

What interviewers actually ask about this, and what a strong answer has to cover.

A feature that summarizes user feedback into a fixed JSON shape works most of the time but occasionally returns inconsistent formatting. How would you approach fixing this through the prompt itself?

A strong answer covers

Identifies that the prompt currently under-constrains the output — asks what specifically is ambiguous rather than jumping to 'use a bigger model'
Proposes adding explicit output-format constraints and/or 1-2 few-shot examples showing the exact desired shape
Frames this as iterative: test against real/representative inputs, observe where formatting breaks, tighten the prompt to close that specific gap
Recognizes that inconsistency, not an outright error, is the expected failure mode of an under-specified prompt

Likely follow-ups

Why might adding a concrete example be more effective here than adding more adjectives like 'be precise' or 'be consistent' to the instructions?
If tightening the prompt doesn't fully close the gap, what's a defensive step you'd add downstream of the model call itself?

Practice these with the AI interviewer →

The plain-language idea

A large language model doesn't "understand" what you want the way a coworker does — it predicts the most statistically plausible continuation of the text you gave it. That means the prompt isn't a request, it's the entire specification. Everything the model has to go on is what's actually in the text: the task, the constraints, the shape of a good answer. Leave any of that out and the model doesn't fail loudly — it fills the gap with whatever's statistically common, which is why vague prompts don't produce wrong answers so much as inconsistent ones: run the same vague prompt five times and you'll get five differently-shaped responses, because nothing in the prompt narrowed the response space down to one shape.

Three techniques do most of the narrowing:

Clear task framing — state the task, the constraints, and any context the model needs, instead of assuming intent carries over from a conversation the model can't see.
Few-shot examples — showing the model 2-3 examples of the exact input/output shape you want. This is often more reliable than describing the shape in words, because the model is literally continuing a pattern instead of inferring a description of one.
Explicit output format — telling the model exactly what shape the response should take (a bulleted list, a specific JSON structure, a single sentence) instead of hoping it infers the format you had in mind.

None of this is a one-shot art where you write the perfect prompt and move on. Treat it as an engineering discipline: write a prompt, run it against real (or realistic) inputs, look at where the output goes wrong or gets inconsistent, and tighten the prompt to close that specific gap. The prompt that works on your first three test cases and breaks on the fourth is the normal case, not a failure — that's what iteration is for.

See it in a real thing: same task, two prompts

Vague:
"Summarize this bug report."

Engineered:
"Summarize this bug report in exactly 2 sentences: the first states
the observed behavior, the second states the expected behavior. Do
not include severity, steps to reproduce, or a suggested fix.

Example input: 'Clicking submit twice creates two orders. Should only
create one.'
Example output: 'Clicking submit twice creates two duplicate orders.
The expected behavior is that only one order is created regardless
of how many times submit is clicked.'

Now summarize: <bug report text>"

The vague version leaves "summarize" undefined — length, structure, and what to include or exclude are all up for grabs, so the model guesses, and different bug reports get summarized in different shapes even when you want consistency across a whole backlog. The engineered version pins down length, structure, and scope explicitly, and the one-shot example shows the exact input/output pattern instead of just describing it. This isn't a toy difference: it's the same distinction between lib/ai/prompts/tutor.ts giving the tutor persona a tight scope (answer only from the provided lesson context) versus letting it answer however it statistically tends to, and lib/ai/prompts/interview.ts demanding strict JSON output rather than hoping the grading model happens to format its verdict usefully.

What people usually miss

Watch out

Vague prompts don't fail — they succeed inconsistently. There's rarely an error; there's a different-shaped answer every time, which is often harder to catch in production than an outright failure.
Few-shot examples teach shape, not just content. Even one example dramatically narrows formatting, tone, and length — the model is pattern-continuing, not just reading a spec.
"Be specific" is itself vague advice. The fix isn't a vaguer instruction to be less vague — it's a concrete constraint: a length, a format, a boundary on what to exclude.
Prompt engineering has a feedback loop, not a finish line. Treat a prompt as a first draft you test against real inputs and revise, the same way you'd treat any other piece of code with edge cases.
A longer prompt isn't automatically a better one. Padding a prompt with instructions that don't narrow the actual ambiguity just adds noise the model has to weigh against everything else.

Why this matters in interviews

"How would you debug an LLM feature that gives inconsistent answers to similar inputs?" is a real question, and the answer that shows depth is diagnosing which specific ambiguity the prompt leaves open, not just reaching for "try a better model."