·7 min read·Helium Team

How to Build a Prompt Library That Works Across Every LLM

How to Build a Prompt Library That Works Across Every LLM

You've written the same "act as a senior code reviewer" prompt at least 20 times. Each time, you write it slightly differently. Some versions work great. Some produce garbage. You can't remember which was which, so you keep rewriting from scratch.

Meanwhile, the perfectly-crafted prompt that generated your best blog outline three weeks ago? Gone. Somewhere in a ChatGPT conversation titled "Writing help." Good luck finding it.

A prompt library fixes this. Not a Notion page you'll forget about, but a system that makes your best prompts findable and reusable in under 5 seconds.

Why prompt libraries fail (and what makes them stick)

Most people attempt a prompt library at least once. They create a Google Doc or Notion page, paste in 10-15 prompts, feel organized for a day, and never open it again.

The failure mode is always the same: the retrieval friction exceeds the rewriting cost. If it takes 30 seconds to find, copy, and customize a saved prompt, but only 45 seconds to write a new one from memory, you'll write the new one every time. The 15-second savings isn't enough to change your behavior.

For a prompt library to stick, retrieval needs to be faster than rewriting. Ideally under 5 seconds. That means:

What belongs in a prompt library (and what doesn't)

Not every prompt is worth saving. The test: would you write this prompt approximately the same way again? If yes, save it. If the prompt was highly specific to a one-time situation, skip it.

Save these:

Role prompts that set up the AI's persona and behavior. "Act as a senior TypeScript developer. Review the following code for type safety, error handling, and edge cases. Be specific about line numbers. Suggest fixes, don't just describe problems." This is a prompt you'll use dozens of times with different code inputs.

Structured output prompts that enforce a specific response format. "Analyze this database schema. Return your analysis as JSON with these fields: { tables: [{ name, purpose, relationships, issues }], recommendations: string[] }." These are especially valuable because getting the output format right usually takes iteration.

Workflow prompts that chain multiple steps. "First, read this codebase overview. Then identify the three riskiest areas for bugs. For each risk, explain the failure mode and suggest a test case." Multi-step prompts are hard to reconstruct from memory because the sequencing matters.

Context-injection prompts that pre-load the AI with your specific situation. "I'm building a React Native app with Expo SDK 52, TypeScript, Supabase for the backend, and NativeWind for styling. When I ask you code questions, use this stack. Don't suggest alternatives unless I ask." This is worth saving because typing your tech stack every time is pure friction.

Don't save these:

Simple questions ("what does Array.flat() do?"), highly contextual prompts that won't generalize ("fix the bug on line 47 of my Component.tsx"), or prompts that didn't produce good results.

Variables make prompts reusable

A prompt saved as-is only works for the exact scenario you originally wrote it for. Variables turn it into a template.

Instead of:

Review this React component for performance issues.
Focus on unnecessary re-renders and memo opportunities.

Save it as:

Review this {{language}} {{artifact_type}} for {{focus_area}}.
Focus on {{specific_concerns}}.

Now the same prompt works for "Review this Python script for security vulnerabilities. Focus on SQL injection and input validation." You swap the variables, not the structure.

The variable syntax doesn't matter. {{variable}}, [VARIABLE], {variable} all work. What matters is that you identify the parts that change between uses and mark them clearly.

Most people skip this step because it feels over-engineered for 10 prompts. It becomes essential at 50+. Build the habit early.

Organizing by task, not by platform

The biggest mistake in prompt library organization is grouping by LLM: "ChatGPT prompts," "Claude prompts," "Gemini prompts." This breaks immediately because most well-written prompts work across all models.

Instead, organize by task type:

Within each category, have 3-5 prompts you've validated. Tag each with which models you've tested it on and any model-specific notes ("Claude handles this better because of the longer context window" or "add 'be concise' for ChatGPT or the response will be 3x longer than needed").

A prompt library structure that scales

Here's a format that works from 10 to 500 prompts:

## Code Review: General

**Tags:** code-review, quality
**Tested on:** ChatGPT, Claude, Gemini
**Variables:** {{language}}, {{focus_area}}

Review this {{language}} code with a focus on {{focus_area}}.

For each issue:
1. Quote the specific line(s)
2. Explain what's wrong
3. Show the fix

Prioritize: correctness > security > performance > style.
Don't suggest stylistic changes unless they affect readability.

**Notes:** Add "Be concise" for ChatGPT. Claude gives the best output here.
**Last updated:** 2026-03-15

The "Notes" and "Last updated" fields matter more than you'd think. Prompts rot. A prompt that worked great on GPT-4 might produce verbose garbage on GPT-5. Review your library monthly, test your most-used prompts on the latest models, and update or retire the ones that no longer perform.

Tools vs. manual approaches

Manual (Notion, Obsidian, Markdown files): Free, flexible, works anywhere. Breaks down past 100 prompts because search gets noisy and there's no one-click copy. Good starting point.

Browser extensions (Promptto, Prompt Stash, FlashPrompt): Fast retrieval, usually with keyboard shortcuts. But they're tied to the browser. If you switch to a mobile app or desktop client, the library doesn't follow. Some store your prompts on their servers, which is a consideration if your prompts contain proprietary business logic.

Dedicated apps (Helium, Prompt Library): Cross-platform, variable support, integrated with AI workflows. More setup upfront, but they scale better past 50+ prompts and often include features like sharing, versioning, and analytics (how often you use each prompt).

Pick the approach that matches your current scale. If you have 15 prompts, a Notion page is fine. If you have 100+, you'll want search, variables, and one-click copy.

Start with your top 5

Don't try to save every prompt you've ever written. Start with the five prompts you use most often, the ones you've been retyping from memory.

Write them down. Add variables where the inputs change. Add a note about which model works best. Put them somewhere you can find in under 5 seconds.

That's the whole system. You'll add more as you go. The important thing is that you stop rewriting prompts from scratch and start compounding on the ones that work.

promptsproductivityworkflow
Get Early Access