BETA This site is in beta. Information is still being added and reviewed.
LINC Reach mental health care in your language
English
What you can actually do with AI
5

Build a reusable prompt library

The prompts that work are worth keeping. A shared library means nobody starts from a blank box and a good prompt written once spreads across the whole team.

The anatomy

What a reliable prompt spells out

Role Act as a caseworker writing to a client at a 6th-grade reading level.
Task Explain which documents to bring to the appointment.
Format A short numbered list, under 120 words, plain language.
Guardrail If you are unsure of a detail, say so; do not invent office hours or rules.
A saved prompt that names the role, the task, the format, and a guardrail is what makes the result repeatable instead of hit-or-miss.
  • Keep the prompts that work in a shared doc so nobody rebuilds a good one from memory, and so a prompt one person tuned becomes something the whole team can pick up and run.
  • Give each prompt a plain name that says what it does and a fill-in-the-blank version, with labeled placeholders like [paste text, no client identifiers] standing in for real details.
  • Add one line to each prompt naming what to check before the result is used, since the same saved prompt will be run by people who did not write it.
  • Write out the exact wording that worked, including the format you asked for and any example you gave, because small changes in phrasing or examples can shift what comes back.
  • Keep client names, A-numbers, and case details out of every saved prompt, so a shared library never becomes a place client data quietly accumulates.
  • Let staff add prompts and mark the ones that hold up, so the library reflects what actually works in your programs and not just what looked good once.
  • Date each prompt and revisit the library when your tools change, since a wording that worked on one version of a tool can quietly start returning something different.

How it works, and where it breaks

The model learns the task from the prompt itself

When you give one of these tools a prompt, it does not retrain. It reads your wording and any examples you include and produces the answer for this one exchange, conditioning on the exact text in front of it. This behavior, picking up a task from instructions and a few examples placed in the prompt, was named in-context learning and shown to work at scale (Brown and colleagues, 2020). It is why a clear instruction with a worked example often gets you a better result than a bare request, and why the specific prompt that worked is worth saving word for word.

Small wording changes can change the answer

Because the model conditions on your exact text, the same request can come back different when you reword it, reorder the examples, or change the formatting. A controlled study found that changes to prompt formatting alone, with the meaning held constant, moved a model's accuracy across a wide range on the same task (Sclar and colleagues, 2024). For agency work that means a prompt someone got working is a specific asset, and retyping it from memory can quietly change the result a client ends up seeing.

A saved, tested prompt is a small piece of quality control

Once a prompt reliably returns what you need, saving the exact wording turns a lucky result into a repeatable one. Everyone who runs the saved version starts from the phrasing that was checked, so the output varies less from person to person and your attention goes to verifying the result instead of rebuilding the request. Keeping the check line attached to the prompt means the verification step travels with it to whoever runs it next.

Make a prompt reusable
How to turn a prompt into a template your team can reuse
  1. Give it a plain name that says what it does, such as Plain-language handout from a policy.
  2. Replace the specific details with clearly labeled placeholders like [paste text, no client identifiers].
  3. Add one line on what to check before the result goes out.
  4. Save it in a shared doc the whole team can open and edit.
  5. Note the date, and revisit it when your tools change.
A prompt that worked once A reusable team template
Turn a prompt that worked into a template the team can reuse

Rewrite this prompt as a clean, reusable template. Replace any specific details with clearly labeled placeholders, keep it free of names and identifiers, and add one line reminding the user what to check before they use the result. [paste the prompt you want to save]

Guardrail. Store the template where the team can find it, and keep client identifiers out of it.

A prompt you think works A prompt you have stress-checked
Pressure-test a prompt before it goes in the library

Here is a prompt I want to save for my team. Run it as written, then tell me where its wording is ambiguous, where a user could paste something that breaks it, and where the output could go wrong without the user noticing. Suggest one tighter version and list what a user should check before trusting the result. [paste the prompt you want to save]

Guardrail. Store the tightened prompt where the team can find it, and keep client identifiers out of it. See Module 6.

A pile of saved prompts An organized, findable index
Draft a short index so the library stays usable

Here is a list of prompt titles my team has saved. Group them into a few plain categories, suggest a one-line description for each so a new staff member knows when to use it, and flag any two that look like duplicates so we can merge them. [paste your list of prompt titles, no client identifiers]

Guardrail. The tool can sort titles but cannot judge which prompt is safe or current, so a person reviews each one before it stays in the library. See Module 6.

Worked example

The same prompt, retyped from memory

  1. A caseworker has a prompt that reliably turns a benefits notice into a plain-language handout, and it ends by listing every date and amount so they can check them.
  2. A colleague likes the result and retypes the prompt from memory, dropping the closing line that asks for the dates and amounts to be listed.
  3. The colleague's version reads just as smoothly, but the handout no longer pulls the deadlines into a checkable list, so a filing date sits buried in a paragraph where it is easy to miss.
  4. They copy the saved prompt word for word, the checkable list comes back, and they add the exact wording to the shared library so the next person starts from the prompt that was tested.

Guardrail. A shared prompt is only safe if it holds no client data. Keep the library clean and make reviewing it a team habit. See Module 4 and Module 6.

Sources
  1. Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., Agarwal, S., Herbert-Voss, A., Krueger, G., Henighan, T., Child, R., Ramesh, A., Ziegler, D. M., Wu, J., Winter, C., ... Amodei, D. (2020). Language models are few-shot learners. In Advances in Neural Information Processing Systems 33 (pp. 1877-1901). https://arxiv.org/abs/2005.14165
  2. Sclar, M., Choi, Y., Tsvetkov, Y., & Suhr, A. (2024). Quantifying language models' sensitivity to spurious features in prompt design or: How I learned to start worrying about prompt formatting. In The Twelfth International Conference on Learning Representations (ICLR). https://arxiv.org/abs/2310.11324