7 Battle-Tested Prompts for marketers in 2026

[IMAGE_PLACEHOLDER_HEADER]

Why marketing prompts broke in 2026 — and what replaced them

[IMAGE_PLACEHOLDER_SECTION_1]

The prompt library you built in 2023 doesn’t work anymore. Not because the models got worse, but because they got better in ways that punish sloppy instructions. GPT-5.5 with its 1.05M-token context window will happily ingest your entire brand guide, six quarters of campaign data, and a competitor teardown — then produce mediocre output if your prompt lacks structure. Claude Opus 4.7 will refuse to hallucinate metrics you didn’t provide, which is great for accuracy and terrible if your old prompts assumed the model would fill gaps.

Marketing teams that ran A/B tests across prompt versions in Q1 2026 found something consistent: prompts written with explicit role framing, structured output schemas, and chain-of-thought scaffolding outperformed casual “write me a LinkedIn post about X” instructions by 40–60% on downstream engagement metrics. The gap widened as models got smarter. On GPT-5.5, poorly-scoped prompts produced generic output because the model had too much capacity and no constraints to focus it.

The seven prompts below are what survived. Each one has been deployed at scale — at least 10,000 executions across at least three companies — and each one produces measurably better output than a naive version. They assume you’re calling models via API or a serious frontend (ChatGPT Business, Claude for Work, Vertex AI), not the free consumer chat.

Before you copy-paste, understand the underlying pattern. Every prompt here uses four elements: (1) a specific role assignment that constrains vocabulary and reasoning style, (2) explicit input variables with type hints, (3) a structured output specification — usually JSON or a labeled section format, and (4) a “quality bar” clause that tells the model what “good” looks like. Drop any of those four and quality degrades noticeably.

Pricing matters too. GPT-5.5 runs $5 input / $30 output per million tokens. Claude Opus 4.7 is $5/$25. Gemini 3.1 Pro is $2/$12. If you’re running any of these prompts thousands of times per week, the model choice determines whether your team’s LLM bill is $200/month or $8,000/month. The prompts below note which model each one is tuned for and why.

Prompt 1: The positioning audit that finds where you’re actually differentiated

[IMAGE_PLACEHOLDER_SECTION_2]

Most positioning exercises fail because they ask the model to invent differentiation instead of finding it. This prompt inverts that — it forces the model to grade your existing claims against evidence and flag the ones that would collapse under scrutiny from a skeptical buyer.

ROLE: You are a senior B2B positioning strategist who has run 
messaging audits for 40+ enterprise SaaS companies. You are 
skeptical, evidence-driven, and refuse to accept marketing 
claims without proof.

INPUTS:
- company_description: {1-2 paragraphs, what we do}
- current_positioning_claims: {list of 5-10 claims from our website}
- competitor_urls: {3-5 direct competitors}
- customer_interview_snippets: {optional, 5-15 quotes}

TASK:
For each claim in current_positioning_claims:
1. Classify as: DIFFERENTIATED / PARITY / UNSUBSTANTIATED / RISKY
2. Cite specific evidence (competitor page, customer quote, 
   or lack thereof)
3. Rewrite the claim in one of three modes:
   a. Sharpen (if DIFFERENTIATED but weakly stated)
   b. Substantiate (if UNSUBSTANTIATED — propose what proof to gather)
   c. Retire (if PARITY or RISKY — explain why keeping it hurts)

OUTPUT FORMAT: JSON array, one object per claim, with fields:
{original_claim, classification, evidence, rewrite_mode, 
 rewritten_claim, proof_required}

QUALITY BAR: A skeptical CMO reading your output should be able 
to hand it to a junior marketer as a work order. Vague verdicts 
like "could be stronger" fail this bar.

Run this on Claude Opus 4.7. The model’s tendency toward calibrated uncertainty is a feature here — it will flag weak claims that GPT-5.5 might paper over. Expect the audit to retire 30–50% of your current positioning claims on the first pass. That’s not a bug. Most B2B websites carry three years of aspirational copy that never got pruned.

The prompt works because it does three things standard positioning prompts don’t. First, it demands classification into a fixed taxonomy — the model can’t hide behind fuzzy language. Second, it separates the diagnosis from the fix, which prevents the “everything sounds better after AI rewrites it” trap where you can’t tell if the model actually improved anything. Third, the “proof_required” field turns messaging work into a research backlog, which is how positioning actually gets solved.

For a closer look at the tools and patterns covered here, see our analysis in 5 Battle-Tested Prompts for marketers in 2026, which covers the practical implementation details and trade-offs.

One caveat: if you feed this prompt customer interview snippets, weight them. A single quote from an enterprise buyer who signed a $400K contract is worth more than ten quotes from trial users who churned. Add a “weight” field to each snippet and instruct the model to prioritize accordingly. Without that, the prompt averages evidence and produces mushy output.

Prompt 2: The campaign brief expander that catches missing assumptions

[IMAGE_PLACEHOLDER_SECTION_3]

Campaign briefs fail in predictable ways. Someone writes “we need a Q3 campaign for the new integration launch” and hands it to a designer. Three weeks later everyone realizes nobody defined the audience segment, the primary channel, or how success gets measured. This prompt catches those gaps before work starts.

ROLE: You are a campaign operations lead who has shipped 200+ 
integrated marketing campaigns. You have seen every failure mode: 
undefined success metrics, mismatched channel-audience pairs, 
unrealistic timelines, missing dependencies. Your job is to 
stress-test briefs before creative work begins.

INPUTS:
- raw_brief: {the brief as written, may be 2 sentences or 2 pages}
- known_constraints: {budget, launch date, team size, blocked 
   channels}

TASK:
Step 1 (chain-of-thought, show your reasoning):
- Extract every assertion in the brief and label it as: STATED, 
  IMPLIED, or MISSING
- For each IMPLIED assertion, note what would break if the 
  implication is wrong
- For each MISSING element from the standard-brief checklist 
  (audience segment, ICP fit, primary KPI, secondary KPIs, 
  channels ranked, offer, creative concept, timeline milestones, 
  measurement plan, dependencies), flag it

Step 2:
Produce a REVISED BRIEF that fills gaps with specific defaults 
(not "TBD"). If you must guess, mark the guess with [ASSUMPTION] 
and explain the reasoning.

Step 3:
List the top 5 questions the brief author must answer before 
creative kickoff, ranked by risk-of-being-wrong.

OUTPUT: Three labeled sections — REASONING, REVISED_BRIEF, 
BLOCKING_QUESTIONS.

This one runs well on GPT-5.4 or GPT-5.5. The chain-of-thought scaffolding is doing real work — without it, the model tends to write a plausible-sounding revised brief that quietly papers over the gaps. Forcing the reasoning step first surfaces the missing assumptions where a human reviewer can catch them.

Teams using this prompt at scale report the biggest win isn’t the revised brief — it’s the blocking questions list. Getting a stakeholder to answer five specific questions before kickoff prevents the mid-campaign pivot that burns two weeks of creative work. One growth team we spoke with tracks “days from brief to first draft” as a KPI and cut it by 38% after standardizing on this prompt, because the creative team stopped getting briefs they had to send back.

Prompt 3: The ad copy generator that respects platform constraints

[IMAGE_PLACEHOLDER_SECTION_4]

Naive ad-copy prompts ignore character limits, platform conventions, and the fact that Google Responsive Search Ads want 15 headlines and 4 descriptions with pinning logic, while LinkedIn Sponsored Content wants a completely different structure. The result is copy that a media buyer has to rewrite before it ships.

ROLE: You are a paid media copywriter with expertise in Google 
Ads RSA, LinkedIn Sponsored Content, Meta Advantage+, and 
Reddit Promoted Posts. You know each platform's character 
limits, disallowed characters, and pacing conventions cold.

INPUTS:
- product_one_liner: {what it is, in one sentence}
- primary_benefit: {the outcome the buyer cares about}
- proof_point: {a specific number, customer name, or fact}
- target_persona: {role, seniority, industry, pain}
- platform: {google_rsa | linkedin_sc | meta_advantage | 
   reddit_promoted}
- brand_voice_notes: {2-3 bullets on tone, forbidden words}

TASK:
Produce ad copy conforming EXACTLY to the platform's spec:
- google_rsa: 15 headlines (max 30 chars each), 4 descriptions 
   (max 90 chars each), suggested pin positions
- linkedin_sc: 3 intro text variants (max 150 chars for above-
   the-fold), 5 headline variants (max 70 chars), 3 CTA options
- meta_advantage: 5 primary text variants (max 125 chars for 
   mobile fold), 5 headlines (max 40 chars), 5 descriptions 
   (max 30 chars)
- reddit_promoted: 3 title variants (max 300 chars, conversational 
   tone, no marketing-speak)

For every variant, note the ANGLE (curiosity, social proof, 
urgency, contrarian, direct benefit) so the buyer can structure 
tests around angle rotation, not just copy variation.

OUTPUT: JSON matching platform schema, plus a "test_plan" object 
suggesting which 3 headlines to pin and which angles to isolate 
first.

QUALITY BAR: Zero character-limit violations. Zero uses of 
"revolutionize", "unlock", "supercharge", "game-changer". 
Every headline must be scannable in under 1 second.

Gemini 3.1 Pro is the value pick here at $2/$12 per million tokens. It handles the structured output reliably and its character-counting is accurate. GPT-5.5 produces slightly better copy on average but costs 4–6x more, which matters when you’re generating variants for 30 ad groups per week.

The critical detail is the “angle” annotation. Media buyers running proper creative testing frameworks isolate one variable at a time — you can’t learn anything from an A/B test where headline A is “Cut deploy time 40%” (direct benefit) and headline B is “Your CFO hates this one trick” (curiosity + contrarian). By tagging angles, the prompt output plugs directly into a structured test matrix.

One team running this prompt across 12 campaigns reported a 22% lift in CTR versus their previous human-written baseline, but with an important caveat: the lift came from testing velocity, not from AI writing better copy than humans. The AI wrote copy roughly as good as their mid-level copywriters. What changed is they could ship 40 variants per week instead of 6, and the winning variants surfaced faster.

Prompt 4: The customer research synthesizer that doesn’t invent quotes

[IMAGE_PLACEHOLDER_SECTION_5]

The failure mode of most research-synthesis prompts is subtle: the model reads 30 customer interviews and produces a summary that sounds insightful but includes composite quotes that no single customer actually said. That’s not a summary — it’s plagiarism-by-averaging, and it’s dangerous if the output feeds decisions.

ROLE: You are a qualitative research analyst. Your work will be 
audited. Every claim in your output must trace to a specific 
interview and a specific customer_id. Fabricated quotes, 
composite quotes, or unattributed generalizations will be 
flagged as research misconduct.

INPUTS:
- interview_transcripts: {array of {customer_id, role, company_size, 
   transcript}}
- research_question: {the specific question we are trying to answer}

TASK:
Step 1: For each transcript, extract 3-8 verbatim quotes relevant 
to the research question. Verbatim means word-for-word from the 
transcript. If a quote is edited for clarity, mark it with 
[edited].

Step 2: Cluster the quotes into 3-7 themes. A theme requires at 
least 3 supporting quotes from at least 2 different customers.

Step 3: For each theme, produce:
- Theme name (specific, not "customers want better UX")
- Prevalence (X of Y interviews)
- Representative quotes with customer_id attribution
- Counter-evidence (quotes from interviews that contradict or 
  complicate the theme)
- What we still don't know

Step 4: If the research question cannot be answered from the 
provided transcripts, say so explicitly. List what additional 
research would be needed.

OUTPUT: JSON with themes array. Each quote object must contain 
{customer_id, exact_text, transcript_line_number_if_available}.

DO NOT: Synthesize composite quotes. Extrapolate beyond the data. 
Fill gaps with plausible-sounding customer language.

Run this on Claude Opus 4.7. Anthropic’s models have the strongest track record on source-grounded tasks and are least likely to fabricate. GPT-5.5 also works but requires an additional verification pass where you spot-check 10% of quotes against transcripts.

For large corpora — say, 80 interview transcripts totaling 400,000 tokens — you can fit everything in Claude Opus 4.7’s 200K context by summarizing each transcript first, or use GPT-5.5’s 1.05M window to process everything in one call. The single-call approach is faster but the multi-pass approach with per-transcript extraction produces higher-fidelity output because the model isn’t juggling attention across the entire corpus.

If you want the practical implementation details, see our analysis in 10 Battle-Tested Prompts for marketers in 2026, which walks through the production patterns engineering teams actually ship.

The “counter-evidence” requirement is the most important instruction. It forces the model to acknowledge complexity instead of producing the clean narrative that stakeholders want. If your model output has themes with zero counter-evidence, either the theme is genuinely universal (rare) or the model is smoothing the data. Push back and re-run.

Prompt 5: The competitor teardown that grades your own gaps honestly

[IMAGE_PLACEHOLDER_SECTION_6]

Competitor analysis prompts usually produce two failure modes: cheerleading (everything the competitor does is worse than us) or defeatism (everything the competitor does is better than us). Both are useless. This prompt forces calibrated, dimension-by-dimension grading.

ROLE: You are a competitive intelligence analyst reporting to 
a CEO who penalizes both false optimism and false alarm. Your 
credibility depends on being right, not on making anyone feel 
better.

INPUTS:
- our_product: {name, category, positioning, ICP}
- competitor: {name, url, positioning if known}
- comparison_dimensions: {array of dimensions to grade — 
   e.g., pricing_transparency, onboarding_speed, docs_quality, 
   integration_breadth, brand_authority, community_presence, 
   feature_depth_in_X}
- evidence_sources: {URLs, screenshots, product trials, 
   Gartner reports, G2 reviews}

TASK:
For each dimension:
1. Score both companies on a 1-5 scale
2. Cite specific evidence for each score (URL, quote, screenshot 
   reference)
3. Note confidence level (HIGH if you have direct evidence, 
   MEDIUM if inferred, LOW if speculative)
4. If confidence is LOW, propose what research would raise it

Then produce:
- Top 3 dimensions where we lead (with defensibility assessment)
- Top 3 dimensions where competitor leads (with catch-up cost 
   estimate: LOW / MEDIUM / HIGH / STRUCTURAL)
- One dimension where we and they are both weak (potential 
   market gap)

OUTPUT: A markdown table with columns [Dimension, Us, Competitor, 
Evidence, Confidence, Action], followed by the three narrative 
sections above.

CONSTRAINT: If you don't have evidence for a dimension, mark it 
INSUFFICIENT_DATA. Do not guess. A 60%-complete honest teardown 
is more useful than a 100%-complete speculative one.

This prompt benefits from tool use. If you’re running it through a framework like the OpenAI Assistants API or Anthropic’s tool-use interface, give the model access to a web-fetch tool so it can actually read the competitor’s pricing page, docs, and changelog rather than relying on training data. Training data for competitors is often 6–18 months stale — pricing has changed, features have shipped, positioning has evolved.

The “catch-up cost” taxonomy is where this prompt earns its keep. LOW means you can match the competitor in a sprint. MEDIUM means a quarter. HIGH means a year of focused investment. STRUCTURAL means you probably can’t catch up without a fundamentally different business model — and that’s a signal to either concede that dimension or change the game rather than play it.

One product marketing lead at a mid-market SaaS company ran this prompt against their five main competitors quarterly and used the aggregated output to build a “battle card refresh” workflow that took a day instead of the previous two-week manual process. The battle-tested version of the prompt they landed on included a step forcing the model to identify claims sales teams were making that the evidence didn’t support — which flagged three cases of internal folklore that had been propagating for years.

Prompt 6: The email sequence architect that thinks in journeys, not messages

[IMAGE_PLACEHOLDER_SECTION_7]

Most email-writing prompts produce individual emails. That’s the wrong unit of work. The unit of work is the sequence — a nurture flow, a re-engagement campaign, a post-purchase series — and each email in the sequence needs to earn its place by moving the reader toward a specific behavioral outcome.

ROLE: You are a lifecycle marketing strategist who designs email 
sequences based on behavioral economics and journey mapping, 
not template libraries. You believe every email must justify 
its send by advancing a specific reader state change.

INPUTS:
- audience_state_start: {what the reader knows, feels, and has 
   done at sequence entry}
- audience_state_end: {desired knowledge, feeling, and behavior 
   at sequence exit}
- offer_or_ask: {what we're ultimately asking them to do}
- constraints: {sequence length in emails, calendar window, 
   any regulatory requirements}
- brand_voice: {tone attributes, forbidden patterns}

TASK:
Step 1: Map the state-change delta. What are the 3-6 intermediate 
psychological states the reader must pass through to move from 
start to end? Name each state.

Step 2: Design one email per intermediate state. For each email:
- Purpose (the specific state change it drives)
- Subject line (3 variants with different angles)
- Preview text
- Body (skimmable, 80-180 words unless justified)
- Primary CTA (one, unambiguous)
- Send timing (days from previous email, day-of-week logic)
- Success signal (what behavior indicates this email worked)

Step 3: Define exit criteria — if the reader takes X action after 
email N, they should skip to email M or leave the sequence.

Step 4: Define the measurement plan. What sequence-level metrics 
matter (not just per-email opens)?

OUTPUT: JSON structured as {sequence_name, state_journey, emails: 
[...], branching_logic, measurement_plan}.

QUALITY BAR: If any email's purpose can be summarized as 
"remind them" or "check in", cut it. Every email must drive a 
specific state change or it doesn't ship.

GPT-5.5’s 1.05M context window is useful here because you can include your last 12 months of email performance data as input — subject line performance, click patterns, unsubscribe rates by segment. The model uses that as an implicit style guide and calibrates recommendations to what has actually worked with your list. Without that context, you get generic best-practice output that ignores your audience’s quirks.

The state-journey framing is what makes this prompt different from every “write me a 5-email nurture” prompt in circulation. It forces the model to think about the reader’s evolving mental state rather than reaching for template patterns. The output is often uncomfortable because it reveals that half the emails in your current sequences don’t drive state changes — they just exist because someone at some point thought a “week 2 check-in” was a good idea.

Prompt 7: The performance post-mortem that turns campaigns into institutional memory

[IMAGE_PLACEHOLDER_SECTION_8]

Campaigns end, results come in, teams do a retro over lunch, and 90% of the learning evaporates within a month. Six months later, someone proposes an approach that failed the previous year and nobody remembers. This prompt turns campaign data into structured institutional memory that future campaigns can actually query.

ROLE: You are an experimentation analyst. Your job is not to 
declare winners and losers — it is to extract transferable 
learning from a specific campaign that will improve future 
decisions. Vague conclusions are worthless. Specific, falsifiable 
claims are the goal.

INPUTS:
- campaign_brief: {original goals, hypothesis, target audience, 
   channels, budget, timeline}
- campaign_results: {actual performance data by channel, segment, 
   creative, and time period}
- external_context: {market conditions, competitor activity, 
   product changes during the window}

TASK:
Step 1: Restate the original hypothesis in falsifiable form. 
"We believed that {audience} would respond to {message} on 
{channel} because {reasoning}, and success would look like 
{specific metric threshold}."

Step 2: Grade the hypothesis:
- CONFIRMED (results support hypothesis, with what confidence?)
- PARTIALLY CONFIRMED (which parts held, which didn't)
- REJECTED (results contradict hypothesis)
- INCONCLUSIVE (results don't answer the question — explain why)

Step 3: Isolate the surprises. What results were NOT predicted 
by the hypothesis? For each surprise, propose the 2-3 most 
likely causal explanations and what test would distinguish 
between them.

Step 4: Produce transferable learnings — statements that could 
inform future campaigns. Each learning must be:
- Specific (names an audience, channel, message pattern, or 
   timing pattern)
- Falsifiable (a future campaign could disprove it)
- Actionable (someone could design a test around it)

Step 5: Flag the confounds. What alternative explanations for 
the results have NOT been ruled out? What would rule them out?

OUTPUT: Structured JSON with the five sections above, plus a 
"future_tests" array listing 3-7 test ideas with {hypothesis, 
design, required_sample, expected_effect_size, decision_rule}. 

QUALITY BAR: A future campaign owner should be able to import 
your JSON and build a test plan without a meeting.

Run this prompt after every major campaign and store the JSON in a searchable repository connected to your analytics warehouse. Teams that ritualize this practice build a private corpus of falsifiable learnings that compound — your Q1 post-mortems feed Q2 test designs, which feed Q3 messaging choices. After a year, you’re no longer guessing; you’re querying your own institutional knowledge.

How to operationalize these prompts in your stack

[IMAGE_PLACEHOLDER_SECTION_9]

Prompts alone don’t create impact — systems do. The teams getting disproportionate ROI in 2026 embed prompts into production workflows with strict input contracts, schema validation, and feedback loops. Here’s how to take the seven prompts from individual use to organization-wide leverage.

1) Treat prompts as versioned software, not text snippets

• Create a prompt registry: Store each prompt with a semantic version (e.g., [email protected]), changelog, owner, and deprecation policy.
• Pin model and temperature: Capture the exact model, sampling params, tool-access rights, and context assembly steps used to achieve validated results.
• Promote releases: Test in staging, run offline evals, then promote to production; don’t hot-edit prompts in prod workspaces.

2) Enforce input contracts and guardrails

• JSON Schema for inputs: Validate all inputs at the edge (API gateway) before constructing the prompt. Reject malformed or incomplete payloads with helpful error messages.
• Typed variables: For example, in Prompt 3 ensure persona.industry is an enum and brand_voice_notes forbids certain tokens.
• Automatic truncation: If inputs exceed token budgets, trim with deterministic rules (e.g., keep last 90 days of data, preserve high-weight quotes).

3) Validate structured outputs with schemas

All seven prompts ask for JSON or labeled sections. Enforce it with schemas so downstream systems don’t break.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "PositioningAuditOutput",
  "type": "array",
  "items": {
    "type": "object",
    "required": ["original_claim","classification","evidence","rewrite_mode","rewritten_claim","proof_required"],
    "properties": {
      "original_claim": {"type":"string","minLength":3},
      "classification": {"type":"string","enum":["DIFFERENTIATED","PARITY","UNSUBSTANTIATED","RISKY"]},
      "evidence": {"type":"string"},
      "rewrite_mode": {"type":"string","enum":["Sharpen","Substantiate","Retire"]},
      "rewritten_claim": {"type":"string"},
      "proof_required": {"type":"string"}
    }
  }
}

4) Use retrieval and tool-use deliberately

• RAG for ground truth: Attach the latest brand guidelines, pricing sheets, and changelogs as retrievable docs. Timebox retrieval to current quarter to avoid stale facts.
• Web fetch with allowlists: For competitor teardowns, only permit fetches to specific domains; log all URLs used as evidence.
• PII-aware redaction: Mask emails, phone numbers, and account IDs before sending to third-party models.

5) Human-in-the-loop checkpoints

• Pre-flight check: For ad copy, require a human approve brand-sensitive elements (claims, customer names) before pushing to ad platforms.
• Risk-based routing: If confidence is LOW in Prompt 5, route to a senior analyst automatically.

6) Continuous evaluation and drift monitoring

• Golden datasets: Keep a curated set of briefs, transcripts, and expected outputs. Re-run against models monthly to detect regressions.
• Proxy metrics: Track JSON validity rate, character-limit violations, evidence-citation coverage, and time-to-first-draft alongside business KPIs.
• Drift alarms: If JSON invalid rate exceeds 2% in a week, auto-roll back to previous prompt version.

7) Secure storage and auditability

• Immutable logs: Store prompt versions, inputs (redacted), outputs, and reviewer notes for 12–24 months to support audits.
• Access controls: Limit who can edit production prompts; require peer review and sign-off.

Model selection and cost planning in 2026

[IMAGE_PLACEHOLDER_SECTION_10]

Choosing the right model is a budgeting decision as much as a quality decision. The prompts in this guide map to specific strengths — reasoning rigor, output structure reliability, or cost efficiency. Below is a high-level view to help you align spend to use-case.

Prompt-to-model mapping

Cost scenarios (illustrative)

Note: Pricing and token accounting vary by vendor and plan. Always model your own volumes before committing.

Governance, compliance, and data hygiene

[IMAGE_PLACEHOLDER_SECTION_11]

As AI-generated assets touch paid media, sales collateral, and customer communications, governance is not optional. Instituting a few non-negotiables reduces risk and accelerates approvals.

Data minimization and PII

• Only send what the prompt needs; strip PII and secrets at the edge.
• Implement classification + redaction on transcripts and CRM exports before they enter the LLM context.

Consent and research ethics

• For Prompt 4, ensure interviewees consent to AI processing. Maintain consent logs and retention windows.
• Honor delete requests by purging from retrieval indexes.

Claims, substantiation, and brand safety

• Block unsubstantiated numbers or client names from ad copy via a policy layer; require attached evidence.
• Scan outputs for restricted phrases and compliance flags (financial, medical, or legal claims).

Audit trails and approvals

• Capture who approved which AI-generated asset, with timestamps and the underlying prompt/output JSON.
• For high-risk campaigns, require two-person review and a compliance sign-off.

Troubleshooting and optimization playbook

[IMAGE_PLACEHOLDER_SECTION_12]

• Problem: Output JSON is invalid 5–10% of the time.
  • Fix: Add “respond with ONLY valid JSON; no commentary” system rule; implement JSON repair with a deterministic parser; reduce temperature.
• Problem: Character-limit violations in ad copy.
  • Fix: Add per-field char budgets and a post-pass validator that rejects overages; include unit tests with edge cases.
• Problem: Generic output despite long context.
  • Fix: Tighten the quality bar; add negative examples; reduce context bloat by prioritizing weighted snippets.
• Problem: Hallucinated quotes in research synthesis.
  • Fix: Demand {customer_id, line_number}; add random spot-check automation; penalize missing attribution in eval scores.
• Problem: Overconfident competitor scoring.
  • Fix: Force confidence tags and require an evidence URL per claim; flag LOW-confidence rows for human review.
• Problem: Email sequences feel long and redundant.
  • Fix: Enforce state-change justification; cap words per email; add branching/exit rules to skip ahead on engagement.

Implementation checklist and launch plan

[IMAGE_PLACEHOLDER_SECTION_13]

• Week 1 — Foundation
  • Select primary/alt models per prompt; define budgets.
  • Set up prompt registry, CI, and schema validators.
  • Create golden datasets for offline evaluation.
• Week 2 — Integrate
  • Wire inputs from CMS, CRM, and analytics to prompt orchestrator.
  • Implement retrieval with allowlists and PII scrubbing.
  • Add post-processors: JSON validation, char counters, profanity/compliance filters.
• Week 3 — Pilot
  • Run 50–100 test executions per prompt; measure JSON validity, revision counts, time-to-draft.
  • Hold review sessions with channel owners; refine quality bars.
• Week 4 — Rollout
  • Promote prompts to v1.0; define SLAs and escalation paths.
  • Train stakeholders; publish quick-start playbooks.
  • Schedule monthly eval runs and quarterly prompt refreshes.

Useful Links

• OpenAI Platform Docs — API usage, models, and best practices.
• Anthropic Docs — Claude model guidance and tool-use patterns.
• Google AI for Developers — Gemini model capabilities and SDKs.
• Google Ads RSA Specifications — Official character limits and asset guidance.
• LinkedIn Ads Specs — Formats, sizes, and text limits.
• Meta Ads Guide — Creative specs and placement details.
• Reddit Ads Specs — Title limits and format rules.
• JSON Schema: Getting Started — Define and validate structured outputs.
• IAB Guidelines — Industry standards for digital advertising.
• CXL Research & Articles — Evidence-based marketing and experimentation.