PromptMake
Article14 min readText & PE

Prompt Testing Simple Examples: Score Before You Paste

Prompt testing with simple examples and an 8-check AI prompt checker rubric. Score your draft before you paste into ChatGPT, Claude, or Gemini.

Generate optimized prompts for ChatGPT, Claude & more

Free prompt generator — no account needed.

Try Prompt Generator

Prompt testing is scoring a draft against a short rubric and 2 sample inputs before you paste into ChatGPT, Claude, or Gemini. You'll want 8 binary checks, 1 weak case, and 1 strong case. This page owns manual prompt testing with simple examples and an AI prompt checker style rubric on a sticky note. It isn't the Promptfoo automation deep-dive, and it isn't the production golden-set guide on prompt-evaluation-framework. PromptMake at https://promptmake.net/text helps you generate or enhance a draft; it doesn't ship a built-in 0-100 scorer. You leave with the rubric, scored before/after examples, and a score-before-paste workflow.

What prompt testing means before you paste

Prompt testing, for personal and small-team work, means you treat the instruction string as untrusted until it clears a written bar. Freeze the job in 1 sentence. Pick 2 inputs: a happy path and a nasty edge. Score craft first (can a stranger see role, task, format, and refuse lines?), then run the draft once on each input against rules you wrote before the model answered. If either side fails, edit the prompt. Don't trust your memory of what "felt fine" last Tuesday.

People skip prompt testing because pasting feels free. It isn't. A vague brief burns retries and teaches the model your worst habits. I've watched teams paste first and "eval later," then collect 3 conflicting system prompts in Slack with no shared bar. A sticky-note rubric beats that mess. You'll graduate to sheets and CI later. Start with checks a human finishes before coffee cools.

Who this is for: freelancers reusing ChatGPT custom instructions, PMs editing 1 support macro, and engineers changing a system prompt without a full eval suite yet. If you've already gated releases on a golden set, keep it. Skim the 8 checks as craft preflight. If you want a productized 0-100 craft badge, SurePrompts publishes a free Prompt Quality Score across 8 weighted categories on sureprompts.com/prompt-score as of late 2026. That grades structure, not truth. PromptMake doesn't copy that badge. Soft drafting help: https://promptmake.net/text.

Prompt testing vs vibe checks

A vibe check is 1 lucky demo on a friendly input. Prompt testing forces a second input that should break a weak draft: empty ticket, conflicting facts, out-of-scope ask. If your "great" prompt only survives the friendly case, you've got a demo, not a test. Write the fail rule before you run the model so you can't move the goalposts after you like the tone.

Prompt testing for chat drafts, not CI yet

Keep this ritual offline from release engineering. You aren't wiring Promptfoo YAML, pinning judge models, or measuring position bias in LLM-as-a-judge setups. Those topics belong to automation and production prompt evaluation. Here you only ask: is this paste ready enough that a second person wouldn't laugh at the missing format line?

Prompt testing with an AI prompt checker style rubric

An AI prompt checker, in the product sense, usually means a craft scorer. You paste a prompt. You get a number or category breakdown. You get fixes. SurePrompts public pages describe a deterministic 0-100 score with 8 categories (length and detail, role, specificity, structure, output format, constraints, context, examples), running in the browser without signup. Other tools market rewrite flows instead of a visible grade. Production prompt evaluation goes further: fixed inputs, pass rules, ship gates. Your manual prompt testing rubric sits between those worlds. It borrows the 8-check idea as education so you can grade craft without pretending PromptMake includes a scorer.

Use binary marks: pass or fail. Skip 1-10 scales on a sticky note; they invite hair-splitting. A draft that fails 3 craft checks rarely deserves a live paste. A draft that passes all 8 can still fail on sample outputs. Craft is necessary. It isn't sufficient. Checker products advertise craft. Your 2 sample runs catch behavior. Keep both steps in one sitting so you don't ship a pretty prompt that invents refund amounts.

When a draft fails, run Enhance on https://promptmake.net/text for the target model family, then re-score with the same 8 checks. Enhance rewrites structure and dialect. It doesn't replace your pass rules or invent a numeric badge inside PromptMake. If your team needs a shared public craft number, use a dedicated checker honestly. Keep PromptMake for generate and enhance across text and image paths. I've used both sides of that stack in the same week.

Prompt testing checks 1-4 for AI prompt checker craft

Check 1, job clarity: the prompt states the outcome in 1 sentence a stranger can repeat. Fail if the ask is only "help with this" or "make it better." Check 2, role or stance: you say who the model should act as, or you deliberately skip role because the task is pure extraction. Fail if you needed a specialist voice and left none. Check 3, specificity: numbers, names, enums, and banned phrases appear where the job needs them. Fail on "professional," "engaging," or "high quality" with no measurable substitute. Check 4, output format: you name bullets, table, JSON schema shape, word cap, or section headers. Fail if the answer shape is implied and you've already been burned by rambling.

Prompt testing checks 5-8 for prompt evaluation readiness

Check 5, constraints: hard do-not lines (no invented facts, no competitor names, stay under N words). Fail if the model is free to invent policy. Check 6, context slots: a clear place to paste the ticket, changelog, or source notes. Fail if context and instructions are mashed so the model can't tell which is data. Check 7, examples: at least 1 short good output or input/output pair when format is picky. Fail if JSON or tone must be exact and you showed nothing. Check 8, refuse or stop: what to do when data is missing or the ask is out of scope. Fail if the prompt always forces an answer. Together these 8 checks are your pocket AI prompt checker. Score craft first, then run prompt evaluation on 2 frozen inputs.

Prompt testing simple examples you can score today

Abstract rubrics die in drawers. Prompt testing sticks when you see a weak paste, a scored sheet, and a repaired paste side by side. Mark each of the 8 checks P or F. Then run 2 inputs in a throwaway chat: 1 friendly, 1 hostile. Only the repaired drafts should clear both. Soft polish after fails: https://promptmake.net/text with Enhance, then cut anything the tool invented.

These examples stay in chat-prompt land. Image and video dialects need different fields. Production routers need golden sets. You're practicing score-before-paste on jobs people mishandle: support tone and structured extraction. Steal the shape. Change the nouns. Keep binary marks. Don't overthink it.

I still fail Check 8 on half my first drafts. The model sounds helpful and invents a policy line I never approved. Annoying. That's why refuse lines belong on the sticky note before paste, not after the customer reply goes out.

Prompt testing example: support reply draft

Weak draft: "You're a helpful support agent. Answer the customer kindly using the ticket." Craft score: Check 1 fail (no concrete outcome). Check 2 pass (role exists). Check 3 fail (no tone or length rules). Check 4 fail (no sections). Check 5 fail (may invent policy). Check 6 fail (no paste slot). Check 7 fail (no sample). Check 8 fail (no refuse). Friendly input might look fine. Hostile input: ticket with no refund policy in notes. Weak draft invents a refund. Prompt testing catch: fail before paste.

Repaired draft: "You're an Acme support agent. Write a reply under 120 words with Greeting, Answer, Next step. Use only facts in TICKET and POLICY. If POLICY lacks the answer, say you need a human and list the missing fact. No apologies longer than 1 sentence. No competitor names. TICKET: {{ticket}} POLICY: {{policy}}." Re-score: all 8 checks pass. Hostile input now refuses cleanly. That's prompt testing with a simple example, not a vibe.

Prompt testing example: JSON extraction draft

Weak draft: "Extract order fields from the email into JSON." Craft fails Checks 3, 4, 5 plus 7 plus 8. The model invents keys, drops nulls, or nests randomly. Friendly email with 1 SKU looks fine. Hostile email with 2 SKUs and a missing zip code blows the schema your code expects.

Repaired draft: "Extract into JSON with keys order_id (string), sku (string), qty (integer), zip (string or null). Output JSON only. If a field is missing, use null. If 2 SKUs appear, set sku to the first and add note as a string field listing extras. Never invent order_id. EMAIL: {{email}}. Example: {\"order_id\":\"A1\",\"sku\":\"X\",\"qty\":2,\"zip\":null}." Craft passes. Hostile input returns nulls instead of fiction. Prompt evaluation on those 2 emails is now boring, which is the point.

How to run prompt testing in ten minutes

Treat prompt testing as a timer, not a research project. 10 minutes covers 1 draft, 8 checks, 2 inputs, and 1 repair. Longer sessions usually mean you're rewriting the product brief. Park strategy debates. Write the job sentence. Score. Run. Edit. Stop when both inputs pass or when a human must answer a policy question. That's it.

Keep artifacts tiny: prompt name, date, 8 P/F marks, 2 inputs, final string. Tomorrow you can re-run the same inputs after a model update without a spreadsheet. When the note grows past 1 screen, promote the job to the production prompt evaluation framework on this blog and add rows in Git. Until then, the sticky note's your source of truth.

Model notes for mid-2026: on reasoning-class targets such as GPT-5.6 Sol, Claude Opus 5 / Fable 5, or Gemini 3.1 Pro, favor goal, constraints, and format over "think step by step" padding. On fast chat or Flash-class targets, keep role, task, and a short example when format is brittle. Re-score after you change the serve model even if the text looks identical. Soft enhance for dialect at https://promptmake.net/text, then paste once.

Prompt testing step 1: freeze the job and two inputs

Write 1 outcome sentence. Pick Input A (core path) and Input B (empty, conflicting, or out-of-scope). Write the pass rule for each input in 1 line before any model call. Example: "Input B pass = starts with NEED_HUMAN and invents no refund." If you can't write that rule, you aren't ready for prompt testing. You're still defining the product. I've stalled there more than once.

Prompt testing step 2: score craft then run samples

Mark Checks 1-8. If 3 or more fail, repair before any paste. Use Enhance on PromptMake when the draft is mushy, then cut invented facts by hand. Paste into the target model only after craft clears. Run Input A and Input B once each at default settings you actually use. Record pass or fail against the prewritten rules. Edit the prompt on fails. Don't edit the rules to save a favorite wording. You'll thank yourself later.

Prompt testing vs prompt evaluation and automation

Prompt testing on this page is the preflight. Prompt evaluation, as covered in prompt-evaluation-framework, is the release discipline: golden sets, thresholds, canaries. Automation tools such as Promptfoo shine when you need a grid of prompts times models times cases, deterministic asserts first, and llm-rubric style judges only for open-ended axes you calibrated. Public Promptfoo docs push deterministic checks before model-graded ones, and they warn you to treat candidate output as untrusted input to the judge. Keep that stack for CI. Don't drag YAML into a one-off marketing macro.

LLM-as-a-judge research and vendor guides (Arize, Langfuse, Promptfoo) agree on the boring parts. Explicit criteria beat "rate helpfulness." Structured scores beat vibes. Pairwise judges show position bias unless you swap order. None of that replaces your 8 craft checks. A judge with a fuzzy rubric will bless padded answers. Your Check 4 and Check 5 cut the padding before a judge ever runs. Use judges when prose quality is the product. Use regex and schema when the contract is discrete. I've wasted tokens ignoring that split.

Anti-cannibal map, short: sureprompts-vs-promptmake owns product scoring comparisons. prompt-optimizer-vs-prompt-generator owns enhance versus generate. This article owns manual prompt testing with simple examples. When Wave 5 ships promptfoo-vs-manual-prompt-testing, that piece owns when to automate. Stay in your lane so search results don't fight each other.

Common prompt testing mistakes

Scoring only craft and never running Input B. A high AI prompt checker style mark can still ship a liar.

Running 5 friendly demos and calling it prompt evaluation. That's theater.

Changing the pass rule after you see a pretty answer. Write rules first.

Assuming PromptMake includes a numeric prompt testing score. It doesn't. Use Enhance, then your rubric.

Copying a SurePrompts 0-100 number into a PR as proof of factual accuracy. That score is craft, per their public docs.

Jumping to Promptfoo before you can state 2 inputs and 8 checks aloud.

Editing the live production string in the chat UI while you "test." Branch the text. Paste once. Keep the prior version.

Soft next steps for prompt testing with PromptMake

Take 1 prompt you paste weekly. Score it with the 8 checks. Fail it on purpose with a hostile input. Repair with a human edit or with Enhance at https://promptmake.net/text, then re-score. Save the winner next to the 2 inputs. Next week, re-run both inputs after any model bump. When that ritual feels too small for the risk, move the same rows into the production prompt evaluation sheet. Guest free use on PromptMake is about 3 text runs per day; registered free is about 5. Soft habit, hard bar: score before you paste. You'll feel the difference by Friday.

Prompt testing FAQ

What's prompt testing in plain English?

Prompt testing means you score a draft prompt against written checks and sample inputs before you rely on the model output. You catch missing format lines, missing refuse rules, and friendly-only demos. It's smaller than a full production eval suite and larger than a gut feel. Use it every time a prompt will be reused or shown to customers.

How does an AI prompt checker fit into prompt testing?

An AI prompt checker usually grades craft: role, specificity, structure, format, and similar traits. Some products publish a 0-100 breakdown; SurePrompts documents a free deterministic browser score as of 2026. Prompt testing adds behavioral runs on frozen inputs. Use a checker or the 8-check rubric for craft, then still run Input A and Input B. Craft alone isn't prompt evaluation for ship decisions.

Do I need Promptfoo for basic prompt testing?

No. Promptfoo helps when you want repeatable grids, CI gates, and model-graded asserts at scale. Basic prompt testing needs a rubric, 2 inputs, and honesty. Automate after the sticky note already catches real fails. A future comparison article covers Promptfoo versus manual workflows in depth; this page stays on the manual examples.

How is prompt testing different from prompt evaluation?

Prompt testing here is the quick preflight before paste. Prompt evaluation is the gated discipline with golden sets, thresholds, and release owners, detailed in prompt-evaluation-framework. You can do prompt testing alone for personal macros. You shouldn't ship high-risk product prompts on prompt testing alone once 2 people share the string.

Does PromptMake score prompts during prompt testing?

No public 0-100 scorer ships in PromptMake. The product generates and enhances prompts for chosen model dialects at https://promptmake.net/text. Bring your own rubric or use a dedicated checker product if you need a shared number. After Enhance, re-run the 8 checks and your 2 sample inputs before you paste.

What should I fix first when prompt testing fails?

Fix Checks 8 and 5 first when the model invents facts: refuse lines plus hard constraints. When format drifts, fix Checks 4 and 7 (state the shape, show 1 example). When outputs feel generic, fix Check 3: swap soft adjectives for numbers and enums. Re-score craft, then re-run both inputs. Don't celebrate a prettier tone that still fails Input B.

Can prompt testing use an LLM as a judge?

Yes for prose axes you can't reduce to schema or string checks, but pin the judge prompt and calibrate on a few human-labeled cases first. Guides from Promptfoo, Arize, and Langfuse all stress clear rubrics and bias controls. For 10-minute prompt testing, binary human marks on 2 inputs beat an uncalibrated judge. Add a judge when volume grows and humans agree on the rubric.

How do I start prompt testing on a free tier today?

Pick 1 live draft, print the 8 checks, and mark P/F. Write Input A and Input B with pass rules, then repair fails by hand or with a free Enhance run on PromptMake /text (about 3 guest runs per day, 5 when registered). Paste once into your chat model and keep the note. Tomorrow, reuse the same inputs; that's enough prompt testing to stop blind pastes without building CI.

Ready to generate your own prompts?

Free. No sign-up required. Works with all major AI models.

Related articles