ChatGPT 101: from your first chat to the API

Imagine a helper who has read a huge slice of the internet, never gets tired of your questions, writes in any style you like, and is awake at 3 a.m. That is roughly what ChatGPT feels like. It is also a tool with sharp edges: it can be confidently wrong, and it only works as well as you ask.

This guide takes you from zero to confident. We start with what ChatGPT is and where it came from, walk through your very first conversation step by step, learn the handful of prompting habits that make the biggest difference, tour every major feature, and finish under the hood — tokens, context windows, tool calls — and in code with the OpenAI API.

What is ChatGPT?

ChatGPT is an AI assistant you talk to in plain language. You type (or say) what you want; it replies in writing, and it can also read files and images, search the web, create pictures, run code and hold a spoken conversation. It is made by the company OpenAI.

The name tells you what is inside. Chat is the conversation. GPT stands for Generative Pre-trained Transformer: generative because it creates new text, pre-trained because it first learned from an enormous amount of text before being tuned to be helpful, and Transformer because that is the type of neural network it runs on.

Where it came from

ChatGPT was not an overnight invention. It sits on top of years of work on ever-larger language models, and the big surprise of late 2022 was less a new model than a new interface: a simple chat box that anyone could use for free.

The key ingredient that turned a raw text-predictor into a helpful assistant was reinforcement learning from human feedback (RLHF): people rated the model’s answers, and it was tuned towards the kind of replies they preferred. That is why ChatGPT follows instructions and stays on topic, where earlier models would simply ramble on.

How it works, in five minutes

At its heart, the model does one thing: given some text, it predicts a likely next word (strictly, the next token — a word or word-piece). It picks one, adds it to the text, and repeats, which is why answers appear word by word. Everything clever it does emerges from doing that one thing extraordinarily well.

The part most people miss is what the model reads each time. It does not “remember” your conversation the way a person does. On every turn, the app sends the model one long document containing everything it needs, and the model reads it all again from the top.

Two consequences follow. First, context is everything: the model only knows about you what is in that stack, so the more relevant detail you give, the better it does. Second, there is a limit: the stack has a maximum size, called the context window. We will come back to both under the hood.

Getting started, step by step

1. Open ChatGPT. Go to chatgpt.com in any browser, or install the official ChatGPT app by OpenAI from your app store. Beware of look-alike apps with similar names.
2. Sign in (optional at first). You can try it without an account. Signing up — with email, Google, Microsoft or Apple — keeps your chat history and unlocks features such as file uploads, memory and Projects.
3. Find your way around. The screen is simpler than it looks:

4. Tell it about yourself once. In Settings → Personalization, custom instructions let you say who you are and how you like answers. They are added to every new chat automatically, which saves repeating yourself.

5. Ask for something real. Not “hello” — an actual task you have today. Then reply to it. The magic of ChatGPT is in the follow-ups.

Your first ten prompts

Not sure what to ask? Copy one of these, change the details to your own life, and go.

Prompting that actually works

A prompt is simply what you type. There is no secret code to it, and you do not need special phrases. What separates great results from bland ones is how much of the picture you give. Brief it the way you would brief a smart new colleague who knows nothing about your situation.

A good brief has up to six ingredients:

You are a patient chemistry tutor for Class 11 students.

Explain how ionic and covalent bonds differ, then quiz me with 5 questions one at a time.

I have an exam next week and I mix these two up. I learn best from everyday examples.

A short explanation (under 150 words), a comparison table, then the questions.

Everyday example style I like: “table salt is ionic, like two magnets snapping together.”

Don’t give the answer until I reply. Tell me if I’m wrong and why.

Seven habits of power users

1. Iterate, don’t restart. “Shorter”, “warmer”, “more like the second option”, “now as a table” — each follow-up builds on everything before.
2. Let it interview you. End with: “Before you start, ask me any questions you need.” It will find the gaps in your brief for you.
3. Show, don’t describe. Paste an example of the style you want. One real example beats a paragraph of adjectives.
4. Ask for options. “Give me five subject lines” and pick, instead of arguing with one.
5. Separate instructions from material. Put pasted text inside quotes or between lines like ---, and say “the text between the lines is my draft”.
6. Ask it to critique itself. “What’s weak about your answer? Fix it.” often lifts quality noticeably.
7. Say what to do, not only what to avoid. “Write in short, plain sentences” works better than “don’t be wordy”.

The feature tour

Beyond typing, ChatGPT has grown a toolbox. Exactly which tools you get, and how often, depends on your plan and country — but here is what each one is for.

Three features worth learning first

Files and data analysis. Drop in a PDF, a spreadsheet or a photo of a whiteboard and ask questions of it. With spreadsheets, ChatGPT writes and runs small programs behind the scenes to calculate and chart — ask it to “show the code you used” if you want to check its working.

Web search. The model’s built-in knowledge stops at its training cut-off. With search on, it looks things up and gives you links. Always open the one or two sources that matter; a link is only reassuring if it says what the answer claims.

Voice. Tap the voice button and simply talk. It is surprisingly good for language practice, rehearsing a tough conversation, or thinking aloud on a walk.

Choosing a model and a plan

ChatGPT offers a few models at once. Broadly there are two kinds: fast models that answer in seconds and handle most everyday tasks, and thinking (reasoning) models that work through a problem privately before answering — slower, but much stronger on maths, logic, code and planning. Often an “Auto” setting chooses for you.

Plans at the time of writing run from Free through low-cost and standard paid tiers (Go, Plus) to Pro for heavy users, plus Business and Enterprise plans for organisations. Paid plans mainly buy you more powerful models, higher limits and access to the heavier tools. Start free; upgrade only when you keep hitting a limit that matters to you.

Staying safe and accurate

ChatGPT’s biggest weakness is that it can hallucinate: produce fluent, confident, wrong answers — invented statistics, quotes, book titles, even court cases. It is not lying; it is producing what sounds right. The fix is a habit, not a setting.

Privacy basics

• Don’t paste secrets: passwords, bank or card details, Aadhaar or passport numbers, confidential client data.
• Check Data Controls in settings. You can choose whether your chats help improve OpenAI’s models, and delete chats.
• Use temporary chat for one-off sensitive questions: it doesn’t appear in history or use memory.
• Review memory now and then (Settings → Personalization) and delete anything you’d rather it forgot.
• At work, follow your organisation’s rules. Business and Enterprise plans have different data terms from personal accounts.

Under the hood

Tokens and the context window

Models read and write tokens, not words. English averages about three-quarters of a word per token; many other languages, including Hindi and Bengali, use more tokens for the same meaning. The context window is the maximum number of tokens the model can take in at once, and everything in Fig. 3 has to share it — including room for the reply.

This explains a lot of odd behaviour. A very long chat may “forget” what you said at the start; a huge PDF may be searched in pieces rather than read whole. The practical fix: start fresh chats for new topics, and restate key facts when a conversation has run long.

Why the same question gets different answers

At every step the model produces a probability for each possible next token, then samples one. Some randomness (controlled by a setting called temperature) keeps writing varied and natural, but it means two identical prompts can take different paths. That is a feature for brainstorming and a reason to double-check facts.

How tools really work

The model cannot browse or run code by itself. Instead it has been trained to write a special tool call — a structured request like search("Shillong weather"). The app sees it, runs the tool, pastes the results into the context, and the model continues. Web search, file reading, image creation, data analysis and agent mode all work on this same loop.

Memory is just more context

“Memory” sounds mysterious but is simple: short notes about you are stored and quietly added to the context of future chats. Nothing about the model itself changes. That is why you can view and edit memories as plain sentences, and why turning memory off makes ChatGPT forget you instantly.

Custom GPTs and Projects

Once you catch yourself pasting the same instructions again and again, it is time to package them. Projects group related chats with shared files and instructions — one for your thesis, one for a client. Custom GPTs go further: a named assistant with its own instructions, knowledge files and tools that you can reuse and share with a link, all built by describing what you want. No code required.

Building with the API

The ChatGPT app is one product built on OpenAI’s models. Developers can use the same models directly through the OpenAI API to build their own apps, chatbots and automations. It is a different product with different billing.

Your first API call

Create an API key in the OpenAI developer platform, store it as an environment variable called OPENAI_API_KEY, install the SDK with pip install openai, and run:

from openai import OpenAI

client = OpenAI()  # reads your OPENAI_API_KEY environment variable

response = client.responses.create(
    model="gpt-6-astra",  # a current model; see the docs for the live list
    instructions="You are a friendly personal-finance tutor for beginners in India.",
    input="Explain compound interest with a ₹10,000 example over 5 years at 7%.",
)

print(response.output_text)

instructions plays the role of the system prompt; input is the user’s message. The API does not keep your conversation for you by default in the way the app does, so a chatbot either sends the earlier turns back each time or uses the API’s own conversation-state options.

Getting data back, not prose

For software, free text is awkward to use. Structured Outputs make the model reply with JSON that is guaranteed to match a schema you define — perfect for sorting feedback, extracting fields from invoices, or routing support tickets.

response = client.responses.create(
    model="gpt-6-astra",
    input="Sort this feedback: 'Delivery was late but the cake was amazing.'",
    text={
        "format": {
            "type": "json_schema",
            "name": "feedback",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "sentiment": {"type": "string", "enum": ["positive", "negative", "mixed"]},
                    "topics": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["sentiment", "topics"],
                "additionalProperties": False,
            },
        }
    },
)

print(response.output_text)
# {"sentiment": "mixed", "topics": ["delivery", "product quality"]}

From here the path leads to function calling (the model asks your code to run a function, exactly like the tool loop in Fig. 13), retrieval over your own documents, and agents that chain many calls together. Three rules keep you out of trouble:

• Keep your API key secret. Only ever call the API from a server, never from code that runs in a visitor’s browser or a mobile app bundle.
• Watch costs. You pay per token in and out; set a monthly budget limit in your account settings before you experiment.
• Test with real examples. Collect twenty or so realistic inputs, check the outputs, and re-run them whenever you change the prompt or model.

Common mistakes, and the fix

Your 30-day plan

Skill with ChatGPT comes from use, not reading. Here is a month of small, practical steps. Tick them off as you go.

Quick quiz

Tap a question to check your answer.

That is ChatGPT from the first click to the first line of code. The best next step is the simplest: open it now and ask it for help with something you actually need to do today. 🚀

ChatGPT and GPT are products of OpenAI; this article is independent and not affiliated with or endorsed by OpenAI. Interface screens are illustrations, and sample outputs are examples. API code follows OpenAI’s developer documentation as of September 2026. Spotted something out of date? Tell us.