ChatGPT — Chat & Setup
ChatGPT is OpenAI’s AI assistant — for most people, it was the introduction to modern AI. This is the on-ramp for the OpenAI track: what ChatGPT is, the GPT model family behind it, the plans and surfaces you’ll reach it through, and the setup steps that turn a plain chat box into a genuine working tool.
ChatGPT is a robot you talk to by typing (or even speaking). It can write things for you, explain hard stuff, look at pictures, search the web, and remember what you like. There’s a fast version for easy questions and a slower “thinking” version for tricky ones — and you can plug it into your other apps so it can actually help with them, not just chat.
What ChatGPT is — and the GPT model family
☺ Like you’re 10: Think of a family of robots with the same last name. The big “GPT” one is the smart all-rounder, the “mini” and “nano” ones are little and speedy for easy jobs, and the special “thinking” ones stop and work problems out step by step before answering — like a kid who shows their working.
ChatGPT is the chat product; GPT (Generative Pre-trained Transformer) is the family of models underneath it, built by OpenAI. When you open ChatGPT you’re really choosing which GPT model answers, trading speed and cost against raw capability. As of mid-2026 the lineup falls into three broad buckets:
| Kind of model | Best for |
|---|---|
| Flagship GPT — the current top general model | The everyday all-rounder: writing, analysis, coding, multimodal (text + images + voice) work. |
| “mini” / “nano” variants | Smaller, faster, cheaper versions of the flagship — high-volume, latency-sensitive, or cost-sensitive jobs. |
| Reasoning models (the “o-series” lineage) | Deliberately think longer before answering — hard math, multi-step logic, tricky code and planning. |
The key split is fast vs. thinking. A flagship or mini model replies quickly in one pass; a reasoning model spends extra time generating a hidden chain of thought before it responds, which costs more and takes longer but is far stronger on problems that need careful, step-by-step work. That distinction — and why a model that “thinks” longer is better at hard problems — is the whole subject of the Reasoning lesson.
Exact product names move fast — GPT-4o, the o-series, GPT-5 and their successors have all arrived in quick succession — so treat any specific version number here as true at time of writing and check OpenAI’s current lineup. This is the same fast/everyday/thinking pattern you’ll meet on the other tracks: it mirrors Anthropic’s Opus / Sonnet / Haiku tiers on the Claude page and the model picker inside GitHub Copilot. The concept sits in The AI Landscape; the mechanics of how any of them generate text is in How models work.
Plans — what each tier unlocks
☺ Like you’re 10: Same robot, different memberships — like a library card. A free card lets you borrow a few books; a paid card lets you borrow more, use the fancy reading rooms, and skip the queue. A company card lets the grown-ups set the rules for everyone.
ChatGPT is free to start, and paid plans mostly raise your usage limits, unlock the strongest models and heaviest features, and — for organizations — add admin and data controls. The exact names and prices shift, but the shape is stable:
| Plan | Roughly who it’s for | What it adds |
|---|---|---|
| Free | Casual use | Access to a capable default model with tighter usage limits; a taste of tools like web search and image generation. |
| Plus | Regular individual users | Much higher limits, access to the flagship and reasoning models, and the advanced features (Projects, advanced voice, Deep Research, connectors) as they roll out. |
| Pro | Power users & professionals | The highest limits and access to the most capable / highest-effort reasoning modes; built for heavy, demanding workloads. |
| Team | Small orgs | Everything in Plus for a workspace, plus shared admin, a business data-handling posture (chats not used for training by default), and collaboration. |
| Enterprise / Edu | Companies & schools | SSO, admin controls, higher security and compliance commitments, and stronger data-handling guarantees at scale. |
The practical rule: if you’re paying, you almost always want the flagship and reasoning models turned on; if you’re a team or company, the deciding factor is usually the data controls (see §6), not the raw limits. Billing for the developer side is separate — that’s the OpenAI API, which is pay-as-you-go per token rather than a monthly seat.
The surfaces — chat, API, Codex, custom GPTs
☺ Like you’re 10: The same helper shows up through different doors. One door is a chat window, one is a socket other apps plug into, one is a coding buddy that lives with your programs, and one lets you build your own mini-helper with its own instructions.
“ChatGPT” is the chat app, but OpenAI’s assistant reaches you through several surfaces — each a different point on the autonomy spectrum. Knowing which door fits the task is half the skill:
| Surface | What it’s for | Covered in |
|---|---|---|
| The chat app (this page) | Conversation, writing, analysis, quick code — with files, memory, Projects, voice, and tools. | here |
| The OpenAI API | Build your own app on GPT — messages, tools/function calling, streaming, structured output, agents. | OpenAI API |
| Codex | An OpenAI coding agent that plans and edits across your codebase, in the terminal/editor and in the cloud. | Codex |
| Custom GPTs & the GPT Store | Package your own instructions, knowledge files, and actions into a shareable mini-assistant — no code required. | below |
This is the autonomy spectrum again: the chat app keeps you in the loop turn by turn; Codex hands off more of the work; the API is where you decide exactly how much to delegate. It’s the same shape as Claude’s chat → Claude Code → API, and Copilot’s completions → chat → agents — just OpenAI’s surfaces.
The chat features that actually matter
☺ Like you’re 10: The typing box is the boring part. The good stuff is the backpack: a note about how you like answers, a memory so you don’t repeat yourself, folders for each project, a shared workbench to write and code on, a voice you can talk to, and a researcher that goes and reads the whole web for you.
The free-text box is the least interesting part of ChatGPT. These are the features that change how much it can actually do for you:
- Custom instructions. A standing note about who you are and how you want ChatGPT to respond (tone, length, format) — applied to every new chat so you stop re-explaining your preferences.
- Memory. Across conversations, ChatGPT can remember useful facts you’ve shared (“I use TypeScript,” “I’m allergic to peanuts”) and carry them forward. You can view, edit, and delete these memories, or turn the feature off.
- Projects. A folder that groups related chats with their own files and instructions, so everything about one piece of work shares context — the counterpart to Claude Projects.
- Canvas. A side-by-side workspace for writing and coding: ChatGPT edits a document or program in place, and you can revise specific sections instead of regenerating the whole reply.
- Advanced Voice. A natural, low-latency spoken conversation — you can interrupt it, and it hears tone — turning ChatGPT into something you talk with, not just type at.
- Deep Research. Hand off a big question and ChatGPT will browse many sources over several minutes and come back with a long, cited report — a multi-step agentic job, not a single reply.
- Image generation & vision. Create and edit images from a prompt, and upload photos, screenshots, charts, or documents for ChatGPT to see and reason about (the multimodal side — see Multimodal).
- Connectors & actions. Link ChatGPT to external apps and data (Drive, GitHub, calendars, and more) so it can read and act on your real information — OpenAI supports the open MCP standard here, the same plumbing you met earlier.
Several of these — Deep Research especially, and connectors that let ChatGPT act — are really agentic behavior wearing a chat interface: the model uses tools, takes multiple steps, and does work for you. Memory and connectors are also, under the hood, close cousins of agent memory and retrieval.
Delphi the Dolphin: Hi Foxy — today I’m playing ChatGPT. Ask me anything, hand me a file, or just talk out loud and I’ll answer.
Foxy: Ooh — turn my scribbled notes into a slide outline, and remember I like short bullet points!
Delphi the Dolphin: Saved to Memory, so I’ll keep them short from now on. I’ll draft it right here in Canvas so you can tweak any line. Want me to Deep Research the topic first?
Professor Owl: Pick the right model for the job, Foxy: the fast flagship for this outline, a reasoning model when the question needs careful step-by-step thinking.
Timmy the Turtle: And before those slides go anywhere — check the facts. Even a “thinking” model can state something wrong confidently. Trust, then verify.
Prompting ChatGPT well
☺ Like you’re 10: A robot can’t read your mind. If you ask “make it good,” you’ll get a shrug. Tell it who to be, what you want, and how the answer should look — like giving a helper clear directions instead of a vague wave.
Good prompting is the same craft everywhere, and the general lesson lives in Prompting. A few things are worth knowing specifically for ChatGPT:
- Give role, task, and format. “You’re a copy editor. Tighten this paragraph to 60 words, keep the friendly tone, return just the edited text.” Specific beats polite every time.
- Let custom instructions do the boilerplate. Put durable preferences (tone, expertise level, output format) in custom instructions so you don’t repeat them each chat — think of it as a permanent first line of every prompt.
- Match the model to the ask. For open-ended or step-heavy problems, switch to a reasoning model and don’t over-instruct it to “think step by step” — it already does that internally. Fast models reward tighter, more explicit prompts.
- Ground it in real sources. Attach the file, turn on web search, or use a connector, then say “answer only from the sources provided and cite them.” That’s retrieval by hand, and it’s the best defense against made-up answers.
Open ChatGPT’s Custom instructions and fill both boxes: who you are (role, expertise level, what you’re working on) and how you want responses (tone, length, format — e.g. “concise, with code in fenced blocks, no filler”). Then start a fresh chat and ask the same question you asked last week. Notice how much less you have to explain — that standing note is doing the work every single prompt now.
Data controls & privacy
☺ Like you’re 10: When you talk to the robot, you get to decide whether it’s allowed to learn from what you said for the next version. There’s a switch for that. And when a whole company uses it, the company’s stuff is walled off by default so it isn’t used to teach the robot.
Whether your chats can be used to improve OpenAI’s models depends on your plan and your settings — and this is exactly the kind of tradeoff Responsible AI asks you to think through:
- Consumer plans (Free / Plus / Pro). By default your conversations may be used to help train future models, but you can opt out in settings (“improve the model for everyone” / data controls). You can also use Temporary Chat for one-off conversations that aren’t saved to history or used for training.
- Business plans (Team / Enterprise / Edu) and the API. Business and developer data is not used to train OpenAI’s models by default. These tiers add admin controls, retention settings, and compliance commitments suited to organizations handling sensitive data.
- Your own controls. You can turn off chat history, delete individual chats or memories, and export or delete your data. Turning off training doesn’t make you anonymous — it changes whether your content trains models, not whether it’s processed to answer you.
The practical habit: know which posture you’re in before you paste anything sensitive. On a personal Free account with training left on, treat the chat like a public postcard; on an Enterprise workspace, you have real guarantees — but confirm them, don’t assume. Legal, compliance, and security concerns for AI at work are covered in AI Security and Responsible AI.
Data-handling defaults differ by plan and change over time. Don’t put secrets, personal data, or client information into any assistant until you’ve confirmed how that specific plan handles training and retention — and prefer a business tier or Temporary Chat for anything sensitive.
ChatGPT vs. Claude vs. Gemini — when to reach for which
☺ Like you’re 10: These are different brands of the same kind of helper — like three good bikes. They’re more alike than different, and the best one is usually the one you know well and that fits the job in front of you.
ChatGPT, Anthropic’s Claude, and Google’s Gemini are the leading general assistants, and honestly they’re more similar than the marketing suggests — all three do writing, coding, analysis, and multimodal work well. Rough, non-dogmatic tendencies (which shift with every release, so verify for your task):
| Assistant | Often reached for | Ecosystem strength |
|---|---|---|
| ChatGPT (OpenAI) | The broadest feature set and mindshare; strong reasoning models, image generation, voice, and a huge tool/plugin ecosystem. | Widest third-party integration; the default many people already know. |
| Claude (Anthropic) | Long-form writing, careful reasoning, and coding; a safety-forward, “helpful and honest” posture. | Deep coding surfaces (Claude Code) and a clean API. |
| Gemini (Google) | Very large context and tight integration with Google’s products (Search, Workspace, Android). | Google ecosystem and multimodal breadth. |
The honest guidance: don’t agonize. Pick the one that fits your ecosystem (already in Google Workspace? try Gemini; live in the terminal? Claude Code or Codex may pull you), the one whose data terms you can accept, and the one you’ll actually get fluent with — fluency beats a marginal benchmark edge. Many practitioners keep two open and cross-check important answers. And remember: whichever you choose, it’s one point on the same autonomy spectrum — a chat assistant today can become an API-driven agent tomorrow. The rest of the OpenAI track builds on exactly that: the OpenAI API for building on GPT, and Codex for handing off code. Broader map in The AI Landscape and The Ecosystem.
(1) What’s the difference between a fast flagship/mini model and a reasoning model, and when would you switch to the latter? (2) Name three chat features (custom instructions, memory, Projects, Canvas, voice, Deep Research, connectors) and what each unlocks. (3) On a personal Free account, is your chat used for training by default — and how do you change that? (4) When picking between ChatGPT, Claude, and Gemini, what matters more than benchmarks? Next up on this track: the OpenAI API for building your own apps on GPT, and Codex for coding.
Check your answers
- Fast vs. thinking: A flagship or mini model replies quickly in a single pass, while a reasoning model (the o-series lineage) spends extra time generating a hidden chain of thought before answering — costing more and taking longer, but far stronger on hard math, multi-step logic, and tricky code. Switch to a reasoning model when the problem is open-ended or step-heavy and needs careful, deliberate work.
- Three chat features: Custom instructions unlock a standing note about who you are and how you want responses (tone, length, format), applied to every new chat. Memory lets ChatGPT remember useful facts across conversations and carry them forward, which you can view, edit, or delete. Deep Research hands off a big question so ChatGPT browses many sources over several minutes and returns a long, cited report.
- Free account & training: Yes — on a personal Free (consumer) plan your conversations may be used by default to help train future models. You change this by opting out in settings (the “improve the model for everyone” / data controls), and you can also use Temporary Chat for one-off conversations that aren’t saved or used for training.
- What matters more than benchmarks: All three are more alike than different, so pick for fit rather than a marginal benchmark edge: the assistant that suits your ecosystem (e.g. Google Workspace → Gemini, terminal work → Claude Code or Codex), whose data terms you can accept, and the one you’ll actually get fluent with — fluency beats a small benchmark lead.