How to Give AI Examples Without Making It Copy Them
Give AI a competitor page or an old email as an example and it hands back a near-clone — same sentence skeleton, the reference's phrases and claims carried straight over. You wanted the style; you got the text. Here's how to give examples as a signal, not a copy source.
Diff Your Draft Against the ReferenceWhen "here's an example" turns into a near-clone
You paste a competitor's landing-page hero, an old email that worked, or three posts in the tone you like, and you say "make mine like this." What comes back isn't inspired by the example — it's the example with the nouns swapped. Same sentence skeleton, the same "in minutes, not days" rhythm, the reference's claims and named entities carried straight into your copy. You wanted the AI to learn what makes the example good; instead it treated the example as a thing to reproduce.
That's the failure this guide is about. An example is one of the strongest signals you can hand a model — and by default it reads it as "produce more of this," not "understand why this works." The fix is to give examples with a boundary: say what the example is for, mark what to learn and what not to reuse, pull the principles out before any drafting, write from your own facts, and then check the result against the reference so you can actually see what carried over. A boundary like that lowers the risk of over-copying. It doesn't guarantee originality, and it isn't a copyright clearance — whether the output is too close, and whether using the reference was appropriate in the first place, stays your call.
Why the model copies the example instead of learning from it
A model learns as much from what you show it as from what you tell it — often more. A concrete example is a vivid, specific target, and "be original" is a vague instruction, so when the two compete the example usually wins: the model imitates the thing in front of it. That tendency is genuinely useful when you want it (it's how a sample locks in a JSON shape), and a liability when you don't. It gets worse when you hand over an example without saying what you actually want from it, because then every surface feature — the wording, the structure, the claims, the CTA — reads as something to match. Here's what gets copied when there's no boundary:
- The sentence skeleton. The reference's exact rhythm and structure come through, just with your words dropped into the slots.
- The signature phrases. A memorable line like "minutes, not days" or "before lunch" gets lifted verbatim because it read as the point.
- The claims and numbers. The example's proof — its stats, its guarantees, its customer names — end up asserted about your product, whether or not they're true of it.
- The outline. The same heading order and section flow, copied as if the structure were the content.
- Invented mechanics. To fit a borrowed frame, the model fills in product details you never gave it — an "upload" step, a "template" your product doesn't have.
Step 1: Say what the example is actually for
The model copies indiscriminately partly because you never told it which layer of the example you care about. An example can be a reference for the voice, the structure, the tone, the formatting, the level of detail — or it can be a negative example of what to avoid. Those are different instructions, and "like this" collapses them into "all of it." So name it: "use this only as a reference for pacing and how it leads with an outcome," or "copy the section order but nothing else," or "this is the tone, not the wording."
Labeling the example does two things at once. It tells the model what to extract, and — just as usefully — it tells it what to ignore, which is the part that gets over-copied. A reference you've scoped to "voice only" has no license to bring its claims along; a reference you've scoped to "structure only" has no license to reuse its sentences. The narrower and clearer the label, the less of the example leaks into places you didn't intend.
Step 2: Write a use / do-not-use split
Make the boundary explicit as two lists. Use: the transferable, abstract things — clarity, pacing, the logic of the sections, the level of detail, the outcome-first framing. Do not use: the concrete, ownable things — the exact phrases, the specific claims and numbers, the named entities and offers, the CTA wording, and any fact that's true of the reference but not of you. The distinction that matters is abstract-versus-concrete: principles are safe to learn from, specifics are the reference's own.
If you give examples often, capture this as a reusable prompt instead of retyping it. The Prompt Template Builder can hold the boundary as a template with named slots — a `{{reference}}` for the example, a `{{transfer}}` list, a `{{do_not_transfer}}` list, and a `{{new_facts}}` slot for your own material — so the same use/do-not-use structure travels to the next example instead of being rebuilt. It holds and formats the prompt; the model does the writing when you run it, and you still judge whether it respected the split. (If you'd rather the rule apply to every request in a session, the same do-not-copy instruction can live as a standing behavior in a system prompt — but a "do not copy" line reduces the risk, it doesn't remove it, which is why the review in Step 5 exists.)
Step 3: Pull the principles out before any writing
The single move that most reliably prevents copying is to separate understanding the example from producing your version. Before it drafts anything, ask the model to answer three questions about the reference: what makes this work, which of those principles should transfer, and which specifics must not. That produces a short example-use plan — a list of abstracted lessons — and it's the plan, not the example itself, that the drafting step then works from.
This matters because paraphrasing and principle-extraction look similar and aren't. If you ask the model to "rewrite this in my words," it stays anchored to the original sentence by sentence and you get a thesaurus pass — the structure and claims survive the reword. If you ask it first to name why the example works and then to write from those principles with the example set aside, it's building from an idea rather than editing a text. The gap between those two prompts is the gap between inspired-by and copied-from.
Step 4: Give it your own facts so the content is yours
A borrowed frame stays borrowed until you fill it with your own material, so the drafting step needs your real substance: your product's actual capabilities, your audience, your proof. When the model has genuine facts to work with, it stops reaching for the reference's — the reason it carried over "upload your data" was that it had a frame and no facts of its own to put in it. Your facts are what make the output about your thing instead of a reskin of theirs.
The discipline to insist on here is that the model uses only what you actually gave it. The Landing Page Hero Copy Prompt is a good model of that rule in the copy domain: it writes a hero from your positioning and proof, requires that every claim trace back to what you pasted, marks anything unsupported as needing evidence rather than inventing it, and returns genuinely different headline angles instead of one reworded near-duplicate. Borrow that instinct whatever you're writing — the reference can inform how you say it, but the what has to come from you, and a claim you can't back with your own proof doesn't belong in your copy just because it was convincing in someone else's.
Step 5: Diff the output against the reference
You can't tell how much of the example survived by reading the output on its own — it looks original in isolation, the same way it looked finished. So put them side by side. The AI Text Diff Checker does this mechanically: paste your output on one side and the reference on the other, and it marks, word for word, exactly what the two share — the repeated skeleton, the lifted phrase, the reused claim. The Compare Two AI Outputs resource shows the same diff in action and is explicit about what it is: a mechanical comparison that reports what changed, not what it means or which text is better.
That last point is the boundary to hold firmly, because a diff is easy to over-read in both directions. Literal overlap is the only thing it sees — so a clean diff with no shared words does not prove your output is original (you can copy a structure or an idea without reusing a single phrase), and a bit of shared wording isn't automatically a problem. A diff surfaces the literal borrowing for you to look at; whether the result is too close to the reference is a judgment you make, not one the diff makes for you.
Common mistakes
The habits that turn a reference into a copy source:
- Pasting the example with "like this." With no label, every surface feature — wording, structure, claims — reads as something to match.
- Asking for a rewrite. "Put this in my words" keeps the model anchored to the original sentence by sentence; you get a reword, not an original.
- Skipping the principle-extraction step. Going straight from example to draft means the example is the draft's template, not its inspiration.
- Letting the reference's claims ride along. A stat or guarantee that's true of the example isn't true of you just because it sounds good — your claims come from your proof.
- Trusting "don't copy" to be enough. The instruction lowers the odds; the example is still a strong pull, which is why you check the output rather than assume.
- Reading a clean diff as originality. No shared words means no literal overlap — not that the structure, idea, or angle wasn't copied, and not that anything is legally clear.
A worked example: a hero from a competitor's hero
Take the most common version of this — a competitor's landing hero used as the example — and watch it go from a near-clone to something learned-from but original.
A reference hero, the near-clone it produces by default, and the same brief handled with an example-use plan and a diff checkTHE REFERENCE (a competitor hero, pasted as the example):
"Launch your team's reports in minutes, not days. Upload your data, choose a
template, and share a polished dashboard before lunch."
WHAT YOU'RE WRITING:
a hero for a different product -- an AI meeting-notes app for remote teams.
THE OVER-COPIED OUTPUT (example used as a copy source):
"Launch your team's meeting notes in minutes, not days. Upload your calls,
choose a template, and share polished notes before lunch."
what carried over: the exact sentence skeleton, "minutes, not days", "before
lunch", the upload/template mechanic -- and it invented a "template" step your
product doesn't even have, to fit the borrowed frame.
THE EXAMPLE-USE PLAN (learn this, don't carry that):
transfer -> lead with the outcome; a time-savings angle; a simple concrete flow
do NOT -> the sentence skeleton; "minutes, not days"; "before lunch";
the upload/template mechanic; the report/dashboard claims
your facts -> remote meetings become searchable notes, action items, and
decisions; no rewriting the call by hand
THE SAFER OUTPUT (written from your facts, example set aside):
"Turn every remote meeting into clear notes, action items, and searchable
decisions -- without rewriting the call by hand."
DIFF CHECK (paste both texts side by side):
- no shared sentence skeleton, no lifted phrases
- no reused claims or named entities from the reference
- no long verbatim runs shared with the reference
(the diff shows only the literal overlap; that it's built from your own facts,
and whether it's "too close", is your call -- not the diff's)Where this fits in NewPrompt
NewPrompt has no plagiarism or originality checker, and this guide doesn't pretend otherwise — what it offers is a way to structure the example and a way to inspect the result. The Prompt Template Builder holds the use/do-not-use boundary as a reusable prompt; the AI Text Diff Checker shows you the literal overlap between your draft and the reference. Neither judges whether the output is original or safe to publish — the diff reveals shared wording, not creative or legal originality, and the decision about whether the borrowing is too much, or appropriate at all, is one you own. The pattern-pulling happens inside your own assistant, off the prompt you assembled — and where the line falls between learning from the reference and lifting it is a line you draw, not one the tools draw for you.
It's worth separating this from the jobs that sit next to it, since they all touch "style" and "examples." Keeping your own writing in a consistent voice across pieces is brand-voice work, and it starts from your voice, not an outside example. Turning a prompt that worked into a reusable one is templating your own prompt, not learning from a sample. And once you've drawn your principles from a reference, the actual drafting — and the later review of whether that draft is accurate and ready — are their own steps. This guide is the narrow thing in the middle: you have an example in front of you, it's genuinely useful, and the trick is to take the lesson without taking the text.