PromptMate · Best practices

Write prompts
worth saving.

The difference between a library you use daily and one you abandon after a week comes down to how the prompts are written. Six rules that make the difference.

Browse starter prompts Back to getting started
Six rules

What separates prompts that stick from ones that rot.

These aren't theoretical. They come from testing the same prompts across hundreds of sessions in ChatGPT, Claude, DeepSeek, and Kimi.

01

Be specific about the task, not the persona

Write "Review this code for SQL injection vulnerabilities" rather than "Act as a security expert". Task-specific prompts produce consistent, usable output. Persona prompts produce unpredictable responses.

What exactly do you want done? Start there.
Less effective

Act as a senior engineer and review this.

Better

Review this pull request for correctness, edge cases, and maintainability. Call out risky assumptions before suggesting changes.

02

Use placeholders for the variable parts

Build reusable prompts with placeholders like [PASTE_CODE_HERE] or [TOPIC] for the parts that change each session. The static framing — tone, instructions, output shape — stays in the saved prompt.

What changes session to session? Make that the placeholder.
Less effective

Explain Kubernetes to me.

Better

Explain [TOPIC] clearly. Start with a one-sentence definition, then give me the intuition, then a practical example. Assume I know software engineering basics.

03

One task per prompt

Prompts that ask for three things produce output that does two of them well and one poorly. Save separate prompts for separate tasks. Compose them manually in a session when you need both.

Can you split this into two focused prompts?
Less effective

Review my code, write tests for it, and then document it.

Better

Save three separate prompts: one for review, one for tests, one for documentation.

04

Match tone and format to the reader, not the task

A code review written as prose is slow to scan. A technical spec in bullet points loses nuance. The output format should match how the output will actually be read — not just what feels right to write.

Who reads this output? How will they consume it?
Less effective

Explain the bug fix. (No format set)

Better

Format: Steps numbered 1–N. Each step: what changed, why, and what to verify. Written for a junior engineer reading in a PR comment.

05

Test before saving, not after

Use a prompt two or three times in real sessions before saving it. If you need to edit it every time, it's not ready. Save the version that works without adjustment — that's the one worth keeping.

Did this produce the right output without editing? If not, fix first.
Less effective

Saving a prompt the first time you write it "just in case".

Better

Run it twice with different inputs. Edit until no adjustments are needed. Then save.

06

Include the context the model can't infer

Language, framework, audience, constraints, what to avoid. The model doesn't know you're on a Kubernetes cluster or writing for a non-technical PM. Put that in the prompt — it won't drift session to session.

What would a smart colleague need to know to do this task well?
Less effective

Write documentation for this function.

Better

Write JSDoc documentation for this TypeScript function. Audience: engineers onboarding to this codebase. Cover: what it does, parameters, return value, one usage example, and edge cases to watch for.

Habits

Build a library that sticks.

Small patterns that make PromptMate worth keeping open every session.

Start with prompts you already reuse

Think about instructions you type every week — code review format, email drafts, explaining concepts to teammates. Those are your first 5 saves. Don't start from scratch — start from what's already working.

Use tone + format for consistent output

Setting tone and format on save means every session starts with the same AI behavior — no drift, no retraining the model each time. The same prompt with 'technical' tone and 'checklist' format produces predictably scannable output.

Edit during a session, not before

Don't over-engineer prompts upfront. Save a rough version, use it in real work, notice what's missing, then edit inline. Version history keeps your original — you're never losing work by refining.

History catches what you forgot

Every prompt you use is logged in history. If a session produced great output but you closed the tab, scroll the history — the prompt that worked is still there and you can promote it to your saved library.

Ready to build?

See the rules in practice.

The starter prompts page has copy-ready examples that follow all six rules. Add them to your library and adapt them to your workflow.