The naming deep-dive
The role · task · format naming pattern
One small convention does more for a prompt library than any app ever will — a name you can guess. Here is the whole pattern: why it works, how it looks across writing, coding, and research, and how it holds up at four hundred prompts.
You can write the best prompt in the world and still lose ten minutes to it — not because it stopped working, but because you could not remember what you named it. A prompt library stands or falls on one unglamorous detail: whether the exact thing you need surfaces the moment you reach for it. That is a naming problem, and it has a small, durable fix.
The pillar guide to organizing your prompts introduces this pattern in passing. This is the deep dive: what each part means, why it beats the clever names we all reach for first, how it looks across three very different kinds of work, and why it keeps working when your library grows from forty prompts to four hundred.
The pattern, in one line
Every prompt gets a name built from three parts:
`role · task · format`
- role — who the model is being: `editor`, `reviewer`, `analyst`, `tutor`, `planner`.
- task — what it is doing, in plain verbs: `tighten prose`, `find bugs`, `summarize`.
- format — what comes back: `bullets`, `table`, `diff`, `keep voice`.
Read left to right, a name becomes a tiny sentence you can picture before you open it. `editor · tighten prose · keep voice`. `reviewer · find bugs · diff only`. `analyst · summarize interview · five bullets`. You already know what each one does, and you have not read a single word of the prompt itself.
The middle dot (`·`) is just a calm separator — easy to read, easy to type once you set up a snippet for it. If your tool dislikes it, a hyphen or a slash works fine. The three-part shape is what matters, not the punctuation.
Why predictable beats clever
Left to our instincts, we name prompts the way we name home WiFi networks: with a wink. `The Closer`. `magic-summary`. `prose-glow-up`. They feel good for exactly as long as you remember them, which is about a week.
The trouble is that future-you does not search for the joke. Future-you, mid-task, types the plainest word that fits the need — `summarize`, `refactor`, `outline` — and expects it to appear. A clever name hides from that search. A predictable name walks right into it.
A name you can guess is worth more than a name that is clever. If future-you would search for "summarize", put "summarize" in the name — not "distill", not "TL;DR", not "magic-shrink".
That is the whole philosophy in one move: optimise for the moment of retrieval, not the moment of creation. You name a prompt once and find it a hundred times. Spend the effort where the hundred is.
Three shelves, one pattern
The pattern earns its keep by working the same way no matter what you do with AI. Here it is across three very different shelves.
Writing. Your voice and editing prompts are the ones you reach for daily, so they gain the most from predictable names.
- `editor · tighten prose · keep voice`
- `writer · draft outline · headings only`
- `critic · flag weak claims · margin notes`
Notice how the format slot quietly stores your preference. "keep voice" tells the model not to flatten you into corporate beige; "headings only" stops it writing the whole essay when you wanted a skeleton.
Coding. Here the format slot is where the time savings hide, because how the answer comes back is half the work.
- `reviewer · find bugs · diff only`
- `engineer · refactor function · explain after`
- `tutor · explain error · plain language`
`diff only` means you get a change you can apply, not three paragraphs about the change. `explain after` means the code first, the commentary second. The pattern lets you bake those habits into the name.
Research. Analysis prompts live on consistency — you want the same clean shape every time so outputs stack up next to each other.
- `analyst · summarize source · five bullets`
- `analyst · extract figures · table`
- `synthesist · merge notes · one page`
When ten summaries all come back as "five bullets", you can scan them side by side. The format slot is what makes the output comparable.
When to bend the pattern
A convention you cannot bend is one you will abandon, so here is where to flex:
- Add a fourth slot when you need it. Some prompts want a subject: `analyst · summarize · table · earnings-call`. Keep the first three fixed and let the fourth carry the specific.
- Drop the format when there is only one. If a prompt only ever returns prose, `tutor · explain concept` is plenty. The slots are a guide, not a tax.
- Mark a version when a workhorse evolves. Append `v2`, or a dated note. That habit gets its own guide on versioning and testing, because your five most-used prompts will change over time and you will want the old wording back at least once.
The rule of thumb: bend the format, never the predictability. Whatever you change, keep the name something future-you would type without thinking.
How it holds up at scale
Forty prompts fit in your head. Four hundred do not — and that is exactly when a good naming pattern stops being nice-to-have and becomes the whole reason the library still works. At scale, three things happen for free:
- Search becomes navigation. Type `reviewer` and every review prompt lines up. Type `table` and every structured-output prompt appears. The name is the filter.
- Duplicates surface themselves. When you go to save `editor · tighten prose · keep voice` and your library autocompletes it, you have just been told the prompt already exists. Predictable names prevent the slow bloat of near-identical twins.
- Newcomers can read the shelf. Hand the library to a teammate and the names teach the system. That is why sharing a library with a team starts with agreeing on this one convention.
None of this needs an app. It is a folder tree, a naming habit, and a five-minute weekly tidy — the same small system whether you keep ten prompts or a thousand.
One line holds no matter how your names evolve: a library, not a keychain. A prompt name can describe the secret it needs — `deploy · call api · use OPENAIAPIKEY` — but the key itself never belongs in the library. Name the reference; store the secret in a real secrets manager. That is what keeps your prompts safe to search, sync, and share.
Want the pattern ready-made? The free Quick-Start Sheet gives you the folder tree and the naming convention on one page, and the Prompt Folder Starter ships forty templates already named this way. If you are building your library from nothing this afternoon, the build-a-library walkthrough is the friendliest place to begin.
One page, ten minutes, no email — the folder tree and the naming pattern, ready to paste in.
The naming pattern: FAQ
Do I have to use the middle dot?
No. The `·` is only a separator that reads cleanly and is easy to scan. A hyphen (`editor-tighten-prose`) or a slash works just as well. What matters is the three-part shape — role, then task, then format — not the punctuation between them.
What if a prompt does not fit three parts?
Then use two, or add a fourth. The pattern is a scaffold, not a rule to obey. A prose-only helper can be `tutor · explain concept`; a very specific one can carry a subject in a fourth slot. Keep the first parts predictable and let the rest flex.
Won't long names get annoying to type?
Rarely, because you search names far more than you type them, and most tools autocomplete after a few letters. If typing ever grates, set up a text snippet for the middle dot and lean on fuzzy search. The findability is worth the extra keystrokes many times over.
How is this different from just using tags?
Tags describe a prompt from the outside; the name describes it from the inside, in the order you think. Most people never need tags once names are predictable. Start with the naming pattern and folders — add tags only if you feel genuine friction, which is rarer than you would expect. The organizing guide covers the folders-first approach in full.
Can my whole team use one naming standard?
Yes, and it is one of the biggest payoffs. When everyone names prompts the same way, anyone can find anyone's work on day one. Agree on the role, task, and format vocabulary once, write it down, and keep the "no secrets" rule strict so a shared name never carries a real key. There is a whole post on sharing prompts with a team if that is where you are headed.
Keep reading
Disclaimer: The Prompt Folder is an organizing tool, not security software. Keep API keys, passwords, and private customer data out of your prompt library — store the prompt, and reference the secret from a real secrets manager.