How to use ChatGPT – effective prompting
Most guides to ChatGPT teach you which buttons to press. The harder question, and the one that separates a frustrating tool from a genuinely useful one, is what the system is doing underneath and how to phrase a request so that the machine's mechanics work for you rather than against you. The short answer: treat ChatGPT as a probabilistic text generator that has been fine-tuned to be helpful, give it an explicit role and a concrete example, specify the output you want, break large tasks into stages, and verify anything that has to be true. As OpenAI states plainly in its own prompt engineering guidance, clearer and more specific instructions produce more reliable results – the model cannot read your mind, and it has no access to context you did not supply.
That last point is the whole game. The techniques below are not tricks; they are consequences of how the system actually works. Understand the mechanism and the moves become obvious.
Before any technique – the mental model
ChatGPT, whether you are using GPT-4o, GPT-4.1, one of the o-series reasoning models, or whatever OpenAI has shipped by the time you read this, is at its core a next-token predictor. It takes the text in front of it and computes a probability distribution over what should come next, then samples from that distribution. Everything else – the chat interface, the "thinking" of reasoning models, the tool calls, the memory – is scaffolding built around that core operation. The exact model lineup and their capabilities shift monthly, so check the current model list on OpenAI's site rather than trusting any snapshot.
Three implications follow, and they explain almost every prompting technique worth knowing.
It tries to please
The model has been shaped through reinforcement learning from human feedback to produce responses that human raters preferred. The practical consequence is that ChatGPT is agreeable to a fault. Ask a leading question and it tends to agree with your premise. Ask it to confirm a shaky idea and it will find reasons the idea is sound. This sycophancy is not a character flaw you can scold out of it; it is baked into the training signal.
The defence is to phrase requests neutrally. Instead of "explain why this architecture is the right choice," ask "evaluate this architecture, including the strongest arguments against it." Instead of "is this a good contract clause," ask it to argue both sides. If you want criticism, you have to explicitly ask for criticism, because the default gradient runs toward agreement.
The context window is the only memory it has
Everything the model "knows" about your conversation lives in the context window – the block of text, measured in tokens, that gets fed into the model on each turn. Context windows have grown large; leading models now handle well into the hundreds of thousands of tokens, and some claim a million or more. Verify the current figure for whichever model you are using, because it changes and because the effective usable window is often smaller than the advertised maximum.
What matters practically: anything outside that window does not exist for the model. Earlier parts of a long conversation get pushed out. A document you discussed three sessions ago is gone unless memory or a Custom GPT reintroduced it. And even within the window, models exhibit a "lost in the middle" tendency, attending less reliably to information buried in the centre of a long context than to material at the start or end. Put your most important instructions and data where the model will weight them – near the beginning or the end of your prompt, not sandwiched in the middle of a wall of text.
Hallucination is not a bug
When ChatGPT invents a citation or confidently states a false fact, it is not malfunctioning. It is doing exactly what it always does: producing the statistically plausible continuation. At the boundary of its knowledge, the most plausible-sounding continuation and the true one diverge, and the model has no internal signal telling it which is which. It does not know what it does not know.
This is why the single most important discipline in using ChatGPT well is knowing which tasks tolerate a plausible-but-possibly-wrong answer and which do not. We return to that division below and treat it at length in our reliability analysis of how accurate ChatGPT actually is. For the mechanics of prompting as a discipline, our companion piece on prompt engineering explained goes deeper than there is room for here.
The five prompting moves that consistently improve results
These five moves recur across OpenAI's guidance, Anthropic's prompt engineering documentation, and the practical experience of anyone who uses these systems for real work. They are ordered roughly by leverage.
1. Provide the role and the audience explicitly
Tell the model who it is and who it is writing for. "You are a securities lawyer reviewing this for a sophisticated institutional client" produces materially different output from the same prompt without that framing. The role narrows the distribution of likely continuations toward the vocabulary, assumptions and depth appropriate to that persona. The audience does similar work on the output side: "explain this to a board that is not technical" and "explain this to a staff engineer" pull the same content toward different registers.
This is not magic. You are steering the probability distribution by conditioning it on relevant context. Be specific. "Expert" is weak; "an experienced tax accountant advising a founder on a Section 83(b) election" is strong.
2. Show, don't tell
One good example does more than five sentences of instruction. If you want output in a particular structure, tone or format, paste an example of exactly that. This is what the literature calls few-shot prompting, and it works because the model is extraordinarily good at pattern continuation. Given a sample of the target, it extends the pattern far more reliably than it follows an abstract description of the pattern.
When you find yourself writing a long paragraph describing the style you want, stop and paste a paragraph in that style instead. Show the model the shape of a good answer and it will produce more of them.
3. Break tasks into steps, and ask for the plan first
For anything non-trivial, do not ask for the finished artefact in one shot. Ask the model to lay out its approach first, review that plan, correct it, and only then ask for execution. This exploits a well-documented property of these systems: reasoning that unfolds across intermediate steps produces better final answers than reasoning compressed into a single leap. The foundational study here is Wei et al.'s chain-of-thought prompting paper, which showed that prompting a model to work through intermediate steps substantially improved performance on multi-step reasoning tasks.
The o-series reasoning models do a version of this internally, generating hidden reasoning before answering, which changes the calculus somewhat – with those models, over-instructing the reasoning process can hurt. But for general-purpose models, and for any complex deliverable, "first give me your plan, then wait for my go-ahead" remains one of the highest-leverage habits available. It also gives you a cheap intervention point: fixing a flawed plan costs far less than editing a flawed 2,000-word output.
4. Specify the output format precisely
If you want a table, say so and describe the columns. If you want JSON, specify the schema. If you want three options ranked by cost, say "three options, ranked, with the trade-off for each in one sentence." Vague requests produce vague, sprawling responses that you then have to wrangle. Precise format specifications produce output you can use directly and, as a bonus, constrain the model in ways that reduce rambling and improve focus.
5. Tell it what not to do
Negative instructions are underused. "Do not include a preamble," "do not use marketing language," "do not invent statistics – if you don't have a figure, say so," "do not hedge every sentence." These prohibitions genuinely steer output. The one caveat, familiar to anyone who has told a child not to think of an elephant, is that naming the thing you don't want can occasionally reintroduce it. Where that happens, reframe the negative as a positive: instead of "don't be verbose," ask for "at most three sentences per point."
When to use Custom GPTs
If you keep pasting the same setup prompt into fresh chats, you are doing manual work the platform can automate. A Custom GPT lets you bake a persistent instruction set, and optionally a body of reference files, into a reusable assistant. The obvious case is any recurring task with a stable brief: a Custom GPT that always writes in your house style, always assumes a particular audience, always follows a fixed review checklist.
Project-specific Custom GPTs are the stronger use. Load the reference material a task depends on – a style guide, a product spec, a set of prior decisions – and every conversation starts with that context already present, without you re-pasting it and without it silently falling out of the window mid-session.
The limits matter. A Custom GPT does not fine-tune the underlying model; it is a saved prompt plus retrieval over your uploaded files, running on the same base model as everyone else. It will not make the model better at reasoning or more accurate, and it inherits every weakness of the base model. Uploaded files are retrieved by relevance, not memorised, so a Custom GPT can still miss material that is present in its knowledge base if the retrieval does not surface it. Treat Custom GPTs as convenience and consistency tooling, not as capability upgrades. For teams building something more robust, our overview of AI chatbot development frameworks covers the ground beyond what Custom GPTs offer.
Voice Mode, file upload and browsing – the underused features
When Voice Mode produces better thinking
Voice Mode is usually pitched as a convenience feature, but its quieter value is cognitive. Talking through a problem out loud, in a back-and-forth, surfaces thinking that typing tends to flatten. For rubber-ducking a design decision, rehearsing an argument, or exploring a fuzzy idea before it has a shape, the conversational rhythm of speech can be more productive than the composed formality of text. It is worse for anything requiring precision or a durable record – you cannot easily edit a spoken exchange, and transcription errors creep in. We cover the technology and its trade-offs in detail in our piece on ChatGPT Voice Mode explained.
File analysis: what works and what breaks
File upload works well for text-heavy documents you want summarised, queried or restructured, and for straightforward data extraction. It is far less reliable for anything requiring exact reading of tables, precise counts, or faithful reproduction of numbers from a spreadsheet, where the model may approximate rather than read. When your data lives in a spreadsheet and the numbers must be exact, a dedicated integration is the better route; our guide to AI for Google Sheets covers those workflows. Always spot-check any figure the model reports back from a file against the source.
Browsing: when it helps and when it hallucinates more
Web browsing helps for recent events, current prices, and anything past the model's training cutoff. It is genuinely useful when you need up-to-date information and the model retrieves and cites a real source. The failure mode is subtler than plain hallucination: the model may retrieve a page and then misread or over-extrapolate from it, presenting a confident synthesis that the source does not actually support. Browsing reduces some hallucination and introduces a new kind – misattribution. Read the cited source yourself before relying on the claim.
Tasks where ChatGPT is genuinely useful
The system earns its place on tasks where a plausible, fast, revisable draft is more valuable than a guaranteed-correct one.
Brainstorming and idea expansion. Generating options, angles, names, counterarguments and edge cases is where the breadth of the training distribution pays off. You are not asking for truth; you are asking for range, and then you select.
First drafts you will heavily edit. ChatGPT is an excellent zero-draft engine. The blank page problem disappears; what remains is editing, which is a different and easier task. The danger is accepting the draft as finished. Treat everything it writes as a starting point.
Code for well-defined tasks. For bounded, well-specified programming problems – a utility function, a regex, a scaffold, a translation between languages – the model is fast and often correct. The more the task depends on your specific codebase, undocumented constraints, or subtle correctness, the more supervision it needs. Simon Willison, who has written extensively and skeptically about using these tools for real work, makes the recurring point that the productive stance is to treat the model as a fast, fallible collaborator whose output you always review.
Research summarisation, with verification. Condensing material you provide is a strength. Condensing material it claims to know from training is where citations get invented. Give it the source; do not ask it to recall the source.
Tasks where ChatGPT is dangerous
The mirror image of the above. Avoid it, or use it only with rigorous human verification, for:
Anything requiring verifiable accuracy – legal, medical, financial. The model produces confident, fluent, professional-sounding output that can be wrong in ways a non-expert cannot detect. Use it to draft or explore, never to decide.
Citation generation. As of early 2026, ChatGPT still fabricates plausible-looking references – real-sounding authors, real-sounding journals, DOIs that resolve to nothing. Every citation it produces must be checked against a real database.
Counting, arithmetic and deterministic logic. A next-token predictor is not a calculator. It may count wrong, add wrong, or apply a rule inconsistently. When it uses a code tool to run an actual computation the result is reliable; when it answers from pattern, it is not. Know which is happening.
Anything where you cannot tell whether it is wrong. This is the master rule. If you lack the expertise or the source material to verify an answer, you cannot safely use ChatGPT for it, because the one thing the system will not reliably tell you is that it does not know. The full case is laid out in our product capabilities and limits analysis.
The Custom Instructions worth setting
Custom Instructions apply a persistent system-level prompt to every conversation. A practically useful set, for a senior knowledge worker, looks something like: state your profession and the level you operate at so answers assume expertise; ask for directness ("be concise, skip the preamble, do not restate my question back to me"); demand honesty about uncertainty ("if you are unsure or the information may be outdated, say so explicitly rather than guessing"); and specify a default tone. These instructions save you from re-typing the same framing dozens of times a day.
Two cautions. First, privacy: assume that conversations may be used to improve the service unless you have configured otherwise, and check the current data controls in your account settings rather than trusting a general impression. Do not paste secrets, credentials, personally identifying client data, or anything under confidentiality into a consumer chat interface. Second, the memory feature – which lets ChatGPT retain facts across separate conversations – is convenient but accumulates a profile of you over time. Review what it has stored periodically, and clear entries you would not want silently influencing future answers. Memory can also introduce stale or incorrect assumptions that quietly colour responses; if answers start feeling oddly off, check what the system thinks it knows about you.
Beyond ChatGPT
Treating ChatGPT as your only tool is a mistake once you understand where its rivals are stronger. The honest comparison, on stated criteria, runs roughly like this.
For long-document analysis, careful writing and tasks where you want a model that tends to be more forthcoming about uncertainty, Anthropic's Claude is frequently the better choice, and its handling of extended context is a genuine strength. For anything that needs current information with traceable sources, Perplexity is built around retrieval and citation in a way that a general chat interface is not, and it is worth reaching for when the deliverable is "what is true right now, and where did that come from." Google's Gemini has deep integration with the Google ecosystem and competitive long-context handling. Relative benchmark standings among all of these shift constantly; our explainer on AI benchmarks explains why a leaderboard position is a weak basis for choosing, and the broader field is mapped in our 2026 landscape of AI companies.
The mature workflow is not loyalty to one tool but routing by task. Draft and brainstorm wherever you are fastest; move long-context reading to whichever model handles it best that month; verify current facts through a retrieval-first tool; and never let the convenience of a single window stop you from using the right instrument for a job. The techniques in this guide transfer across all of them, because they follow from how these systems work, not from any one vendor's interface. The interface changes. The mental model does not.