Contact
← Back to blog

How to Write High-Accuracy Prompts for ChatGPT (A Practical, Friendly Guide)

Published: 2025年08月26日


Why better prompt design boosts accuracy



LLMs generate the most “probable” response given your instructions and context. That means:


  • Ambiguity ⇒ average answers. Vague asks spread the model’s attention. Clear constraints shrink the search space.
  • Structure ⇒ fewer omissions. When you specify sections and required items, recall improves.
  • Grounding ⇒ fewer hallucinations. Feeding facts, links, or tables steers the model away from guessing.
  • Decomposition ⇒ fewer logic slips. Breaking the task into steps (analyze → decide → write) reduces error chaining.
  • Self-checks ⇒ higher trust. Asking for assumptions, risks, and validation steps surfaces weak spots before you ship.






Core principles (the “RGO-FGQS” checklist)



  1. Role – Set expertise and point of view (e.g., “B2B SaaS PM”).
  2. Goal – Define the business outcome, not just the artifact (“help a CFO decide X”).
  3. Output – Specify format, length band, sections, tone, and audience.
  4. Facts – Provide grounding inputs: data, constraints, definitions, non-goals.
  5. Guardrails – What to avoid, what to flag as uncertainty.
  6. Quality bar – Who will read it, how it will be used, how it will be judged.
  7. Self-verification – Ask for assumptions, risks, test plan, or a brief fact-check plan.



Mini-template

R: … G: … O: … F: … Gd: … Q: … S: …





Practical techniques that consistently raise accuracy




1) Role priming



“You are a {{seniority}} {{domain}} expert…” tunes jargon level, depth, and what counts as “good.”



2) Decompose the work



Ask for phases: clarify inputs → analyze → propose → package.

Example: “First list assumptions (bullet points). Then analyze trade-offs (table). Then recommend one option with a short rationale.”



3) Specify must-haves and non-goals



“Must include ROI math and risks. Do not add generic tips or vendor pitches.”



4) Ground with concrete inputs



Paste key facts, brief datasets, or links. If facts are missing, say: “If information is missing, ask clarifying questions first or proceed with explicit assumptions.”



5) Ask for a brief self-check (not the full chain of thought)



“End with a 3-item self-check: (1) biggest risk, (2) what could be wrong, (3) how to validate quickly.”



6) Draft → critique → refine loop



“Give me a concise draft. Then critique it for missing evidence and bias. Then produce a revised version.”



7) Use evaluation tasks



“Score your output 0–100 against the quality bar, list 3 improvements, then apply them.”





Reusable prompt templates (copy-paste and adapt)




A) Analysis memo



Role: Senior analyst in {{industry}}.

Goal: Help {{stakeholder}} decide {{X}} within {{time/budget}}.

Inputs: {{facts, numbers}}

Output (max 600 words): Executive summary, Options (table with pros/cons/cost/risks), Recommendation, Next steps (week-by-week).

Guardrails: No claims without a source; highlight uncertainties.

Self-check: List top 3 risks and how to de-risk.



B) Product spec outline



Role: Staff PM for {{product}}.

Goal: Draft a one-pager PRD.

Inputs: Problem, users, constraints.

Output: Problem, Goals/Non-goals, Users & JTBD, Requirements (MoSCoW), Metrics, Risks, Open questions.

Format: Markdown, ≤900 words.

Self-check: Conflicts, missing stakeholders, edge cases.



C) Customer email (enterprise)



Role: Customer success lead.

Goal: Write an email to {{persona}} to {{objective}}.

Inputs: Account context, last call notes.

Output: Subject lines (3), body (≤150 words), CTA options (2).

Tone: Clear, respectful, non-salesy.

Self-check: Red-flag phrases, accessibility issues.



D) Data extraction & summarization



Role: Ops analyst.

Goal: Extract entities from the text and summarize.

Input: {{paste text}}

Output: JSON array of {entity, type, value, source span}, then a 120-word summary.

Guardrails: If confidence < 0.7, mark “uncertain.”

Self-check: 3 likely extraction errors to watch.



E) Brainstorm → filter → rank



Goal: Generate 20 ideas, then score each on Impact, Effort, Risk (1–5), show a sorted table, and recommend top 3 with 2-line rationale each.

Guardrails: No illegal/unethical ideas; de-duplicate similar items.





Before/After examples



Vague ask (before):

“Write a blog post about our new feature.”


Structured ask (after):

“Role: SaaS content marketer. Goal: 900-word launch post that helps PMs decide to trial Feature X. Facts: target users {{A/B}}, solves {{C}}, pricing {{D}}. Must include: pain → story → demo flow → ROI example → CTA. Tone: confident, non-hype. Self-check: list 3 claims a skeptic would question.”


Result: More relevant narrative, fewer edits, clearer CTA.





How to use this in day-to-day work (step-by-step)



  1. Define the outcome: What decision/action should your reader take?
  2. Pick the audience: Who reads this? What do they value?
  3. Choose a template: Start from the closest template above.
  4. Add facts: Paste data, constraints, definitions, links.
  5. Name must-haves & non-goals: Sections, metrics, scope boundaries.
  6. Set the bar: Who will judge it, by which criteria.
  7. Ask for a self-check: Risks, assumptions, quick validation.
  8. Iterate: Request a critique, then a refined version.
  9. Spot-check: Verify a few claims against sources before publishing.
  10. Save what works: Build a small library of prompts tailored to your team.






An evaluation rubric you can reuse



Score each 1–5:


  • Accuracy: Facts are right; uncertainties flagged.
  • Coverage: All must-haves present; no key gaps.
  • Structure: Follows requested format; skimmable.
  • Relevance: Serves the stated audience and goal.
  • Actionability: Clear next steps or decision criteria.
  • Consistency & Tone: Matches role and brand voice.
  • Risk & Validation: Assumptions and checks are explicit.



Anything <4? Ask the model to “improve scores on {{dimensions}}; keep length and format.”





Troubleshooting quick guide



  • Too generic? Tighten the goal, add audience, list must-haves, reduce word count band.
  • Hallucinations? Add facts or say “If unknown, state ‘unknown’ and propose how to find it.”
  • Messy structure? Provide an explicit outline with headings.
  • Weak reasoning? Ask for pros/cons tables and trade-off analysis before recommendations.
  • Overconfident tone? Require assumptions + uncertainty notes + validation plan.
  • Too long? Set a range (e.g., 450–600 words) and ask for bullets.






Applying this beyond ChatGPT



These patterns work across major LLMs (Claude, Gemini, Llama-based, etc.). You may need minor tweaks (some models need stricter formatting cues), but Role + Goal + Output + Facts + Guardrails + Quality + Self-check is broadly portable.





A compact prompt kit (bookmark this)



  • Strategy memo: Role (strategist) + Goal + Inputs + Table of options + Rec + Risks + Next steps + Self-check.
  • Spec: Role (PM/Tech Lead) + Goals/Non-goals + Users + Must/Should/Could + Metrics + Risks + Open Qs.
  • Email: Role (CSM) + Context + 3 subject lines + ≤150-word body + 2 CTAs + accessibility check.
  • Summary/Extraction: JSON schema + confidence flags + 120-word summary + likely errors.
  • Brainstorming: 20 ideas → score & rank table → top-3 rationale → de-duplication.






Final note



You don’t need “magic words.” You need clear goals, grounding facts, explicit structure, and a built-in self-check. Treat the model like a sharp junior partner: brief it well, ask it to check itself, and iterate. That’s how you turn prompts into consistently accurate, shippable outputs.