How to Prompt ChatGPT: What Works on GPT-6, What Doesn’t, and How to Test It

On October 7–8, 2026, GPT-6 became the model behind ChatGPT’s Chat tab. A lot of prompt guides still ranking on Google were written for GPT-3.5 and GPT-4. This guide is checked against OpenAI’s own pages, separates evidence from habit, and shows you how to test every claim on your own work.

Last verified: October 22, 2026 · 15 min read · Covers GPT-6 Sol, GPT-6 Luna, and Intelligent UI by the BestPrompt.art editorial team

The short version

• The model: GPT-6 Sol on Plus, Pro, Business, and Enterprise. GPT-6 Luna on Free and Go.
• Habits to drop: “act as a world-class expert” (when you want accuracy), “think step by step,” and instructions you have already given once.
• Habits to keep: a clear goal, context the model can’t guess, a checkable finish line, a stated output format.
• New in 2026: say whether you want an interactive tool or plain text, and ask the model to flag what it couldn’t verify.
• For repeat work: set up custom instructions, a Project, and memory properly. Past a point, that beats better wording.
• Before trusting any of this, including this guide: run the test in section 7 on your own tasks.

In this guide

1. What changed in ChatGPT this year
2. What the evidence says about old habits
3. A prompt structure, and when not to use it
4. 12 prompts, tightened
5. Custom instructions, Projects and memory
6. Prompting for Intelligent UI
7. Test it yourself in 10 minutes
8. FAQ
9. Sources and method

1. What changed in ChatGPT this year

The model you prompt today is not the one most tutorials describe. These changes come from OpenAI’s release notes and launch posts.

Two practical consequences:

1. Check which model you’re on before you compare anything. Sol, Luna, and older models can all appear in a model picker, and Chat, Work, and Codex don’t always run the same one. Write the model name next to any result you want to reuse.
2. Enterprise access depends on admin settings. A rollout date is a start date, not a promise that every account switched that day.

OpenAI also describes GPT-6 as better at saying when it lacks the information or tools to answer. That affects how you end a prompt, covered in the library below.

A note on sourcing. OpenAI’s detailed prompting guidance is written for API developers. The most recent prompting guide we could confirm is the one for GPT-5.6 Sol. OpenAI has not published a consumer manual for prompting GPT-6 in ChatGPT. Where this guide applies developer guidance to chat, it says so.

2. What the evidence says about old habits

Prompt advice spreads by repetition. Three habits have actually been tested, and the results are less flattering than most listicles suggest.

How far to trust the numbers

• The persona and chain-of-thought studies measured accuracy on hard multiple-choice questions. They say nothing about tone, voice, or format. The Wharton authors themselves note that personas may still shape those.
• OpenAI’s figure that leaner prompts scored roughly 10–15% better while using 41–66% fewer tokens comes from a sample of its internal coding-agent runs. It is not a measurement of everyday chat. Don’t expect a 41–66% saving, or any saving, in a typical conversation.
• Benchmark results can’t tell you how a prompt performs on your documents. That is why section 7 exists.

3. A prompt structure, and when not to use it

Here is a five-part structure for prompts you’ll reuse, or that carry real stakes. It is a synthesis, not an official framework. It follows the ingredients OpenAI’s guide lists for an outcome-focused prompt (outcome, constraints, evidence, completion bar), trimmed for chat.

Before and after

Written for a 2023 model

text

Act as a world-class marketing consultant with 20 years of experience. Think step by step. First identify the target audience, then their pain points, then write three headlines.

Written for GPT-6

text

Goal: three headline options for a project-management tool.Context: buyers are ops managers at 50–200-person companies, currently on spreadsheets, wary of "AI" framing.Constraints: under 9 words, no buzzwords.Done when: one data-led, one problem-led, one skeptic-friendly, each with a one-line reason.Format: numbered list. If anything is ambiguous, ask one question first.

The second version holds information the first never supplied: who is buying and what they distrust. The persona and the step-by-step line carried none.

A 20-second pre-flight check

Before you send a prompt that matters, answer four questions:

1. Could a smart stranger tell when this task is finished? If not, add a “Done when” line.
2. What would the model have to guess? Replace each guess with a fact or a gap rule.
3. Do any two instructions disagree? Delete one.
4. Where will the answer go? Email, spreadsheet, and CMS all want plain text. A conversation can take something interactive.

When not to use the structure

• Quick, low-stakes questions. “What’s the difference between a Roth and a traditional IRA?” needs one sentence, not five parts.
• Exploration. When you don’t yet know what you want, start loose and steer with follow-ups. A rigid spec can lock in a bad framing.
• Creative work where surprise is the point. Constrain the format, not the ideas.

What we don’t know. No published head-to-head compares this structure against other approaches for everyday ChatGPT tasks. It’s recommended here because it matches OpenAI’s own developer guidance and removes parts that tested poorly, not because it has been shown to win. Treat it as a strong default for repeatable work, and check it on your tasks.

4. Twelve prompts, tightened

Each prompt names a scope or output, a finish line, and a rule for gaps. Replace the bracketed parts. They are starting points, not benchmarked winners.

1. SEO article brief

text

Build a brief for the keyword "[keyword]" for [audience], search intent [informational/commercial].Return a table: H1, five H2s with what each must cover, questions to answer, three primary sources to cite.Match the structure of this sample brief: [paste]. If a fact is missing, ask me.

2. Cold outreach sequence

text

Write three emails selling [product] to [role] at [company type].1: 80 words, one specific observation. 2: 100 words, built on this customer result: [result]. 3: 60 words, easy opt-out.No exclamation marks, no "hope this finds you well." If you need a fact I haven't given, ask.

3. Executive summary

text

Summarize the attached document for a reader with two minutes. 200 words maximum.Include: the problem in two sentences, three findings with page references, one recommended action.Flag anything in the document that looks inconsistent.

4. Competitor comparison

text

Compare [A] and [B] for [use case], for a non-technical buyer.Table: Criterion, A, B, Better for us. Rows: price at [team size], setup time, integrations we use ([list]), support.Use current vendor pages and link each source. End with a recommendation, or say it's a toss-up.

5. Meeting notes to actions

text

Turn these notes into a table: owner, action, due date, dependency.If an owner or date isn't in the notes, write "unassigned" or "no date." Don't guess.Notes: [paste]

6. Draft review (review only)

text

Review the draft below for [clarity/logic/tone]. Review only; do not rewrite.List the five highest-impact problems in order. For each: the exact sentence, why it fails, a one-line fix.Draft: [paste]

7. Decision memo

text

I'm choosing between [A] and [B] for [decision]. Constraints: [budget, deadline, must-haves].Give the strongest case for each, the main risk of each, and what evidence would change your answer. Then recommend one.Under 350 words.

8. Data analysis

text

Using the attached CSV, answer: [question].Show the method in two lines, the result, and one chart.List data-quality problems and how they affect the answer. Tell me before dropping or changing any rows.

9. Code review

text

Review this diff for bugs and security issues. Review only; make no changes.Per finding: file and line, why it matters, severity, minimal fix. Ignore style.If unsure it's a bug, label it "question." Diff: [paste]

10. Learning plan

text

Build a [N]-week plan to learn [skill] at [hours] hours a week. I already know [list].Each week: one goal, one practice task, one check that proves I did it. No motivation advice.

11. Rewrite in my voice

text

Rewrite the draft in the voice of the samples. Keep every fact and number unchanged. Use shorter sentences.Return only the rewrite.Draft: [paste]Samples: [paste 3]

12. Research with sourcing

text

Research [topic] using current sources. Return: a five-line summary, a table of claims with source link and date, and a list of what you couldn't verify.Prefer primary sources. If sources disagree, show both.

Why these work (our reasoning, not a measured result): each one pairs a scope verb with a finish line and a rule for gaps. The scope verb stops unrequested extra work. The finish line gives you something to check. The gap rule turns a silent guess into a visible question. None of them needs a persona to do that job.

5. Custom instructions, Projects and memory

Past a certain point, what ChatGPT already knows when you start typing matters more than how you phrase the request. Prompt engineering is how you ask. Context engineering is what the model has in front of it when it answers. ChatGPT gives you three tools for the second, and they work in layers.

OpenAI’s own guidance describes custom instructions as your default working style and memory as best for recurring context such as your role, common projects, and preferences. Plan availability and menu names change, so check Settings for what your account offers.

What goes where

Account-level custom instructions (a sample to adapt):

text

Lead with the answer, then the reasoning.Use plain language. No filler openers or closing summaries.If you lack a fact or a source, say so. Don't guess.When I ask for a draft, give one, not three options.

Notice what is missing: a hard word cap. Because GPT-6-era models can already run concise by default, an account-wide “keep replies under 200 words” can over-correct and starve answers that need room. Put length limits in the prompt for the task, where they belong.

A Project’s instructions (a sample for a recurring job):

text

This Project is for weekly client reports for [client]. Audience: their COO, who reads on mobile.Structure: result, three drivers, one risk, one ask. Under 250 words.Use only the figures in the uploaded files. If a number is missing, list it as "needed."

The first message of each chat then carries only what is new: the goal, today’s inputs, and the finish line.

Keep the layers clean

• Don’t write conflicts. If account instructions say “be brief” and the Project says “be thorough,” you’ve written a contradiction. We couldn’t find an authoritative statement of exactly how Project and account instructions override each other, so don’t depend on a particular rule. State each rule once, in the layer where it belongs. This applies to OpenAI’s developer advice about conflicting instructions to chat.
• Don’t count on instructions for must-have rules. Anything that must never be missed belongs in the prompt itself, where you can see it, plus a check in the “Done when” line.
• Audit monthly. Read your saved memories and instructions. Delete what is stale, vague, or contradictory.
• Keep memory out of tests. When you compare prompts (section 7), use fresh chats with memory off, or a temporary chat where available, so saved context doesn’t skew the result.
• Mind what you store. Treat memory and project files as places your data lives. Leave out secrets, credentials, and other people’s private details.

A quick diagnosis. If the right document or past decision would fix the answer, you have a context problem, and rewording won’t help. If the model has everything and still misreads the ask, you have a prompt problem.

6. Prompting for Intelligent UI

Intelligent UI is the biggest visible change to how ChatGPT answers since reasoning models arrived. Most guides haven’t caught up. Here is what OpenAI says it is, how to prompt for it, and where to stay skeptical.

What it is

According to OpenAI, GPT-6 is trained to compose responses from text, visuals, and interactive elements, choosing how they fit together based on your question. Responses can include graphics, tappable buttons, forms, charts, and interactive experiences you can use directly in the conversation. A plain text answer remains an option when it’s the most useful one.

OpenAI’s examples fall into three families, which make a handy way to think about prompts:

• More visual everyday answers. A plan with its timeline beside it, or road-trip stops on a map.
• Learning. Explanations where you change an input to see what happens, or work through a problem step by step.
• Tools on demand. A savings calculator, a bill splitter, or a small game, built inside the conversation.

Prompt patterns for each family

These patterns are our suggestions based on OpenAI’s examples. They have not been benchmarked, so test them with section 7.

Interactive or plain text?

Where to stay skeptical

• Verify the math. A calculator that looks polished can still be wrong. Test any tool against a case whose answer you already know before you rely on it.
• Ask for the formula. “Show the formula you used” makes errors visible, which a clean interface otherwise hides.
• Copy out what you need. Interactive pieces are built for the conversation. Move anything you need to keep into your own document.
• Check what you’re actually on. Intelligent UI shipped in the Chat tab. Work and Codex run different models. Some secondary reports also say the “Pro” reasoning option doesn’t use Intelligent UI. We couldn’t confirm that on OpenAI’s pages, so check your own picker. Enterprise access depends on admin settings.
• Don’t assume the API gives you the same thing. OpenAI describes Intelligent UI as a ChatGPT capability. Calling GPT-6 Sol or Luna through the API does not automatically reproduce the ChatGPT interface.
• End with a gap rule. Because GPT-6 is described as better at recognizing when it lacks information or tools, use it: “Tell me what you couldn’t verify or didn’t have access to.”

7. Test it yourself in 10 minutes

Everything above is a hypothesis about your tasks until you check it. OpenAI’s own guidance says to validate prompt changes on representative work, because results vary by workload.

1. Pick three tasks you repeat, such as a summary, an email, and an analysis.
2. Write two prompts per task. A is your current prompt, unchanged. B is the five-part structure.
3. Give A and B the same output format. If B asks for a table and A doesn’t, a scorer can tell them apart at a glance, and the test is no longer blind.
4. Run each three times in fresh chats with memory off, or in a temporary chat. Answers vary between runs.
5. Score blind. Shuffle the outputs, hide which is A or B, and rate each on the rubric below.
6. Compare medians. Keep B only where it wins on usability or edit time, not on length.

If B doesn’t win on your work, keep A. If you publish your results with sample size and task types, you’ll have something more useful than any opinion piece, including this one. <!– OPTIONAL: paste your own results table here (model name, date, tasks, runs, medians for A and B) before publishing. First-hand data is the strongest trust signal this page can carry. –>

Automate it with a blind-test script

If you have an OpenAI API key, this script runs the protocol for you. It sends each prompt several times, shuffles the outputs, hides which version produced each one, and gives you a sheet to score. After you score it, it prints medians per task and version.

What we verified: we ran the pipeline end to end in dry-run mode (no API calls) with sample scores, and it produced the expected median table. What we haven’t done: published GPT-6 results from it. Treat it as a tool, not a finding.

Two limits. The API isn’t the ChatGPT app, so it has no memory or Intelligent UI, and your results may not carry over. And three tasks with three runs each are a small check, not proof.

Save your tasks as tasks.json. Put your current prompt in prompt_a and the five-part version in prompt_b:

json

[  {"name": "Weekly client summary", "prompt_a": "[your current prompt]", "prompt_b": "Goal: ...\nContext: ...\nConstraints: ...\nDone when: ...\nFormat: ..."},  {"name": "Task 2", "prompt_a": "[your current prompt]", "prompt_b": "[five-part version]"},  {"name": "Task 3", "prompt_a": "[your current prompt]", "prompt_b": "[five-part version]"}]

Save this as ab_test.py:

python

#!/usr/bin/env python3"""Blind A/B prompt test (API only: no ChatGPT memory, no Intelligent UI).  pip install openai  export OPENAI_API_KEY=...  python ab_test.py run --model gpt-6-sol --runs 3     # writes blind_sheet.csv + key.json  python ab_test.py run --dry-run                      # no API calls, checks the pipeline  python ab_test.py score                              # after you fill the score columnsConfirm the model ID in OpenAI's model docs before you run."""import argparse, csv, json, random, statistics as stMETRICS = ("correct_1to5", "complete_1to5", "usable_1to5", "edit_minutes")def run(a):    tasks = json.load(open(a.tasks, encoding="utf-8"))    client = None    if not a.dry_run:        from openai import OpenAI        client = OpenAI()    rows = []    for t in tasks:        for ver in ("A", "B"):            for n in range(1, a.runs + 1):                prompt = t["prompt_" + ver.lower()]                out = (f"[dry-run output: {t['name']} / {ver} / run {n}]" if a.dry_run                       else client.responses.create(model=a.model, input=prompt).output_text)                rows.append({"task": t["name"], "ver": ver, "run": n, "output": out})    random.Random(a.seed).shuffle(rows)    key = {}    with open("blind_sheet.csv", "w", newline="", encoding="utf-8") as f:        w = csv.writer(f)        w.writerow(["id", "task", "output", *METRICS])        for i, x in enumerate(rows, 1):            key[str(i)] = {"task": x["task"], "ver": x["ver"], "run": x["run"]}            w.writerow([i, x["task"], x["output"], "", "", "", ""])    json.dump({"model": a.model, "runs": a.runs, "key": key}, open("key.json", "w", encoding="utf-8"), indent=1)    print(f"Wrote blind_sheet.csv ({len(rows)} rows). Score it without opening key.json.")def score(a):    meta = json.load(open("key.json", encoding="utf-8")); key = meta["key"]    data = {}    for r in csv.DictReader(open("blind_sheet.csv", encoding="utf-8")):        if not r["correct_1to5"].strip():            continue        k = key[r["id"]]        d = data.setdefault((k["task"], k["ver"]), {m: [] for m in METRICS})        for m in METRICS:            d[m].append(float(r[m]))    print(f"Model: {meta['model']} | runs per version: {meta['runs']} | values are medians")    print(f"{'task':28}{'ver':5}{'n':4}{'correct':9}{'complete':10}{'usable':8}{'edit min':9}")    for (t, v), d in sorted(data.items()):        meds = "".join(f"{st.median(d[m]):<{w}.1f}" for m, w in zip(METRICS, (9, 10, 8, 9)))        print(f"{t[:27]:28}{v:5}{len(d['correct_1to5']):<4}{meds}")p = argparse.ArgumentParser(); s = p.add_subparsers(dest="cmd", required=True)r = s.add_parser("run")r.add_argument("--model", default="gpt-6-sol"); r.add_argument("--runs", type=int, default=3)r.add_argument("--tasks", default="tasks.json"); r.add_argument("--seed", type=int, default=7)r.add_argument("--dry-run", action="store_true"); r.set_defaults(f=run)c = s.add_parser("score"); c.set_defaults(f=score)a = p.parse_args(); a.f(a)

Run it. Install the library with pip install openai, set OPENAI_API_KEY, then run python ab_test.py run --model gpt-6-sol --runs 3. Confirm the model ID in OpenAI’s model docs first. Open blind_sheet.csv and score every row, but don’t open key.json yet. Then run python ab_test.py score.

8. FAQ

Which model does ChatGPT use now? Since October 7–8, 2026, the Chat tab runs GPT-6 Sol on Plus, Pro, Business and Enterprise, and GPT-6 Luna on Free and Go. Enterprise availability depends on admin settings. GPT-6.1 Sol launched September 29 for Work and Codex, and OpenAI said at launch it was not yet in Chat. Check your model picker for the current state.

Do I still need to tell ChatGPT to act as an expert? Not for accuracy. Controlled tests found expert personas gave no consistent gain on hard factual questions. Use a role only to set audience or tone, such as “explain this to a first-year student.”

Should I still say “think step by step”? On reasoning models, research shows little or no accuracy benefit, along with more variability and slower answers. Ask for the result plus a short rationale instead.

Should every prompt use the five-part structure? No. Use it for repeatable or high-stakes work. For quick questions, a plain sentence is enough; for exploration, it’s better to start loose and refine.

How long should a prompt be? As long as the context requires. OpenAI’s developer guidance favors stating each instruction once, but its efficiency figures come from coding-agent tests and shouldn’t be read as a rule for chat.

Where should recurring context live? Preferences that apply everywhere go in custom instructions. Work with its own files and rules goes in a Project. Stable background goes in memory. Keep each rule in one place so the layers don’t contradict each other.

How do I get an interactive tool, or avoid one? To get one, describe the tool and the inputs you want to change. To avoid one, write “plain text only, no interactive elements.”

Can I automate the test? Yes, for API use. The script in section 7 runs a blind A/B comparison and prints median scores. It tests the API, not the ChatGPT app, so Intelligent UI and memory aren’t covered.

Is prompt engineering still worth learning? Yes, with a narrower scope. Clear goals, relevant context, and checkable finish lines still separate good results from generic ones. The tricks have faded. The fundamentals haven’t.

9. Sources and method

Model, availability, and release facts were checked against the OpenAI pages below on October 22, 2026. The prompts here are our own and haven’t been independently benchmarked. Statistics are quoted with their source and scope. Guidance on Projects, memory, and custom instructions draws on OpenAI Academy’s personalization page and third-party guides, so confirm menu names and plan limits in your own account. BestPrompt.art is not affiliated with OpenAI.

OpenAI

• GPT-6 and Intelligent UI for everyone (Oct 7, 2026): availability, Sol and Luna, Intelligent UI.
• Introducing GPT-6.1 Sol (Sep 29, 2026): availability in ChatGPT Work and Codex, “not yet available in Chat” at launch.
• ChatGPT Model Release Notes: GPT-5.6 Sol rollout (Jul 9, 2026) and the Feb 13, 2026 retirements.
• Prompting guidance for GPT-5.6 Sol: outcome-first prompting, conflicting rules, the internal coding-agent figures.
• OpenAI Academy, “Personalizing ChatGPT”: custom instructions and memory.

Research

• Basil, Shapiro, Shapiro, Mollick, Mollick and Meincke, Prompting Science Report 4: Playing Pretend: Expert Personas Don’t Improve Factual Accuracy, Wharton Generative AI Labs (Dec 2025).
• Meincke, Mollick et al., “The Decreasing Value of Chain of Thought in Prompting,” Prompting Science Report 2, Wharton Generative AI Labs (Jun 2025).
• Zheng et al., “When ‘A Helpful Assistant’ Is Not Really Helpful,” Findings of EMNLP 2024.

Not primary-sourced. The September 2026 Astra, Sol, and Luna dates and the report about the Pro reasoning option come from secondary coverage and aren’t confirmed on OpenAI pages we could open. We’ve worded them accordingly.

Corrections. An earlier version of this guide placed the GPT-6.1 Sol launch after October 7. OpenAI’s announcement is dated September 29. Fixed October 22, 2026. Spotted something out of date? Tell us, and we’ll update this page and log the change here.