Most people approach audience-adaptive prompting through intuition, adjusting tone and depth until something feels right. Intuition works until it does not, and it does not scale across a team or a large body of content. A named structure does. This article introduces the LAYER model, a five-stage framework for building prompts that adapt to their reader deliberately and repeatably.
LAYER stands for Locate, Attune, Yield, Examine, and Refine. Each stage has a distinct job, and the stages run in order, though you loop back as you learn. The value of a named model is that it makes the work teachable and reviewable: you can ask which stage a prompt skipped, and the answer tells you where it went wrong.
This is the structural companion to the practices in Principles Worth Following When Prompts Must Fit Their Reader. Where that article gives reasoned habits, this one gives the scaffold those habits hang on. A framework will not make you a better writer on its own, but it will make sure you never skip a step you would have wanted to take, and it gives a team a common map to point at when something goes wrong.
Locate: Pin Down Who Is Reading
The first stage establishes the target. Nothing downstream is reliable without it.
What this stage does
Locate produces a written audience profile—expertise, goal, vocabulary tolerance, emotional state, and intended use. The output is a few specific sentences, not a label. "Locating" the reader means moving from a vague sense to a concrete description you could hand to someone else.
When it matters most
Always, but especially when the content will reach a diverse or unknown audience. Skipping Locate is the single most common failure, as detailed in Mistakes That Quietly Erode Prompt Reliability. If you do nothing else, do this.
Attune: Convert the Reader Into Dials
The second stage translates the profile into instructions the model can act on.
What this stage does
Attune takes each attribute from Locate and turns it into a concrete dial: vocabulary setting, depth, entry point, and substance decisions about what to include and omit. The profile describes the reader; Attune describes what to do about them. A profile without this translation often produces output that adjusts tone but not content.
When it matters most
Whenever the gap between the reader and the model's default audience is wide. The further the reader sits from the generic average, the more explicit your dials need to be to overcome the default.
Yield: Produce the Output in the Right Order
The third stage is generation, but generation structured to honor the earlier stages.
What this stage does
Yield assembles the prompt with the audience first, the dials stated, a calibration sample attached, and the task last. The ordering is not cosmetic; the model weights early context heavily, so leading with the reader propagates adaptation through everything after. The mechanics of this assembly appear in The Sequence That Turns a Vague Audience Into a Working Prompt.
When it matters most
Every time, but the ordering discipline pays off most on longer outputs where a buried audience instruction loses influence as text accumulates.
Examine: Verify the Output Serves the Reader
The fourth stage checks the result against the target set in Locate.
What this stage does
Examine runs two verifications: a built-in self-check inside the prompt asking the model to confirm fit, and a human read performed from the reader's perspective rather than the author's. It also confirms that any simplification preserved accuracy. This applies the verification mindset described in Models Are Learning to Catch Their Own Mistakes.
When it matters most
In proportion to the stakes. Low-risk drafts need a quick read; high-stakes content needs both the self-check and a deliberate human examination from the reader's seat.
Refine: Adjust and Capture
The final stage closes the loop and turns a one-off success into a reusable asset.
What this stage does
Refine adjusts one dial at a time based on what Examine found, re-running until the fit is right. Then it captures the working prompt with its audience profile and boundaries noted, so the effort becomes reusable. Changing one variable per iteration is what turns guessing into learning.
When it matters most
When the output will recur or the prompt will be reused. A one-time throwaway can skip the capture step; anything you will need again earns it.
Applying LAYER as a Team
The model's real payoff is shared language.
A common vocabulary for review
When a reviewer can say "this prompt skipped Attune," everyone knows what to fix. The stages give a team a way to diagnose adaptation failures precisely instead of vaguely sensing that output is off.
Scaling without losing fit
As content volume grows, LAYER lets you standardize the Locate and Attune stages into reusable profiles and dial sets, so each new piece starts from a fitted base. The capture discipline from The Working Checks That Keep Adapted Prompts Honest feeds directly into this.
Where LAYER Bends and Where It Holds
A model is only useful if you know its limits. LAYER is a scaffold, not a law, and treating it rigidly defeats its purpose.
Compress the stages for low stakes
For a throwaway request, running five full stages is overkill. You can collapse LAYER to a quick Locate and a light Examine and skip the rest. The model scales down gracefully because each stage is independent; you are not obligated to run all five every time. The skill is matching the depth of the process to the cost of getting it wrong.
Do not skip Locate, ever
The one stage that resists compression is Locate. Even the quickest application benefits from a one-line reader description, because everything downstream aims at the target it sets. Skipping Locate is the failure that produces generic, unfitted output, and no amount of careful work in the later stages recovers from a missing target.
Loop, do not just march
Though the stages run in order, the model is iterative. Examine often sends you back to Attune to adjust a dial, and occasionally back to Locate when you realize you misjudged the reader. Treat the arrows between stages as two-way. The first pass through LAYER is rarely the last, and the loop is where the fit gets refined.
Frequently Asked Questions
Why use a named model instead of just adjusting intuitively?
Intuition does not scale across a team or a large body of content, and it cannot be reviewed. A named structure makes the work teachable and diagnosable—you can identify which stage a prompt skipped, which turns a vague sense that output is off into a specific, fixable cause.
Do I have to run all five stages every time?
For consequential or recurring work, yes. For a quick throwaway, you can compress—Locate and a light Examine may suffice. But skipping Locate is almost never safe, because it sets the target everything else aims at.
What is the difference between Locate and Attune?
Locate describes the reader; Attune describes what to do about them. Locate produces a profile—expertise, goal, jargon tolerance. Attune converts that profile into concrete dials like vocabulary and depth. A profile without Attune often adjusts tone but not the substance the reader actually needs.
Why does the order in the Yield stage matter?
Because the model weights early context heavily. Leading the prompt with the audience makes every later instruction interpret through the reader. Burying the audience lets the model commit to a generic approach first, which the audience instruction then has to fight, especially on long outputs.
How does LAYER help a whole team rather than an individual?
It provides shared vocabulary. A reviewer can name the missing stage, and standardized Locate and Attune outputs become reusable profiles and dial sets. That lets a team scale content volume without each new piece sliding back to a generic, unfitted default.
Key Takeaways
- LAYER is a five-stage model—Locate, Attune, Yield, Examine, Refine—for designing prompts that adapt to their reader.
- Locate produces a specific written audience profile; Attune converts it into concrete dials for vocabulary, depth, entry point, and substance.
- Yield assembles the prompt audience-first so adaptation propagates, and Examine verifies fit through a self-check and a reader-perspective human read.
- Refine adjusts one dial at a time and captures the working prompt with its boundaries for reuse.
- The model's payoff is shared, diagnosable vocabulary that lets a team scale adaptive content without losing fit.