I measured what makes a prompt reusable: 246 named inputs across 152 prompts

I sell a pack of 152 prompts for $6. Before I wrote this I decided to measure it the way I'd
measure a codebase, because "152 prompts" is a number I could hit with a text file of
one-liners and no buyer would be able to tell the difference. So: what actually makes a prompt
reusable, and how do you check it in someone else's library — or your own?

Here's the answer I came back with: a prompt is reusable when it names its own inputs. A
prompt that says "write me a blog post about my topic" is a sentence. A prompt that says what to
fill in, and where, is a function. I made that a rule in this library and then counted whether
the library obeyed it.

The structure, in three parts

Every prompt in the file is built the same way:

1. The instruction — role, task, and the constraints that stop the model freelancing.
2. Bracketed slots inside the text — [TOPIC], [AUDIENCE DESCRIPTION], [TONE] — so the places that need your input are visible without reading twice.
3. A closing Variables: line — the manifest. This is the part most prompt lists skip, and it's the part that decides whether you can reuse the prompt or have to reverse-engineer it.

Real example, verbatim:

### W-01 · Full-article draft from a bare idea
> Act as an experienced [INDUSTRY] writer. Write a [WORD COUNT]-word article on [TOPIC] for an
> audience of [AUDIENCE DESCRIPTION]. Structure it with a hook opening, 3–5 subheadings, concrete
> examples, and a takeaway ending. Tone: [TONE]. Avoid clichés and filler phrases like "in today's
> fast-paced world."
>
> Variables: INDUSTRY, WORD COUNT, TOPIC, AUDIENCE DESCRIPTION, TONE

The Variables: line does something a wall of brackets doesn't: it lets you decide before you
paste whether you have the inputs. If you don't know your audience description yet, you skip this
one and use a different prompt. That's the whole ergonomic.

What the count says

I parsed my own file rather than trusting my own listing copy. Script, since you can run it on
any markdown library:

import re
src = open("prompts.md").read()
parts = re.split(r"(?m)^### ([A-Z]-\d+) · (.+)$", src)
prompts = [(parts[i], parts[i + 1], parts[i + 2]) for i in range(1, len(parts), 3)]

with_line = [p for p in prompts if re.search(r"(?m)^> Variables:", p[2])]
real      = [p for p in with_line if "(none" not in p[2]]
slots     = [len(re.search(r"(?m)^> Variables: (.+)$", p[2]).group(1).split(",")) for p in real]
words     = [len(p[2].split()) for p in prompts]
print(len(prompts), len(with_line), len(real), sum(slots), min(words), max(words))

Results, all reproducible from the shipped file:

Measurement	Value
Prompts	152, no duplicate IDs
Categories	8 (20 / 19 / 19 / 19 / 19 / 19 / 18 / 19)
Prompts with a Variables: line	152 of 152
…that name at least one real slot	150
…marked (none — interactive)	2 — P-10 Energy audit, P-13 Life area review
Total named slots	246
Slot distribution	1 slot: 81 · 2: 48 · 3: 17 · 4: 2 · 5: 2
Prompt body length	19–51 words, median 32, 4,918 words of paste text
Fenced code blocks	0

Two numbers in there are the ones I actually care about, and one of them is a problem.

81 of the 150 need exactly one input from you. That's the usability argument for the whole
format. A prompt with five slots is a form, and forms get abandoned — the median is 1, not 3. If
you're writing your own library, this is the metric I'd steal: what fraction of your prompts do
you need only one thing for? If the answer is a low number, people will read them and never run
them.

The 2 exceptions are honest, not sloppy. P-10 and P-13 are interview-style prompts — the model
asks you questions and you answer them, so there is nothing to pre-fill. They still carry the
line, saying (none — interactive), because an empty slot is different from an unmarked one and
you shouldn't have to guess which happened.

What I found that I don't like

Accounting for the number I was proud of, here's the part that didn't survive the count.

The notation drifted. Most prompts use one bracket per name — [TOPIC], [TONE]. A few use a
slash inside a single bracket, like [BUSINESS/SITUATION] or [TOPIC/AUDIENCE], which is fine but
is a different instruction than it looks like. And one prompt, P-16 Travel planner, crams five
names into one bracket set:

> Plan a trip: [DESTINATION, DATES, TRAVELERS, BUDGET, PRIORITIES]. Day-by-day itinerary ...
> Variables: DESTINATION, DATES, TRAVELERS, BUDGET, PRIORITIES

Its Variables: line promises five slots; the text supplies one. A reader who fills it literally
gets one blob. So "152 prompts, 246 slots" is true at the manifest level and slightly untrue at the
body level for exactly one entry — which I found by counting instead of by remembering, and which is
now on my fix list before the next file cut.

A correction, because I published the wrong number first. My first pass counted words by splitting each prompt block on whitespace, which counted the > quote markers and the Variables: line as prompt text. That is how "27-57 words, median 39" got into the table above. Counting only the text you actually paste gives 19-51 words and a median of 32. The shape of the finding survived - the prompts are short and one input is still the median demand - but those figures are the kind you re-derive, not remember.

The other thing worth saying out loud: I have no performance data. No benchmark says these
prompts beat anyone else's, and "battle-tested" in marketing copy is not evidence. What I can claim
is structural: every prompt is long enough to carry constraints (median 39 words), names its inputs,
and encodes a named technique rather than a vibe — STAR answers, pre-mortems, weighted decision
matrices, consultative discovery calls. If a prompt list claims to be better and can't show you its
distribution, that's a signal about the list, not about you.

Steal the format, skip the purchase

If you already keep prompts, you don't need to buy anything to apply this. Add two lines to your
best five prompts and you're done:

Your prompt text here, with [THE THINGS YOU HAVE TO SUPPLY] written into the sentence where they belong.

Variables: NAME_ONE, NAME_TWO

Then run a count like the one above over your own folder. If you get a Variables: line on nothing,
that's why the library gathered dust — it wasn't the model's output quality, it was that every use
started with re-reading the prompt to figure out what it wanted.

The measured version is the AI Prompt Vault at $6 — the same 152
prompts as a markdown file plus a spreadsheet with a Category column you can filter, because
searching a 44 KB file by eye is its own problem. There's a longer index of what's in each category
at monkeyrun's product page.

If you've built a prompt library that stayed usable, what did you do about inputs — a header block,
a variable list, or something else? I'd like to know what the format looks like when it's better than
mine.