CCAR-F practice questions: Prompt engineering.

You need a response in a strict JSON shape that downstream code will parse. Which approach is most reliable?

• Lower the temperature to zero so the formatting is deterministic across runs
• Define the shape as a tool input schema, or use structured outputs, so the model must conform
• Ask for JSON in the user message and add a note that any text outside the object will break the parser
• Prefill the assistant turn with an opening brace and stop at the closing brace

A prompt includes a 40-page contract and one question about it. Where should the question go?

• In the system prompt, with the contract alone in the user turn, so instruction and content are separated
• Split across several user turns, one section of the contract per turn, with the question at the end
• At the end of the user message, after the contract, with the contract clearly delimited by tags
• At the top of the user message, before the contract, so the model knows what to look for while it reads

Output format keeps drifting despite detailed instructions. What usually fixes it fastest?

• Remove the system prompt and put the instructions in the user turn, closer to the task
• Add two or three high-quality examples of the exact format, wrapped in clearly labeled tags
• Reduce max_tokens so the model has no room to add anything beyond the required format
• Restate the format instruction at both the start and the end of the prompt so it is harder for the model to miss

When is extended thinking the wrong tool?

• Multi-step planning over a set of requirements that conflict with one another
• Debugging a subtle logic error across several interacting functions
• Weighing the trade-offs between two candidate system architectures
• A high-volume yes/no classifier where per-request cost and latency dominate

A system prompt says 'be helpful' and the outputs vary wildly in format. The highest-leverage change is:

• Adding 'be concise and consistent' to the system prompt
• Lowering the temperature so the formatting varies less
• Stating the exact output format with a short example
• Adding a persona so the model has a stable voice to write in

You need the model to reason through a multi-step pricing rule before answering. Which technique?

• Split the request across two turns, one for the rule and one for the answer
• Provide several unrelated worked examples so the model learns to be careful
• Ask for the final price only, with a rule that the answer must be a single number
• Ask it to work through the steps before answering, or enable extended thinking for the hard cases

Which is the best use of XML-style tags in a prompt?

• Separating instructions, reference documents, and examples so the model does not confuse them
• Signalling to the API which sections of the prompt are eligible for prompt caching
• Marking the parts of the prompt the model may skip when the context is nearly full
• Replacing the system prompt with a tagged block at the top of the user turn

You want responses to begin with a JSON object and nothing else. Which technique reduces preamble?

• Adding 'respond with JSON only' as the last line of the system prompt
• Prefilling the assistant turn with the opening brace
• Setting stop_sequences to a closing brace so the model ends at the object
• Setting temperature to zero so the model picks the most likely opening

The model keeps inventing a citation when a source is missing. Which instruction helps most?

• 'Keep answers short so there is less room for unsupported claims to appear'
• 'If no source in the provided material supports the claim, say so instead of citing'
• 'Cite at least one source for every claim, using the provided material where possible'
• 'Use your own knowledge to fill gaps when the provided material does not cover a claim'

Which examples make few-shot prompting work best?

• A few examples that closely match the target task and format, including a tricky edge case
• Examples drawn from a different but similar domain to avoid overfitting to the test set
• Examples that deliberately contain errors, with corrections, so the model learns what to avoid
• A large set of loosely related examples so the model sees the range of possible inputs

A prompt for summarizing meeting notes should also flag decisions and owners. Where do those requirements go?

• Stated explicitly as required output sections, with an example
• Implicitly, since a well-written summary includes decisions and owners
• In the system prompt as a general instruction to 'capture action items'
• In a second call after the summary, so each call has one job

What is the role of the system prompt compared with the user turn?

• The system prompt is where the model name and version are declared; the user turn holds everything else in the request
• The system prompt sets standing role, rules, and format; the user turn carries the specific task and material
• The system prompt carries the material to analyze; the user turn carries the standing rules
• They are interchangeable; the model concatenates them before reading either

A prompt includes ten rules and the model follows nine. Which change is most effective?

• Move the missed rule near the task, restate it as a concrete check, and add an example of compliance
• Delete the nine rules that already work, so the missed one gets the model's full attention
• Move the missed rule into a tool description so the model reads it when it acts
• Repeat the missed rule in capitals at the top and bottom of the system prompt

When should you ask the model to quote the relevant passage before answering a question about a long document?

• Only when streaming, since the quote arrives first and gives the user something to read while the answer generates
• When the answer is a single fact, since longer answers already cite their sources
• When accuracy on the document matters, since grounding in quotes reduces invented details
• Only for documents short enough that the quotes do not add much to the output

A prompt asks for 'a short answer' and gets three paragraphs. What fixes it reliably?

• Reduce temperature to zero so the model chooses the most likely, usually shorter, phrasing
• Specify the length in sentences or words and show an example of the right length
• Set max_tokens to a small value so the response cannot run to three paragraphs
• Add 'be brief' to both the system prompt and the user message

Which is a sign that a task needs extended thinking rather than a normal response?

• The prompt is long and contains several reference documents the model has to read through
• The task requires weighing several constraints and checking intermediate steps
• The user wants the answer quickly and is willing to accept a rough result
• The output must follow a strict schema that downstream code will parse

What is a good way to make a prompt testable?

• Test it against live traffic and roll back when the error rate rises
• Define expected outputs for a set of inputs and check the prompt against them after every change
• Freeze the prompt once it works and route changes through a new prompt
• Keep the prompt general so it holds up on inputs you did not anticipate

Which change most often improves a prompt that is 'almost right'?

• Adding a persona that matches the domain the prompt operates in
• Adding a line asking the model to double-check its answer before responding
• Moving the instructions from the system prompt into the user turn
• Replacing an ambiguous instruction with a specific, checkable one

Which instruction most improves factual grounding when documents are provided?

• 'You are a careful analyst who values accuracy above all else in every answer you give'
• 'Be concise and accurate, and avoid speculation unless the user asks for it'
• 'Combine the documents with your own knowledge and give the most complete answer'
• 'Answer only from the provided documents and cite the passage; if it is not there, say so'

A prompt must produce output in a strict template across thousands of runs. Which combination is strongest?

• A detailed persona plus a high temperature so the model stays engaged across runs
• Ten varied examples with no explicit template, so the model infers the pattern
• A precise template, one or two examples, and schema enforcement where possible
• A long narrative description of the task that explains why the template matters

What is the drawback of stuffing every possible rule into one system prompt?

• The model treats later rules as higher priority, so the early rules get ignored
• Rules compete and get missed; prioritize, structure, and test which ones matter
• Longer system prompts break prompt caching, so each run pays full price for the rules
• There is no real drawback as long as the rules are numbered and grouped by topic

When should you show the model a negative example (what not to do)?

• When a specific failure keeps recurring and a positive example alone has not fixed it
• Only as a last resort after temperature and max_tokens adjustments have both failed to help
• In every prompt, paired with each positive example so the contrast is explicit
• Only in the system prompt, since negatives in the user turn are treated as content

Which is the best way to get the model to ask a clarifying question instead of guessing?

• Include examples of confident guesses marked as wrong so the model learns to avoid them in similar cases
• Add a persona of a cautious consultant who checks with the client before acting
• Instruct it to ask when a required detail is missing, and define what counts as required
• Lower the temperature so the model is less willing to commit to an uncertain answer

A summarization prompt is losing important numbers. What helps?

• Ask for a shorter summary so the model focuses on only the most important facts
• Instruct it to preserve all figures, dates, and names verbatim, with an example
• Increase max_tokens so the summary has room for every number in the source
• Switch to bullet points, since lists make omitted figures easier for a reader to spot

What does 'role prompting' do well and what does it not fix?

• It sets tone and perspective; it does not fix missing instructions, data, or ambiguous tasks
• It fixes ambiguous tasks by giving the model a viewpoint from which to resolve them
• It replaces the need for examples, since a strong persona implies the expected output
• It improves factual accuracy by activating domain expertise the model would not otherwise use

Which prompt is more testable?

• 'Write a summary of at most 120 words with one sentence per section, listing every decision and owner'
• 'Summarize this document in the style of our best analyst, keeping the reader's needs in mind'
• 'Write a thorough, well-organized summary that a busy executive would find genuinely useful and complete'
• 'Produce a high-quality summary and double-check it for completeness before you answer'

You want the model to output only 'APPROVE' or 'REJECT'. What is the most reliable approach?

• Constrain the output through an enum in a tool schema, or prefill and instruct with examples
• Add a strict reviewer persona and ask the model to be decisive in every answer it gives
• Raise max_tokens and instruct the model to end its response with the final label on its own line
• Ask the question twice and accept the label only when both responses agree with each other

How should a prompt handle ambiguous user requests in a customer-facing product?

• Instruct the model to answer every plausible interpretation in turn so the user can pick the right one
• Instruct the model to state its interpretation or ask one clarifying question, per product policy
• Instruct the model to choose the most common interpretation and answer with confidence
• Instruct the model to decline ambiguous requests and direct the user to a support form

Which change is likely to reduce hallucinated tool parameters?

• Fewer examples in the tool description, so the model relies on the schema alone
• A system prompt persona of a careful engineer who double-checks every parameter before calling a tool
• Examples of correct calls in the tool description and a schema with enums and required fields
• Longer output budgets so the model has room to reason before it commits to a call

What is a reasonable way to iterate on a prompt with a team?

• Freeze the prompt after launch and route new requirements to a separate prompt
• Versioned prompts, a shared eval set, and review of score changes before deploy
• Each teammate tests edits in their own environment and merges whichever version feels best
• One owner edits the production prompt by feel and watches user feedback for regressions

Which is the most reliable way to keep a chatbot on topic?

• Lower the temperature so the model is less likely to wander from the topic
• State the allowed scope and the exact behavior for out-of-scope requests, with an example refusal
• Ask it in the system prompt to stay focused and professional throughout the conversation and avoid tangents
• Limit max_tokens so long off-topic answers are cut off before they finish

A prompt uses the word 'summarize' but the stakeholder wants an executive brief with decisions and risks. What is the fix?

• Keep 'summarize' but add 'good' and 'executive' as qualifiers to signal the audience
• Add a persona of a chief of staff so the model understands who the reader is
• Replace the vague verb with the required sections and length, plus an example brief
• Move to a larger model, since executive briefs need stronger reasoning than summaries

What is the purpose of asking the model to plan before it writes a long document?

• Faster generation, since the model writes prose more quickly from an outline
• A structure to check and steer before tokens are spent on prose
• A longer output, since the plan and the document are both returned
• Fewer examples needed, since the plan takes the place of a sample document

Which instruction helps most when the model must handle inputs in several languages?

• State the expected input languages and the required output language explicitly
• Tell the model it is multilingual and let it match whatever language the user writes in
• Instruct the model to translate everything to English internally before answering
• Provide one example conversation in each language the product supports

You need consistent scoring of essays on a 1 to 5 rubric. What makes the prompt reliable?

• Extended thinking so the model weighs each essay carefully before it commits to a score
• The rubric spelled out per score level with an example essay at two or three levels
• A one-line instruction to score from 1 to 5, with temperature set to zero
• A persona of a strict but fair teacher with twenty years of grading experience

The model returns Markdown when you need plain text for an SMS. Simplest fix?

• Instruct plain text with no formatting, show an example, and validate before sending
• Switch to a smaller model, since smaller models use less formatting by default
• Ask for the message twice and send whichever version contains fewer formatting characters
• Strip Markdown syntax in code after generation and accept the occasional artifact

Why keep examples in a prompt consistent in format with the required output?

• The API validates examples against the output schema and rejects mismatches
• Consistent examples let the model skip reasoning and copy the pattern directly
• The model imitates the examples; inconsistent examples produce inconsistent output
• Consistent examples compress better, which keeps the prompt within the cache limit

What should you do when a system prompt and a user message conflict?

• Rely on the default, since the system prompt is guaranteed to win any conflict
• Raise the temperature so the model can weigh the two instructions more flexibly
• Remove the system prompt and put all instructions in the user turn so nothing can conflict
• Design the system prompt to state precedence for the cases you care about, and test them

Which is a sign a prompt is over-specified?

• Cache hits fall because the system prompt changes with every rule added
• The model asks clarifying questions on inputs the rules already cover
• Consistent output on the eval set but higher cost per call than the team expected
• Long rule lists the model ignores while output quality drops on normal inputs

How do you test a prompt change without a full eval suite yet?

• Change the prompt, the model, and the temperature together so any improvement shows clearly
• Ship the change to a small share of users and watch the support queue for complaints
• Ask the model to compare the old and new prompt and say which one it prefers
• A small fixed set of representative inputs, including edge cases, compared before and after