How to Build a Competitor Battlecard With ChatGPT in 30 Minutes

Why Most AI Battlecards Fail Reps

They fail because the model was asked to produce a document, not to report what it actually knows. Given a competitor’s name and a template, ChatGPT fills every box — including the boxes where it has nothing. That’s not a bug in the tool; it’s the tool doing exactly what a document-shaped request asks for.

OpenAI is direct about this in its own documentation on when ChatGPT gets things wrong, which names fabricated quotes, studies and citations as a known failure mode and tells users to verify anything that matters. Our guide to why ChatGPT hallucinates covers the mechanics. For a competitor battlecard, the practical consequence is narrower and sharper: the fabricated lines are always the specific ones, and specific lines are exactly what reps quote.

The bad version isn’t badly written. It’s confident, it sounds like competitive intelligence, and it will get an account executive corrected in front of a buyer. Most sales enablement leads will tell you the same thing: one public correction costs more trust than five missing facts ever did.

What separates the two isn’t prompt length. It’s that the second line existed as a sourced fact before anyone asked ChatGPT to write a card.

The Evidence Ledger Method Explained

An evidence ledger is a three-column table — claim, source, confidence — that every line of the finished competitor battlecard must trace back to. You build the ledger first, generate the card only from ledger rows, then audit the card against the ledger and cut whatever doesn’t match.

Three passes, in that order. Skipping straight to “write me a competitor battlecard” collapses all three into one, which is precisely why the output looks finished and isn’t.

The confidence column is what makes the method work rather than just feel rigorous. Three levels are enough:

• High — the competitor states it themselves, on a page you can link
• Medium — a named customer said it, in a transcript or note you hold
• Low — inferred, and therefore never printed as a fact on the card

Low rows aren’t wasted. They become the questions you ask a prospect instead of the claims you make at them.

Build Your Competitor Battlecard Ledger

This is the pass that takes the time, and it’s the one people skip. Everything downstream is fast because this part was slow. If you’ve already run a broader competitor research session in ChatGPT, you can feed that report in here rather than starting cold.

Gather four things before you open ChatGPT. Every competitor battlecard starts here. Two are public, two are yours, and the second pair is what nobody else in your category has.

• The competitor’s pricing, product and trust or security pages, saved as text
• Two or three recent call transcripts where a prospect mentioned them by name
• Your last few win-loss write-ups involving that competitor
• Your own one-pager, so the model knows what it’s comparing against

Transcripts and win-loss notes carry customer names, deal values and sometimes contract terms. Strip those before anything is uploaded — and check which account you’re in first, because that decision matters more than which plan you pay for.

This step is the one that separates a sourced ledger from a plausible one, and almost nobody writing about battlecards mentions it. Inside ChatGPT’s Deep Research mode, you can limit a research run to specific domains: open the composer, choose Sites, then Manage sites, and add the competitor’s own domain. You can restrict the run to those sites only, or prioritise them while still allowing a wider search. It’s documented in OpenAI’s Deep Research documentation, alongside the research plan you get to review and edit before the run starts.

Point it at the competitor’s own site and your uploaded files, and the model has far less room to reach for a half-remembered review-site summary. If Deep Research isn’t in your tools menu — availability varies by plan and country — ordinary web search plus your uploaded files still runs this method; you just do more of the source-checking yourself.

You are a competitive intelligence analyst supporting a B2B sales team.

Goal: gather facts about [Competitor Name] that a seller could repeat to a prospect without being corrected.

Sources: use only the sites listed for this research task and the files I have uploaded. Do not use review-site summaries, press coverage, or your own background knowledge.

Cover: current plan names and prices, stated feature limits, published integrations, support and onboarding commitments, and anything they have changed in the last six months.

Format: a plain list of factual statements. After each one, name the exact page or file it came from. If something is not stated anywhere in the allowed sources, write "not published" rather than estimating.

Now fold in your own documents and force the three-column structure. The word CUT matters here — it gives the model somewhere to put a claim it can’t support, which is the alternative to inventing a source for it.

You are building an evidence ledger for a competitor battlecard.

Inputs: the research findings above, plus the files I have attached ([call transcripts], [win-loss notes], [our own product one-pager]).

Build a three-column table: Claim | Source | Confidence.

Rules:
- One row per claim. Each claim must be specific enough for someone to disagree with.
- Source names the exact page or file. "General knowledge" is not a source.
- Confidence: High = the competitor states it themselves. Medium = a named customer said it in my files. Low = inferred.
- Do not add rows to make the table look complete. A short ledger is a true ledger.
- Any claim about pricing, security or compliance that you cannot source, mark CUT.

Generate the One-Page Card

Only now does the card get written, and it gets written from the ledger rather than from the competitor’s name. Five blocks, sized so the whole thing fits one screen — a rep scanning mid-call has maybe thirty seconds.

The constraints at the bottom of the prompt below do most of the work. Word ceilings stop the essay, and the “no sourced evidence” instruction gives the model a legitimate way to leave a block thin. That’s negative constraint prompting doing what it does best — telling the model what not to reach for.

You are a product marketer writing a one-page competitor battlecard that account executives will read mid-call.

Build the card for [Our Product] versus [Competitor Name] using ONLY the rows in the evidence ledger above. Ignore every row marked CUT.

Use exactly five blocks:
1. Positioning — one sentence on where we win.
2. Who they win with — the buyer profile that genuinely prefers them, two bullets.
3. Strengths and gaps — three of their strengths, three of their gaps, each with its source in brackets.
4. Objection matrix — a table: Objection | What is really being asked | What the rep says | Proof.
5. Discovery questions — three questions that surface their gaps without naming them.

Constraints:
- No cell longer than twenty words.
- No adjective about our product that a real customer has not used.
- If a block cannot be filled from the ledger, write "no sourced evidence" and move on.
- Do not add a summary, an introduction, or a closing paragraph.

If you want more prompt variations for this — different card shapes, different competitors, a lighter version for SDRs — our companion guide on creating a sales battlecard with AI works through five of them. This article stays on the sourcing pipeline behind a competitor battlecard; that one is the prompt pack.

Audit Every Line Before Sending

The third pass is the whole point, and it takes about four minutes. You’re asking the model to grade its own homework — which sounds naive, and works far better than it should, because the ledger gives it something concrete to grade against.

Run the audit in the same conversation, so the ledger is still in context.

Audit the competitor battlecard you just produced against the evidence ledger above.

For every line in the card, output one row: Card line | Ledger row it came from | Verdict.

Verdict rules:
- KEEP: traces to a High or Medium ledger row.
- FLAG: traces to a Low row, or the wording is stronger than the source supports.
- REMOVE: no ledger row supports it.

List all REMOVE rows first. Do not defend the card and do not rewrite it yet — I will decide what to cut.

Expect three to six REMOVE rows on a first run. That number isn’t a sign the method failed — it’s the count of claims your reps would otherwise have repeated. Read our guide to fact-checking AI research if you want the broader version of this discipline for reports and briefs.

Which ChatGPT Plan Your Team Needs

Here’s the correction most guides get wrong, and it costs teams real money in the wrong direction: paying for Plus does not change what happens to your data. Free, Go, Plus and Pro all default to training-eligible with a user-controlled opt-out. Only Business, Enterprise and Edu workspaces exclude your data from training by default, per OpenAI’s own data controls documentation.

So the plan question isn’t “how good do I need ChatGPT to be”. It’s “whose data goes in” — because a competitor battlecard built from call transcripts is a different risk profile entirely. If the answer includes transcripts, win-loss notes or anything with a customer’s name on it, that’s a workspace decision, not a subscription upgrade — and worth reading alongside our privacy guide for using ChatGPT at work. Prices move; check the current page before you buy.

When Battlecard Prompts Go Wrong

Five things go wrong with competitor battlecard prompts often enough to be worth naming. Four of them are fixed by pushing the work back a stage rather than rewriting the final prompt.

The pattern is worth noticing. A weak card is almost never a prompt problem — it’s a thin ledger wearing a good template. When output disappoints, re-read the ledger before you touch the card prompt.

The one genuine prompt-level failure is the essay. Models drift toward length when nothing caps them, so repeat the word limit in the audit pass.

What This Method Cannot Fix

The ledger fixes sourcing. It does not make you a strategist, and it’s worth being clear about where the machine stops.

Four things stay yours, and pretending otherwise is how teams end up with a technically accurate card that still loses deals:

There’s also a shelf-life problem no prompt solves. A competitor battlecard built today is stale within a quarter, because pricing pages change and the gap you built the card around gets shipped. Rebuilding from scratch every time is why most teams stop after two.

The ledger is what makes the refresh cheap: re-run the scoped research against the same sources, update the rows that moved, and regenerate. That’s the ten-minute version, and it’s the point at which this becomes an ongoing monitoring habit rather than a one-off project. Start with your single most contested competitor, build one card properly, and let your reps tell you which block they actually opened.