Instead of retyping the same instructions every time, you can save a configured assistant for a task you do again and again. It remembers how you want the work done, so you never start from a blank box.
How it works
A custom assistant is your instructions plus your material
Standing instructions+Your own documentsA reusable assistant
It still drafts, not verifies. The fact-check habit stays.
A custom assistant reuses your setup so you do not retype it each time; it does not make the output any more verified, so you still check what it produces.
This capability shows up on every major tool under a different name. Claude has Projects and Skills, ChatGPT has Custom GPTs and Projects, Google Gemini has Gems, and Microsoft Copilot has agents. The idea underneath is the same.
A custom assistant bundles standing instructions, a consistent style, and reference material you load once, such as your agency's plain-language style guide or an approved FAQ, so you stop retyping the same setup.
Because the setup is saved and shared, every staff member who uses it starts from the same instructions and the same reference material, so the output stays consistent across the team.
Set up a plain-language rewriter tuned to your reading level, so every rewrite comes back at a level your clients can follow.
Set up an intake-summary assistant that returns notes in the same format each time, and a resource-finder primed with your local referral list so it draws from names you already trust.
Load only agency-owned, shareable material into an assistant the team shares, with no client identifiers in the reference files, since everyone who uses it can see what shaped its answers.
The saved setup speeds up the work and steadies it, and every output is still a draft you check, because the assistant can miss its reference material or go past it.
How it works, and where it breaks
1A custom assistant is a saved instruction sheet plus files it reads from
A Custom GPT, a Gem, a Project, or a Skill is not a new model trained on your data. It is the same underlying model with a saved system prompt, which holds your standing instructions, and a set of reference files the tool searches when you ask something, pulling the relevant passages into the prompt before it answers. Attaching retrieved reference text to a general model this way is called retrieval-augmented generation (Lewis and colleagues, 2020). This is why your instructions and your reference files shape every answer: they are placed in front of the model each time it responds.
2Loading files is not the same as retraining the model
Fine-tuning changes a model's internal weights by training it further on new examples, which is costly and stays baked into that copy. A custom assistant does something lighter. It leaves the model unchanged and hands it your material to read at the moment you ask. That is why you can update a custom assistant by swapping a reference file, and why the assistant's knowledge is only as current and correct as the files you loaded. Nothing about your agency is written into the model itself.
3The reference guides the answer, it does not fence it in
The model still writes each answer by predicting text, so it can lean on what it learned in general training and produce something the reference files never said, or state a confident answer when its search of the files turned up little. Surveys of these systems document fluent output that is unsupported by or inconsistent with its source (Ji and colleagues, 2023). Tell the assistant to answer only from the loaded material and to say when something is not covered, and still read the output before anyone uses it.
Set it up once
How to set up a custom assistant your team can reuse
Name the task the assistant handles, such as a plain-language rewriter or an intake summarizer.
Write the standing instructions once, including the reading level, the tone, and the format you want back.
Load reference material the whole team can share, such as a style guide or an approved FAQ, with no client identifiers in it.
Add one line to the instructions on what the user should check before the result is used.
Share it with the team, and revisit the setup when your tools or your reference material change.
The same rewrite instructions, retypedA shared plain-language rewriter
Set up a plain-language rewriter your whole team can reuse
You are a plain-language rewriter for our agency. Rewrite anything I paste at a sixth-grade reading level, in short paragraphs with plain headings. Keep every date, amount, and deadline, and list them at the end so I can check them. Follow the wording and tone in the style guide I have loaded. [load your agency's plain-language style guide, paste text with no client identifiers]
Guardrail. Load only agency-owned material with no client details, and check every rewrite before it goes out.
Raw intake notes in every formatA consistent intake summary
Set up an intake-summary assistant the team shares
You summarize intake notes into a consistent format with short sections for situation, needs identified, actions taken, and next steps. Stay factual and neutral. Do not add anything I did not write. Follow the intake template I have loaded. [load your blank intake template, paste notes with no client identifiers]
Guardrail. Keep client identifiers out of the notes you paste, and read every summary against what you wrote.
Retyping your trusted referralsAn assistant that draws from your list
Set up a resource-finder primed with your referral list
You are a resource-finder for our agency. When I describe a client need in plain terms with no identifiers, suggest matches only from the referral list I have loaded, give the service, the contact, and who it fits, and say clearly when the list has nothing that fits instead of inventing an option. End by reminding me to confirm each referral is current. [load your agency referral list, describe the need with no client identifiers]
Guardrail. Load only agency-owned, shareable content, and confirm each referral against its source before you pass it to a client. See Module 4.
A task you keep doing by handStanding instructions you can paste into the setup
Write the instructions for a shared assistant
Help me write the standing instructions for a custom assistant that does the task I name. Ask me for the reading level, tone, and output format if I have not given them, then draft short, plain instructions that tell the assistant to work only from the reference material I will load, to flag anything not covered, and to remind the user what to check before using the result. [name the task and who on the team will use it]
Guardrail. Keep the instructions and any loaded files free of client identifiers, and treat every output as a draft you check. See Module 4.
Worked example
When the assistant fills a gap the files did not cover
A team sets up a resource-finder and loads their approved referral list, then asks it for a food-assistance option in a neighborhood the list does not cover.
The assistant returns a confident, well-formatted suggestion with a name and a phone number that reads exactly like the entries on the loaded list.
A staff member checks it and finds the organization is real but its program closed, and it was never on the agency's list. The assistant filled the gap from its general training when it should have said the list had nothing.
They add an instruction telling the assistant to answer only from the loaded list and to say when nothing fits, reload it, and confirm every referral against its source before it reaches a client.
Guardrail. A shared assistant is only safe if its reference material holds no client data. Load only agency-owned, shareable content, and treat every output as a draft you check. See Module 4.
Sources
Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Kuttler, H., Lewis, M., Yih, W., Rocktaschel, T., Riedel, S., & Kiela, D. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems 33. https://arxiv.org/abs/2005.11401
Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., Xu, Y., Ishii, E., Bang, Y. J., Madotto, A., & Fung, P. (2023). Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12), 1-38. https://doi.org/10.1145/3571730