3 ChatGPT Prompts I Run in Production Every Single Day

By Lazar Milicevic · Published September 26, 2026 · 7 min read

Most "top ChatGPT prompt" lists show you write-me-a-poem toys. These three prompts run inside paying-client automations every single day, each has cleared well over a thousand real executions, and they've each been rewritten three or four times to get there. Here's exactly what's shipping, why it works, and what broke on the way.

The rule that makes any prompt production-safe

Before the prompts: the single constraint that separates a demo from a workflow is strict JSON output, enforced at both the prompt and the API layer. If the model ever returns Sure! Here's the classification: before the JSON, your n8n node fails, the automation halts, and you find out about it three days later when a client asks why nothing got routed.

Two non-negotiables in every prompt below:

• The phrase Never return prose. Never wrap in markdown. Only JSON. at the end of the system prompt.
• response_format: { type: "json_object" } on the API call (or json_schema on newer models for stricter validation).

from openai import OpenAI
client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    response_format={"type": "json_object"},
    temperature=0,
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": payload},
    ],
)
data = json.loads(resp.choices[0].message.content)

temperature=0 matters too. These are classification tasks, not creative writing. Determinism is a feature.

Prompt 1 — Email triage classifier (~200 emails/day)

A small services business was losing about two hours every morning to Gmail triage. Owner reads message, decides lead vs support vs vendor invoice vs noise, forwards manually. Every day. Before coffee. We built a classifier that tags every inbound email before a human ever sees it. About 200 emails/day go through it. The owner now touches around 20.

The system prompt:

You are an email triage classifier for a small business.
Given the sender, subject, and first 500 characters of the email body,
return strict JSON with four fields:

- category: one of "lead", "support", "invoice", "vendor", "personal", "noise"
- urgency: integer 1-5
- suggested_action: one short sentence
- confidence: float 0.0-1.0

Never return prose. Never wrap in markdown. Only JSON.

Example output:

{
  "category": "lead",
  "urgency": 4,
  "suggested_action": "Reply within 2 hours — asked for pricing on Q1 rollout.",
  "confidence": 0.91
}

The n8n flow after the model call:

• category = lead and urgency >= 4 → Telegram push to the owner's phone
• category = invoice → drop into a Notion "AP inbox" board
• category = noise and confidence >= 0.85 → archive silently
• Everything else → normal inbox, unread

What broke on the way

• v1 returned prose. Fixed with the strict JSON instruction + response_format.
• v1 was too generous with urgency: 5. Every angry customer was a 5. Added anchoring: "5 = business-blocking, revenue-loss, or legal risk. 3 = normal request. 1 = FYI."
• v1 leaked noise classification on real leads when the subject line was casual ("quick q"). Now the prompt sees sender domain too — a Gmail address with "quick q" is different from a fortune-500 domain with "quick q".

Cost: ~200 emails × ~600 input tokens × $0.15/1M input = roughly $0.02/day on gpt-4o-mini.

Prompt 2 — Invoice extractor with a needs_review circuit breaker

A client was hand-typing about 50 invoices a week from email confirmations, PDF attachments, and forwarded WhatsApp screenshots. Different formats, different languages, half with typos. Now 85% flow through fully automatic; the remaining 15% get a two-second glance in a review queue. An entire afternoon collapsed to about 20 minutes.

You are an invoice data extractor.
From the input text, extract the following fields as strict JSON:

- client_name: string
- client_tax_id: string or null
- invoice_amount: number
- currency: 3-letter ISO code (e.g. "USD", "EUR", "GBP")
- invoice_date: ISO 8601 date
- due_date: ISO 8601 date or null
- line_items: array of { description, quantity, unit_price }

Rules:
- If a field is missing, return null. Never guess. Never invent values.
- If confidence on ANY field is below 80%, add "needs_review": true
- If all fields are extracted with high confidence, omit needs_review

Never return prose. Never wrap in markdown. Only JSON.

The needs_review flag is the whole trick. Without it the model will confidently hallucinate a tax ID that doesn't exist and you'll ship a broken invoice to a real customer. With it, anything uncertain routes to a human queue instead of straight to the billing system.

Real output on a messy PDF-forwarded email:

{
  "client_name": "Northwind Logistics LLC",
  "client_tax_id": null,
  "invoice_amount": 4820.50,
  "currency": "USD",
  "invoice_date": "2026-09-14",
  "due_date": "2026-10-14",
  "line_items": [
    {"description": "Warehouse rental — Sept", "quantity": 1, "unit_price": 4200.00},
    {"description": "Pallet handling", "quantity": 31, "unit_price": 20.02}
  ],
  "needs_review": true
}

needs_review: true fired because the line-item unit price doesn't reconcile cleanly to the total (arithmetic drift > $0.10). That's caught by a validation node after the model, not by the model itself — never trust an LLM to do arithmetic. The model extracts, code validates.

The validation layer that actually catches hallucinations

• Sum of quantity * unit_price must be within $0.50 of invoice_amount
• currency must be in an allow-list (USD, EUR, GBP, CAD, AUD)
• due_date must be after invoice_date
• If any check fails → force needs_review = true regardless of what the model said

That layer catches roughly 4-6% of extractions the model marked confident but got wrong.

Prompt 3 — Lead qualification scorer with a ceiling

This one runs on inbound contact forms and cold-reply threads for a small B2B agency. Every new lead gets scored 0-100 before anyone wastes a call.

You are a B2B lead qualification scorer for a services agency.
Given the lead's company name, website domain, role, message content,
and any enrichment data provided, return strict JSON:

- score: integer 0-100
- tier: one of "hot", "warm", "cold", "disqualify"
- reasoning: two sentences maximum explaining the score
- next_action: one specific sentence for the salesperson

Score based on:
- Budget indication (explicit numbers, "we have budget", RFP language)
- Decision-maker role (founder, VP, director > manager > analyst)
- Urgency language ("this quarter", "ASAP", specific deadline)
- ICP fit: services businesses, 5-50 employees, US/UK/CA/AU

HARD RULE: Never score above 80 without explicit budget OR timeline signal.
Politeness and enthusiasm are not signals.

Tier mapping:
- 85-100: hot
- 65-84: warm
- 40-64: cold
- 0-39: disqualify

Never return prose. Never wrap in markdown. Only JSON.

That "never score above 80 without explicit signals" line is what keeps the model honest. Left alone, GPT will score every polite inbound a 75 because it sounds enthusiastic. Force it to require real signals and the scores start meaning something.

Routing:

Before this ran, the founder was calling roughly 40% of inbound. After, he calls about 12% — and close rate on those calls went from ~18% to ~34%. Same top of funnel, better filter.

What all three have in common

Look at the prompts side by side and the pattern is obvious:

• Role + task in one sentence. "You are an X. Given Y, return Z."
• Explicit output schema. Every field named, every type declared.
• Null over guess. Missing data returns null, never a fabrication.
• A ceiling or circuit breaker. needs_review, "never score above 80", "confidence float". Something that makes the model admit uncertainty.
• The JSON-only ending. Always. Every prompt.

None of these started this clean. The v1 of the email classifier was 380 words of examples, edge cases, and "please" statements. It broke weekly. Each rewrite deleted more than it added. The versions above are what survived three or four rewrites and a few hundred real failures.

Cost per prompt at production volume

Rough monthly cost on gpt-4o-mini at current pricing:

• Email triage: 6,000 runs/mo → **$0.60/mo**
• Invoice extractor: 200 runs/mo, larger context → **$0.90/mo**
• Lead scorer: 400 runs/mo → **$0.25/mo**

Total: under $2/month in model spend to replace roughly 15-20 hours/week of human work across three workflows. The n8n instance runs on a $6/mo VPS.

Why bizflowai.io helps with this

Every automation I ship at bizflowai.io uses the same pattern: strict JSON prompts, deterministic temperature, a validation layer between the model and the downstream system, and a needs_review fallback for anything the model isn't sure about. The prompts above are three of the templates clients get on day one — plumbed into their inbox, invoicing tool, or CRM inside a week. Nothing exotic, nothing that breaks the second OpenAI changes a model. Just the boring engineering that turns a demo into something you'd trust to run before you're awake.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.