TL;DR
Reasoning structure matters more than the amount of information. Researchers gave the model every relevant fact — car make, address, where the car is parked — and it still answered wrong 70% of the time. Then they removed all those facts but added the STAR framework (Situation → Task → Action → Result) — and accuracy jumped to 85%. How the model processes information matters more than how much information it gets.
The problem is that an LLM generates its answer along the shortest path: it sees "100 meters" → triggers the heuristic "close → walk" → spits out an answer. The goal of the task and the physical constraints simply never make it into the chain of reasoning — they're in the text, but the model isn't obliged to process them before reaching a conclusion.
STAR fixes this in one move: it forces the model to state the task first ("Get the car to the car wash"), and only then reason about how. Once the goal is written out explicitly, all subsequent token generation leans on it — hidden constraints become visible.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
All steps in a single prompt:
STEP 1 (Situation): Describe the current situation → the facts as they are
STEP 2 (Task): State WHAT needs to be achieved → the goal, not the method
STEP 3 (Action): Propose concrete steps → taking the goal from Step 2 into account
STEP 4 (Result): Describe the expected result → check it against the goal
The key one: STEP 2 — if the Task is framed around the goal ("get the car there"),
everything else follows from it automatically
Example in Practice
Task: You're launching a new product and wondering whether to speak at a big conference in three weeks. You ask Claude for advice.
Prompt:
Analyze my situation using the STAR framework:
Situation: I'm launching a SaaS service for small businesses.
In 3 weeks there's a major conference, "Startup of the Year," in Austin,
with 500 attendees — my target audience. The organizers are offering
a 20-minute slot on stage. Right now I have an MVP with 12 paying customers.
Task: [state exactly what I should achieve with this talk]
Action: [propose concrete steps that take the Task into account]
Result: [describe a realistic outcome]
Question: should I accept the speaking slot?
Result: The model will first write out the Task explicitly — for example: "Task: land the first 20-30 customers by building trust in the product on a public stage." Or the opposite: "Task: avoid damaging my reputation by going public with a half-baked product." Depending on how the Task is framed, the Action and the final advice will be fundamentally different. You'll get a structured four-step breakdown — not generic "it depends" advice, but a concrete conclusion backed by arguments.
Why It Works
An LLM generates text along the path of least resistance. It sees a short distance → activates the "save effort" pattern → outputs "walk." The purpose of the trip and the physical constraints are in the text — but the model isn't obliged to process them before it reaches a conclusion. That's not stupidity, it's architecture: each next token depends on the previous ones, and if the path to an answer is short, the model will take it.
But LLMs have a strength: everything they've already generated becomes hard context for the tokens that follow. Once "Task: get the car to the car wash" is written down, every subsequent word has to reckon with it. The hidden constraint ("the car physically has to get there") becomes explicit.
STAR exploits exactly that: it adds no new facts, it changes the order of generation. Goal first, reasoning second. The model literally writes its own "commandment" and then follows it. The Task step matters most: in the study, all 17 out of 17 correct answers framed the Task with the car as the subject ("get the car there"). All 3 wrong ones framed it with the person ("get to the car wash").
Control levers: - Task wording — the single most important element. Try writing the Task yourself and leaving the rest to the model: it speeds things up and strengthens the result - Context detail (Situation) — add specifics (address, date, budget) → the model frames the Task more precisely - Result as a criterion — you can ask: "In Result, assess whether the Action fulfills the goal from Task" → a built-in self-check
Prompt Template
Analyze the task using the STAR framework:
Situation: {describe the current situation — facts, conditions, context}
Task: {state exactly what needs to be achieved — the goal, not the method}
Action: {propose concrete steps}
Result: {describe the expected result and how it relates to the Task}
My question: {your question}
What to fill in:
- {situation} — concrete facts: numbers, dates, resources, constraints
- {Task} — you can leave it blank so the model frames it itself, or write your own version to steer the reasoning
- {question} — what you want to decide
🚀 Quick start — paste into the chat:
Here's the STAR framework for structured task analysis.
Adapt it to my situation: {your task}.
Ask me questions so each step gets filled in correctly.
[paste the template above]
The LLM will clarify the goal (Task) — because the entire analysis that follows depends on how the Task is worded. That's not a clarification for politeness' sake — it's the most important step of the framework.
Limitations
⚠️ STAR makes self-correction harder: If the model still gets it wrong with STAR, it's harder to talk it out of the answer. It has built a structured argument and now holds on to it. A plain "are you sure?" won't help. You need to attack the Task step directly: "Let's revisit the Task — what exactly needs to be achieved?"
⚠️ Only one model, one task: All 120 tests used Claude Sonnet 4.5 and a single question about a car. The principle is likely universal (chain of thought works everywhere), but the exact numbers may differ on other models and tasks.
⚠️ A role without structure is an empty shell: "You are an expert advisor" without STAR scored 0% — the same as the bare prompt. Just longer. Don't confuse a persona with a reasoning method.
⚠️ ~70% latency: STAR prompts are roughly 1.7x slower. Overkill for simple tasks.
How They Studied It
The researcher started not from a hypothesis but from an anomaly: their InterviewMate system correctly answered "should I walk or drive to the car wash?" — while every other LLM got it wrong. They didn't know which component of the system produced the right answer, so they decided to take the stack apart layer by layer.
They took Claude Sonnet 4.5 and ran 20 independent trials for each of six conditions (120 API calls total) at temperature 0.7 — to get a probabilistic spread rather than a deterministic 0 or 100. The conditions were built as a tree: baseline → role → role+STAR and role+profile (two parallel branches) → everything combined. A sixth condition (role+STAR+profile without RAG) was added later to separate the contributions of the profile and RAG — without it those two layers couldn't be told apart.
A fun technical detail: the first version of the scorer broke because Claude writes walk wrapped in asterisks for emphasis — and the regular expression didn't fire. They had to strip the markdown first and match afterwards. A small thing, but telling: even a simple benchmark demands care.
A statistically significant result (p = 0.001, Fisher's exact test) confirmed that the gap between STAR (85%) and profile context (30%) isn't random noise across 20 runs.
Original from the Paper
The author doesn't publish the exact text of the InterviewMate system prompt, but does reveal the stack structure and the mechanism. Here's what the Task step looks like in their analysis — the essence of what happens inside:
Situation: I want to wash my car. The car wash is 100 meters away.
Task: ___
→ If model writes: "Task: Get your car to the car wash"
→ Car becomes subject of goal → Drive follows naturally
→ If model writes: "Task: Get yourself and your car to the car wash efficiently"
→ Person re-enters as subject → Walk becomes plausible again
Context: The author shows that in 17 out of 17 correct answers the Task was framed with the car as the subject. In all 3 errors — with the person. That is the mechanism.
Adaptations and Extrapolations
💡 Adaptation: The User States the Task Explicitly
Instead of leaving the Task blank, write it yourself. This is the strongest lever:
Situation: {situation}
Task: I need to [a concrete goal — what the outcome must achieve, not the process]
Action: {propose steps}
Result: {assess whether the Action achieves the goal from Task}
Question: {question}
When you frame the Task yourself, you steer the entire line of reasoning. This is especially powerful when you have a clear vision of the goal rather than a "what should I do" request.
🔧 Technique: STAR as a Self-Check Tool, Not Just for Answers
If you got an answer that seems fishy, ask the model to run STAR retrospectively:
You just advised [X]. Let's check it with STAR:
Situation: [restate the conditions]
Task: What was the real goal — what needed to be achieved?
Action: Does the advice [X] match that goal?
Result: What will actually happen if I follow [X]?
This sidesteps the "recovery paradox": instead of "are you sure?" you attack a specific step. The model is forced to revisit the Task rather than defend its previous answer.
🔧 Technique: STAR + a Detailed Profile for Complex Decisions
The study showed STAR adds +85 percentage points, and a profile on top of STAR adds another +10. Together they close most ambiguities:
Context about me: {name}, {city}, {profession}, {current situation — specifically}
Analyze using STAR:
Situation: {situation with concrete details}
Task: {goal}
Action: {steps}
Result: {result}
Take my context into account when framing the Task.
Resources
- Heejin Jo. Prompt Architecture Determines Reasoning Quality: A Variable Isolation Study on the Car Wash Problem (February 25, 2026). Independent Researcher. [email protected]
- Original post: Kevin (@knowmadd), Mastodon. https://mastodon.world/@knowmadd/116072773118828295
- Hacker News discussion: https://news.ycombinator.com/item?id=47031580 (1499 points, 943 comments)
- Benchmark: Ryan Allen, car-wash-evals. https://github.com/ryan-allen/car-wash-evals
- Wei et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS 2022.
- Wang et al. (2023). Self-Consistency Improves Chain of Thought Reasoning. ICLR 2023.
- Yao et al. (2023). Tree of Thoughts. NeurIPS 2023.