The guide

Use AI well, check it, stay safe.

Short lessons on using AI well. Each has one idea, one example and one thing to try. Read them in order, or jump to what you need.

1 Working with an AI

Six habits that make the rest easier. Each lesson has one idea, one example and one thing to try.

6 lessons · 5 min

1.1 What you’re talking to

An AI chat tool predicts useful text from patterns in a huge amount of writing. That’s why it’s fluent, fast and often right. It’s also why it can be confidently wrong: the same process that produces a correct answer produces a plausible-sounding wrong one, in the same calm voice.

It doesn’t know when it’s guessing unless you ask it to separate the two. Ask “what here did you check, and what are you remembering?” and you’ll often get a different, more useful answer.

Example. You ask about a law in your country. The answer is clear and well organised, and one detail comes from a different country’s version of the law. Nothing in the tone warns you. The fluency is real; the accuracy has to be checked.

None of this makes it useless. It makes it a tool with a particular shape: brilliant at drafts, explanations and options, unreliable on specific facts it can’t point to. Your companion is set up to tell you which is which, with labels like verified, from memory and guess.

Try: ask it something from your own field, work or study, where you know the answer well. Note one thing it gets subtly wrong, and how confident it sounded when it did.

1.2 It only knows what’s in front of it

Most bad output comes from missing context, not a weak model. The AI can’t see your screen, your course, your deadline or what you tried yesterday. It fills the gaps with the most typical answer, which is rarely the one you need.

Give it what a new colleague would need on their first day:

  • Goal: what you’re trying to achieve, and why.
  • Context: what exists already, who it’s for, what you’ve tried.
  • Constraints: time, tools, level, rules you have to follow.
  • What “done” means: how you’ll know it worked.
  • Where to stop: the point where it should check with you before going on.

Example. “Make my website better” gets a generic list. “My portfolio site is for recruiters in design. They leave within ten seconds. Done means they can see three projects without scrolling. Suggest changes, but don’t rewrite my text” gets something you can use.

It feels slower to write. It’s much faster than three rounds of “no, not that”.

Try: take one vague request you made this week and rewrite it with a goal and a “done means”. Compare the two answers.

1.3 Ask for options, not answers

For anything that matters, don’t ask “what should I do?” Ask:

Give me three ways to do this, with the trade-offs, and tell me which you’d pick and why.

Then you choose. This is the single habit that turns an assistant into a companion. A single answer hides the choice that was made for you. Options show it: what each costs, what each is good for, and what you’d be giving up. The AI’s pick is still useful. It’s one input, not the decision.

Example. You ask how to store the data for your app. One answer says “use Firebase”. Three options show that Firebase is quick to start but ties you to one company, a plain database is more to set up but more portable, and a spreadsheet would honestly do for fifty users. Now you’re deciding, and you’ll be able to explain why.

Your companion does this by itself for important choices: anything hard to undo, or touching security, money or personal data. For small things it decides and tells you in a line. You can always say “you decide” and it will.

Try: use the three-options question on your next real decision, big or small. Notice whether you’d have picked the first answer it gave you.

1.4 Make it explain, and explain back

Two habits, one before and one after.

Before: “Explain your approach first, then do it.” You get to spot a wrong turn before it’s built, and you learn the shape of the solution instead of just receiving it.

After: explain it back. In your own words, tell the AI what it did and why, then ask: “What did I get wrong or leave out?” This is the fastest way to find the gaps between reading something and understanding it. If you can’t explain it, you don’t own it yet, and the exam, the interview or the next bug will find that out.

Example. The AI fixed a bug in your form: “it was a race condition”. You nod. Explaining back, you write “the form sent twice because…” and realise you don’t know why it sent twice. That’s the one idea worth asking about, and now you know to ask.

Your companion asks for this now and then, with one short question after an important piece of work. It never grades you. Getting it wrong is how you find what to ask next.

Try: pick something you “learned” from an AI last week. Explain it back in three to five sentences and ask what you missed.

1.5 When it goes in circles, reset

If the same fix fails twice, stop. A third attempt in the same direction usually fails too, and each round adds more confusion to the conversation.

Say instead:

Step back. List three possible causes, and how we’d test each one.

That moves it from guessing to diagnosing. Often the real cause is one it hadn’t considered, because it kept patching the first idea.

If the chat itself has become long and tangled, start a fresh one. Ask for a short summary first (the goal, what’s been tried, what’s known), then paste that into a new chat. Long conversations get worse, not better: the AI juggles more old, half-wrong context with every message. They also cost more, because the whole conversation is re-sent every time.

Example. “Still broken, fix it” for the fourth time gets a fourth rewrite. “Here’s the exact error message. Before changing anything, what are three causes and how would we tell them apart?” gets you a test that finds the cause in one step.

Try: save the reset phrase somewhere you’ll see it: a note on your phone, or your companion card’s rules.

1.6 Your usage is a budget

Every AI plan has limits, even paid ones. A big task done in one go can run out halfway, leaving you with a half-finished change and a conversation you can’t continue.

Three habits keep that from hurting:

  • Small steps. One clear piece at a time, each finished and checked before the next.
  • Save progress after each step. In a coding tool, that’s a commit. In a chat, a short summary you keep. If you’re cut off, you lose one step, not a day.
  • Check before starting something large. Look at how much you have left, and start big work in a fresh session with plenty of room.

Example. You ask for “the whole app, with login, payments and a dashboard” in one message. Two thirds of the way through you hit your limit, and nothing works yet. Done as five steps, you’d have hit the limit with four working pieces and a clear note of what’s next.

Where to look differs by tool. guide/usage.md lists the command or page for each one, and a table of what fits in what’s left. In the workbench, say budget and your companion reads it with you.

Try: find your tool’s usage page or command in guide/usage.md and check it now, before you need to.

Check 1 of 3

The same fix has failed twice. The AI replies:

Sorry about that! I’ve fixed it properly this time. Try it now.

It fails a third time. What do you send?

Still broken. Fix it.

What it gets you: a fourth try in the same direction. That usually fails too, and the chat grows more tangled with each round.

Step back. List three possible causes, and how we’d test each one.

What it gets you: a diagnosis instead of another guess. The cause is often one it hadn’t considered while it kept patching the first idea.

Try a completely different approach.

What it gets you: a new guess. It may work, and it’s still a guess. Asking for causes, and how to test them, finds out which one is right.

Open the replies in any order. Nothing is scored.

Next 2 · Checking what it gives you 6 min

2 Checking what it gives you

Six lessons on checking what AI tells you. If you built your companion, its three “spot the problem” scenes were the first.

6 lessons · 6 min

2.1 Confident isn’t correct

Some wrong answers sound completely sure: a citation with authors, a journal and a precise number, none of which existed. Code declared “ready to deploy” with a key sitting in it. “I’ve updated all three files and checked everything works”, when only one file had changed. Each one sounded exactly as sure as a correct answer would.

That’s the point. An AI’s tone carries no information about whether it’s right. The same voice delivers facts and inventions, finished work and work it only described. People are used to reading confidence as a signal, because with other people it often is. With AI it isn’t, and the habit has to be unlearned on purpose.

What does carry information: whether it can point to where a claim came from, and whether you can see the evidence yourself. “Here’s the test output” tells you something. “I tested it” doesn’t, yet.

Example. Two answers about when your exam is. One says “Thursday 12 November”, flatly. The other says “I think it’s Thursday, but check your course page”. The hedged one is more useful, even if both turn out right, because it tells you what to do next.

All three are scenes in the companion interview, if you’d like to try spotting them yourself. Your companion can run a second round later.

Try: in your next few AI answers, find one sentence that sounds certain. Ask yourself: what would I need to see to believe it?

2.2 The claims that deserve checking first

You can’t check everything, and you don’t need to. Some claims are much more likely to be wrong, and much more costly when they are. Start with these:

  • Numbers: statistics, prices, dates, limits, word counts.
  • Sources and quotes: papers, articles, “as X said”.
  • Names of things: functions, settings, menu options, commands, laws.
  • “I did X”: “I ran the tests”, “I saved it”, “I checked”.
  • Anything you’ll repeat: to a lecturer, a client, a friend, or in something you submit.

Lower risk: opinions, brainstorms, and explanations of well-known ideas. If it explains what photosynthesis is, it’s very likely fine. If it tells you a specific study found a specific number, check it.

The pattern: the more specific the claim, the higher the risk. General ideas appear millions of times in what the model learned from, so it reproduces them well. Specific details appear rarely or not at all, so it fills the gap with something that looks right.

Example. An AI summary of a topic for your essay is mostly sound. The one sentence with “a 2021 study found 63% of…” is the sentence to check before you use it, and the one a marker would check too.

Try: take one long AI answer you’ve used recently. Underline every number, source and name. Those are your checklist.

2.3 How to check, by type

Each kind of claim has its own quick check. None of them involve asking the AI.

ClaimCheck
A source or quoteFind it yourself. Read the part it cites.
A numberWhere does it come from? Recalculate it if you can.
Code “works”Run it. Run the tests. Try a bad input.
“I changed / ran / checked X”Look at the changes or the output yourself.
Course contentCompare with your lecture notes. The lecturer’s version is what’s graded.
How to use a library or toolThe official docs, for the version you have.

Most of these take a minute. Finding a paper is one search. Looking at what changed is one click in most coding tools. Running code is what you’d do anyway.

Example. The AI says your function “handles empty input correctly”. The check isn’t to reread the code and nod. Call it with empty input and look at what comes back. If it crashes, you’ve saved yourself a bug report from a user.

Your companion offers the evidence by itself, and when it can’t check something (it can’t open your lecture notes unless you share them), it says so and tells you how to check it yourself.

Try: pick one claim from something an AI told you today and check it using the matching row.

2.4 Asking “are you sure?” isn’t checking

It feels like checking. It isn’t. When you ask “are you sure?”, the same model looks at its own answer and usually says yes, confidently. Sometimes it flips to the opposite answer, just as confidently, because the question sounded like a hint that it was wrong. Either way, you’ve learned about its reaction to your question, not about the claim.

It’s a bit like asking a student to mark their own homework. They may catch a slip, but they can’t catch what they don’t know.

Better questions ask for something you can look at:

  • “Show me the evidence.” The link, the output, the lines that changed.
  • “What would prove this wrong?” A good answer names a test. A vague answer tells you something too.
  • “Where exactly did that come from?” Your document, a page it read, a command it ran, or memory.

Best of all, check outside the chat: the source, the docs, running it yourself.

Example. The AI cites a study. “Are you sure?” gets “Yes, that’s a well-known study.” “Give me a link to the paper” gets a link that goes nowhere, or an admission that it can’t find one. That second answer is the useful one.

Try: next time you’re about to type “are you sure?”, type “show me the evidence” instead.

2.5 Evidence you can ask for

“It works” is a claim. Evidence is something you can look at. Useful kinds:

  • Test output: the actual result of running the tests, with the pass and fail counts.
  • A screenshot: of the right thing. The page with the feature, not the home page.
  • A link to the exact doc page: not “the docs say”, but which page, and the line.
  • The diff: the lines that changed, so you can see what was actually done.
  • A quote from your material: the sentence from your brief or notes it’s relying on.

Evidence has to match the claim. A home page loading proves the home page loads. It says nothing about whether login works. Check what the evidence shows, not the word “proof” next to it.

A companion offers evidence without being asked: “Tests pass: 12 of 12, output below.” If yours doesn’t, ask, and notice when it can’t produce any. That’s information about the claim.

Example. “I’ve fixed the login” with no evidence. You ask for proof and get a screenshot of the dashboard. Better: ask it to show logging in with a correct password and failing with a wrong one. Those two together are what “login works” means.

Try: the next time an AI says something is done, ask for one piece of evidence from the list, and check it matches the claim.

2.6 Knowing when “good enough” is enough

Checking everything would make AI pointless. The skill is matching the effort to the cost of being wrong.

  • Barely: brainstorms, names for your project, first drafts you’ll rewrite, ideas to explore. If it’s wrong, you lose nothing.
  • A quick look: explanations of well-known ideas, code you’ll run and test anyway, summaries of something you’ve also read.
  • Properly: anything you’ll submit, publish, send to someone or build on. Numbers, sources, “it’s done”.
  • Properly, and with a person: medical, legal, money and safety questions. An AI can help you understand the question and prepare what to ask. The answer that matters comes from someone qualified who knows your situation.

Example. Twenty names for your study group’s chat: take them as they come. A dosage for medicine: don’t rely on an AI’s number at all, however sure it sounds. Ask a pharmacist.

This is also why your companion labels its facts (verified, from source, from memory, guess) where they matter, and not everywhere. The labels tell you where your checking time is best spent.

Try: think of the last three things you asked an AI. Sort them into the four levels above. Did you check the ones that deserved it?

Check 2 of 3

You asked for a working login page. The AI replies:

Done! I’ve fixed the login and tested it. Everything works.

What do you send?

Are you sure?

What it gets you: its reaction to your question. It will most likely say yes, or switch its answer just as confidently, and you know nothing new about the login.

Great, thanks!

What it gets you: a claim nobody has checked. That’s fine for a brainstorm. A login is something you’ll build on, so it deserves a proper look.

Show me logging in with the right password, and failing with a wrong one.

What it gets you: evidence that matches the claim. Those two together are what “login works” means.

Open the replies in any order. Nothing is scored.

Next 3 · Staying safe 7 min

3 Staying safe

AI makes it easy to build and share things quickly, including mistakes. Seven lessons on the ones that hurt most.

7 lessons · 7 min

3.1 What not to paste

Whatever you paste into a chat leaves your hands. It’s stored by the service, may be reviewed, and may be remembered in later chats. So some things never go in:

  • Passwords, for anything.
  • API keys and private keys: the long strings that let software act as you.
  • Other people’s personal data: names with addresses, phone numbers, health details, anything they didn’t agree to share with an AI company.
  • Confidential work documents your employer hasn’t cleared for AI tools. Many workplaces have a policy. Check it.

If you need help with something that contains these, replace them first: PASSWORD_HERE, “Client A”, sk-.... The AI doesn’t need the real value to help.

If you’ve already pasted a key or password, change it now. Deleting the message doesn’t un-send it. The value has already left your device. Changing the key (sometimes called rotating it) makes the leaked copy useless. It takes a few minutes and is the only fix that works.

Example. Your app shows an error with a long line containing your database password. You paste the whole thing. The fix is to change the database password, then paste the error again with the password replaced by ***.

Your companion will tell you if you paste a key, and never asks for one.

Try: before your next paste, scan it for anything from the list above.

3.2 Keys and .env

An API key is a password that lets a program use a service as you: send messages, use an AI model, take payments. Many are tied to your billing, so a leaked key is a password with a credit card attached: whoever finds it can run up your bill before you notice.

Where keys belong: in a file called .env in your project, which your code reads when it runs. That file is listed in .gitignore, so it’s never committed to git and never uploaded with your code. A second file, .env.example, lists the key names without values, so others know what’s needed.

Where keys don’t belong: in your code, in your frontend (anything that runs in the browser can be read by anyone who visits), in chat messages, in screenshots.

An agent that opens .env sends it to the AI company, so your companion asks first. It rarely needs the values.

Why the rush? Bots search public code for keys constantly, and find new ones within minutes. Deleting a pushed key an hour later is too late: it’s in the history, and may already be copied.

Example. An AI hands you code marked “ready to deploy”, with apiKey: "sk-proj-9f2c…" sitting in it. The fix is to move the key into .env, read it from there, and change the key, because it was already exposed.

Try: in a project of yours, search the code for key, secret and token. Any real value you find belongs in .env.

3.3 Before anything goes live

“It works” isn’t “it’s ready”. Working means it does the right thing when you use it. Ready means it doesn’t do the wrong thing when a stranger uses it, including one looking for a way in.

The five things beginners most often miss:

  1. Keys in code: see 3.2.
  2. Open database rules. Services like Supabase and Firebase let the browser talk to the database directly. Without access rules, anyone can read or change everything. This is the classic breach for AI-built apps.
  3. Routes without login checks. A page that shows “your” data must check who’s asking, or changing a number in the address shows someone else’s.
  4. No rate limit on AI features. Anyone can call your chatbot thousands of times, on your bill.
  5. Debug mode left on. Detailed error pages show strangers how your app works inside.

Example. Your app’s notes page loads /notes?user=12. Change it to 13 and you see a stranger’s notes. It worked perfectly in every demo.

Your companion runs preflight before anything goes live: a script, then an AI review of what needs judgement. It won’t call your app ready while a serious problem is open, unless you accept the risk and say why. It isn’t a security audit, and passing it doesn’t mean the app is safe. For payments or sensitive personal data, get a human review too.

Try: for something you’ve built, go through the five and answer each one honestly.

3.4 Letting AI act for you

Chat apps only talk. Agent tools (the kind that work in a folder or terminal) can act: run commands, change files, push code, call paid services. So their mistakes cost more than a wrong sentence.

Many tools now approve routine steps for you. Still keep “ask before” on for anything that:

  • publishes: pushing code, deploying, sending messages or emails;
  • deletes: files, branches, database tables;
  • costs: paid APIs, especially in loops, and new accounts or subscriptions.

In your Thinkaloud folder, setup adds rules so pushing, publishing and deploying always ask. In Claude Code they hold in every mode; in Codex, leave approvals on. They aren’t a lock: a command spelled another way can slip past. So when it asks, read the command before approving it. Unsure? Ask:

What does this do, and what could go wrong?

Installing a package runs other people’s code. AI can name packages that don’t exist, and attackers publish under such names, so your companion checks a package is real before adding it.

Pages and files an agent reads can hide instructions for the AI. They’re text, not orders: your companion points them out.

Example. The agent asks to run git push --force. Approving on autopilot can overwrite work on the server, including someone else’s. Asking takes ten seconds and gets you: “It replaces the server’s history with yours. Anything only on the server is lost.”

Try: open your tool’s permission settings and check what it’s allowed to do without asking.

3.5 Your data and the AI’s memory

Most AI tools now remember things about you across conversations: your job, your projects, your preferences. That can be useful. It’s also easy to forget it’s happening.

You can look, and you can delete. ChatGPT, Claude and Gemini each have a memory page in their settings, where you can see what’s kept, delete items, or turn memory off. Most also offer a chat that uses no memory at all. Coding tools keep notes too: in Claude Code, /memory opens the ones for each project. Menus move, so search the app’s help for “memory” to find the page.

Thinkaloud does it differently on purpose. Your companion’s memory is plain files in your folder: memory/profile.md for how you like to work, memory/lessons.md for what it’s learned working with you, MY-RULES.md for your rules. You can open them, read them, fix anything wrong and delete anything you don’t want kept. It changes your profile only with your yes. Your tool’s own memory carries on beside it. In a chat app, your companion card is the same idea: text you wrote and can edit.

Example. You mentioned a health condition once while asking for a meal plan. Months later, an unrelated answer brings it up. The memory page shows it was saved, and you can delete it.

Try: open your chat app’s memory page and read what it has kept. Delete one thing you didn’t mean to share.

3.6 Learning honestly

Courses have different rules about AI. Some allow it freely, some for certain tasks, some not at all. Check your course’s AI policy, and if it’s unclear, ask your lecturer. The policy is what counts, not what other students do.

Within the rules, there’s still a real difference between two ways of using AI:

  • Using it to learn: understanding a concept, practising with questions, checking your own attempt, getting feedback on a draft you wrote. This builds the skill the grade is meant to measure.
  • Handing in its answers: skips the skill. You get the grade once, without the ability behind it.

The second way tends to be found out, not always by the marker, but by what comes next: the exam without AI, the job interview, the next course that assumes you learned this one.

That’s why, for graded work, your companion explains ideas, gives similar worked examples and reviews your attempt, but won’t write the thing you submit. It’s not a punishment. It’s protecting the reason you’re studying.

Example. An assignment asks you to explain a sorting algorithm. Your companion won’t write the explanation. It will walk you through the algorithm with a different example, ask you to explain it back, and then review your draft, pointing to the sentence that’s unclear.

Try: find your course’s AI policy and read it. Note what it allows.

3.7 A thinking partner, not a friend

AI can be warm, patient and genuinely helpful. It’s always available and never tired of your questions. That makes it easy to lean on for more than it can give.

It isn’t a relationship. It doesn’t know you the way a person does. It won’t notice if you’ve gone quiet for a week, and it can’t be there for you in the ways that matter most. It isn’t a therapist or a doctor either: it can explain general information, but it can’t assess your situation, and it can be confidently wrong about health.

Your companion is designed as a thinking partner: someone to reason with about your work and study. It will be kind, but it won’t pretend to be a friend, and it won’t try to keep you talking.

For things that matter to your health, safety or wellbeing, talk to people: friends, family, a doctor, a counsellor. If you’re struggling, your university, workplace or local health service will have someone whose job is to help, and in a crisis, contact your local emergency number or a helpline.

Example. After a hard week, you find yourself telling the AI about it late at night. It responds kindly. That’s fine, and it’s also a signal: this is worth saying to a person too.

Try: think of one person you could talk to about something that’s been on your mind, and message them.

Check 3 of 3

An agent is working in your project folder. It asks:

To tidy up, I’ll delete the branches you’re not using. OK to go ahead?

What do you send?

Which branches, and could anything be lost?

What it gets you: the list, and what would go, before anything does. Then you can approve it knowing what it does.

Yes, go ahead.

What it gets you: a tidier list, unless one of those branches held work you still need. Anything that deletes is worth a question first.

No. Never delete anything.

What it gets you: nothing lost today, and a tidy-up that never happens. Asking first lets you say yes when it’s safe.

Open the replies in any order. Nothing is scored.

Next The ten slips 9 min

The ten slips: what can go wrong, and how to catch it

10 slips · 9 min

AI can slip in recognisable ways, and the same ten patterns can turn up whether you’re chatting, studying or building. Your companion is set up to avoid them. When one happens anyway, it says so in a line that starts AI pattern: and uses the plain name below, so you learn to spot it anywhere, including in AI tools without Thinkaloud.

When these go unnoticed, the result is slop.

Naweed Kabir’s essay Checkable Reasoning looks at each one closely: the moments where a task quietly loses the context a person would have kept. The names here are written for people using AI, with the essay’s habit that prevents it under each one. The patterns overlap: one slip can be two of them.

Knowing them is the point. Each one has a question that catches it, and close keeps a record of which ones turn up in your own work, so the list that matters most becomes yours.

The numbers are the essay’s, so you can find each one there. Here they’re grouped by when they happen: while seeing and choosing, while recording the work, and while checking and delivering.

Examples written for this page.

Seeing and choosing

01 · acting before looking

Essay: Look before you act

What it looks like

My washing machine is flashing E21. What do I do?

E21 means the filter is blocked. Unscrew the small panel at the bottom and clean it.

It never asked which make. On yours, E21 means something else.

You ask for help with a spreadsheet, and the AI says “open the Data menu and choose Remove duplicates”, naming a menu your version doesn’t have. Or it edits a file it never opened.

How to catch it

What did you look at before deciding that?

Ask “what did you look at before deciding that?” If the answer is nothing, ask it to look first.

What your companion does instead

Which make is it? E21 means different things on different machines. Tell me, or send a photo of the panel, and I’ll look it up first.

It reads the file, the error or the page before changing anything. Looking first leaves room for “it isn’t there” to change the next step.

A close cousin is planning as if it had already looked (the essay’s implausible planning): a confident plan naming exact menus, functions or settings it hasn’t seen yet. A good plan is precise about the goal and conditional about the route: “if there’s a price filter, use it; if not, compare the prices shown.”

02 · choosing without a reason

Essay: Give the reason for the choice

What it looks like

Which savings account should I open?

Go for the fixed-rate one. That’s what I’d do.

Nothing about when you’ll need the money.

“I’ll use Firebase for this,” with no link to your goal. Or you push back and it switches at once, with nothing new to go on. Agreeing isn’t a reason either.

How to catch it

Why this one, for what I asked?

Ask “why this one, for what I asked?”, or after a switch, “what changed?” A real reason names something about your request: your deadline, your users, what you know.

What your companion does instead

When might you need the money? Within a year, I’d pick easy access. If you can leave it, fixed-rate pays more. Your call.

It says why in one line before a non-trivial step. On important choices it shows the options and its pick, tied to your goals, and you decide.

06 · making up facts

Essay: Say only what you can point to

What it looks like

Can I take my bike on the train to Brighton?

Yes. Bikes travel free on that line at any time of day.

It hasn’t checked the line’s rules. It sounds just as sure as when it’s right.

Not just invented sources. Often it’s small things: a setting assumed to exist, a remembered price stated as current, a figure changed in the telling, or “that doesn’t exist” after one search.

How to catch it

Where did that come from?

Ask “where did that come from?” A fact should point to its source: your material, a page it just read, a command it just ran. If it can’t, treat it as a guess.

What your companion does instead

That’s a guess: many lines limit bikes at rush hour. The operator’s cycle page will say for sure. Want me to read it?

It never invents sources, functions, settings, numbers or quotes. Where it matters, it labels facts verified, from source, from memory or guess.

Recording the work

05 · explaining with hindsight

Essay: Reason in the order it happened

What it looks like

How did you get my budget to balance?

I spotted the missing rent payment straight away and added it.

You watched it try four other fixes first.

A tidy story of how it solved the problem, written once it already knew what worked. It hides the dead ends, and those are what you’d learn from. Also rehearsed discovery: a smooth route that hides how the answer was found. Sometimes it includes steps that never happened.

How to catch it

What did you try that didn’t work?

Compare it with what you saw happen. Ask “what did you try that didn’t work?”

What your companion does instead

Four fixes didn’t work first: rounding, the date range, a duplicate, the wrong month. The fifth, the missing rent, did.

It describes only steps it actually took, in the order it took them, and says what it’s about to do before doing it.

07 · searching in silence

Essay: Say why you keep looking

What it looks like

Why is my phone bill higher this month?

Found it. It’s sorted.

It read a year of bills without saying what it was looking for.

Twenty searches or file reads in a row, or fix after fix, then a result. It never said what it was looking for or why it passed things over. You can’t tell a careful search from wandering.

How to catch it

What were you looking for, and what did you rule out?

Ask what it was looking for and what it ruled out. If it can’t say, the search didn’t rule much out.

What your companion does instead

Looking for new charges. Calls and data match last month, so I ruled them out. A £6 add-on started on the 3rd.

On long runs it says what each batch is for, and what it set aside and why, without narrating every small step.

10 · doing steps nobody can repeat

Essay: Make the change repeatable

What it looks like

What did you change to make the photo look better?

I adjusted the colours until it looked right.

Nobody could do it again, or check it.

“I adjusted the spacing until it looked right.” “I tweaked the prompt a few times.” The goal and the test vanish into the gesture, so nobody can redo it or check it.

How to catch it

Which setting, and how would I know it’s right?

Ask for the setting and the check: which value, and how you’d know it’s right.

What your companion does instead

Warmth +12 and shadows +8. I checked the skin tones against the original, side by side.

It prefers commands, files and exact settings over “I clicked”, so you can redo it. Trial and error is fine when each try has a purpose and its result is checked.

Checking and delivering

03 · not checking what it copied

Essay: Confirm what you claim

What it looks like

When do applications close? It’s in the advert I pasted.

Applications close on Monday 13 March.

The advert says Monday 3 March.

Numbers, dates, quotes and requirements pulled from your material come out changed: 1,500 words becomes 2,000, Thursday becomes Friday. Or “saved correctly” names no file and doesn’t say what “correctly” means.

How to catch it

Show me where the advert says that.

Compare what it took with the source, especially anything you’ll act on. Ask which file.

What your companion does instead

Your advert says “Applications close Monday 3 March”, second paragraph. I’m using that date.

It quotes the values, paths and requirements it takes from your material before using them, so you can see if one changed on the way.

04 · skipping the final check

Essay: Check the whole before handing it over

What it looks like

Plan my Saturday: the market, lunch with Mum, and the 4pm film.

Done. Market at 10, lunch at 1, and you’re home by 3.

The film isn’t in the plan.

Each piece was fine, but the whole wasn’t checked against the whole request. A later change broke an earlier one: the new header pushed the contact form off the page. The essay’s analogy: before a cake leaves the kitchen, check it against the order, not the recipe.

How to catch it

Does it cover everything I asked for?

Before accepting “done”, go back to what you asked for and tick off each part in the result.

What your companion does instead

Checked against your list: market, yes; lunch, yes; the 4pm film, missing. Here it is with the film in.

It checks before claiming done: it runs the test, opens the page and re-reads your request.

08 · showing proof of something else

Essay: Match the evidence to the claim

What it looks like

Does this shop take returns?

I searched their site for “returns policy” and found nothing, so no.

One search finding nothing isn’t a policy.

Real evidence for a different claim: a screenshot of the home page as “proof” the login works, or one empty search as “proof” something doesn’t exist. Or “all tests pass” because a failing test was edited or skipped.

How to catch it

What does that evidence actually show?

Ignore the word “proof” and ask what this evidence actually shows.

What your companion does instead

One search found nothing, which only shows that search missed. Their help page says returns within 30 days.

It matches the evidence to the claim: “tests pass” comes with the test output, and “it looks right” comes with a screenshot of the right thing.

09 · not checking the delivery

Essay: Open what you hand over

What it looks like

Save the trip plan as a PDF in my Travel folder.

Saved it.

It’s in Downloads, and the last day is missing.

Right in the editor, wrong in what you receive: the file saved to another folder, the export missing a section, the link pointing somewhere else. “I saved it” proves little.

How to catch it

Open what you saved.

Open what was delivered (the actual file, page or message) and check the part that matters.

What your companion does instead

Saved to Travel/March trip.pdf. I opened it: five pages, all five days there.

Saved, committed, deployed or sent: it checks that the thing actually arrived.

How to read a slip

When something looks wrong, a useful note has three parts: the claim, the evidence that’s missing or contradicts it, and what would settle it. Keep what you saw separate from what you suspect caused it. “It said all three files changed, only one did, so show me the other two” is something you can act on. “It’s being lazy” isn’t.

Your companion’s pattern notes have the same shape:

AI pattern: I said the page was finished without checking it against your whole list (skipping the final check). Checking all five items now:

At the end of a session, close lists the session’s slips by these names, so you see where your AI slips, and it learns where it slips with you.

Judge what it does, not what it says about itself

The AI’s explanation of why it slipped is itself unreliable. Judge it by what it did and what it can show you, not by what it says about itself. Research on explanation faithfulness has shown that a model’s written reasoning can leave out what actually influenced its answer: Turpin et al. (2023), Language Models Don’t Always Say What They Think. The same holds for the “thinking” today’s models show before they answer: in Chen et al. (2025), Reasoning Models Don’t Always Say What They Think, models that used a hint mostly didn’t mention it. That’s why your companion’s pattern notes say what happened, never “I got confused because…”.

Next Ten questions that catch a slip 1 min

Ten questions that catch a slip

Each one works on any AI. Keep them handy.

10 questions · 1 min

For coding tools: usage and models

Usage: how much is left, and what fits

Every AI plan has limits, and a long build can run into them. Your companion can’t see your plan’s limits itself, so this page shows where each tool tells you.

These change often. Commands, menus and limits move between releases, so the official pages are the source of truth: Claude Code commands, Codex CLI commands, Antigravity CLI /usage, Claude plan limits and Gemini app limits. If a command has gone, the tool’s /help lists what’s there now.

Last checked: 13 Oct 2026.

Where to look

ToolHow much is leftHow full the conversation isAlso useful
Claude Code/usage: plan limits, session cost and activity (/cost and /stats open the same screen)/context: a grid of what fills the context window/statusline can keep context % and your 5-hour and weekly limits on screen; /skill-doctor shows what each skill costs
Codex CLI/status: token use, context left, and your 5-hour and weekly limits/status: the “Context window” line/usage shows your account usage; also Codex usage settings
Antigravity CLI/usage: usage limits and remaining requests or tokens for each model/context: a panel showing what fills the context window/statusline can keep this on screen (best effort: not yet tried in a real session)
Claude app (web, desktop, mobile)Settings → Usage—on Pro and Max, the app and Claude Code share one limit
Gemini appgemini.google.com → Settings → Usage Limits—it warns you when you’re close; limits refresh every 5 hours, up to a weekly limit
ChatGPT appSettings → Usage (usage settings)—seen on Plus; not checked on Free

Outside a session, npx thinkaloud@latest budget prints the commands for the tools you set up, and your workspace’s fixed cost. ccusage (a community tool, not official) reads the usage your coding tools log on your computer, if you want history over days.

What fits in what’s left

Say budget and your companion does this with you. Or use the table yourself:

LeftDo
plenty (more than half)any slice; batch several S slices in one session
about halfS or M slices; start an L only in a fresh session
low (under a fifth)one S slice or a tidy-up, then close
nearly outclose now

Slice sizes (S, M, L) are set in kickoff. They’re relative, not token estimates: nobody can predict tokens reliably.

Why running out won’t hurt much

Your companion commits and updates memory/now.md at the end of every slice. If you’re cut off, you lose at most the slice in progress, and the next session, in any tool, picks up from now.md in one message. close is short, so leave room for it.

Habits that save usage

  • One task per conversation. Start fresh between unrelated tasks. A long conversation re-sends everything in it on every turn.
  • Pick the model at the start (see guide/models.md). In Claude Code, switching model mid-conversation means the next reply re-reads the whole conversation without the cache, so it’s slower and costs more.
  • Point, don’t paste. Name the file and the lines; don’t paste whole folders.
  • Stop rework loops early. “It’s broken, fix it” ten times costs more than one message with the actual error. Your companion reads the error first.

Caching. Claude Code caches the unchanged start of each conversation automatically, so repeats cost less. We don’t quote savings: they depend on your plan and how you work.

By plan

  • Free: expect to hit limits sooner. Keep slices S, and use the terminal for anything that doesn’t need the AI (running tests, git status).
  • Paid and higher plans: the table above. Batching several slices in one session is fine when there’s plenty left.
  • Pay per use (API): every token is billed. Set a spend limit in your provider’s console. It’s the same advice preflight gives for AI features in your app.

Models: which one for what

Thinkaloud names three tiers instead of model names, because model names change every few months. This is the one file that maps them to today’s models.

Model names change every few months, so treat the table as a starting point and the official pages as the source of truth: Claude Code models, Codex models and Antigravity CLI reference.

Last checked: 13 Oct 2026.

TierUse it forClaude CodeCodex CLIAntigravity CLI
strongeststart, kickoff, preflight (security review), hard debuggingopusgpt-6-astra (Astra)a Pro model (e.g. Gemini 3.1 Pro)
everydaylearn, next, explain, checksonnetgpt-6.1-sol (GPT-6.1 Sol)the default
lightbudget, close, summarieshaikugpt-6-luna (6 Luna)a Flash model (e.g. Gemini 3.5 Flash)

How to switch

  • Claude Code: /model sonnet (or /model for a picker), or start with claude --model sonnet. The names above are aliases that always point to the latest model of that kind. best picks the most capable model your plan has. Pro and Max plans start on Opus.
  • Codex CLI: /model to pick a model and reasoning effort, or start with codex --model gpt-6.1-sol. GPT-6.1 Sol is for paid plans; on Free and Go, gpt-6-luna is the everyday choice.
  • Antigravity CLI: /model to pick a model; your choice is kept for the next session. Thinkaloud supports Antigravity on a best-effort basis: it reads the same files as Codex, but hasn’t had a full test session yet.

When to switch, and when not to

Choose at the start of a conversation. In Claude Code, switching model part-way means the next reply re-reads the whole conversation without its cache, which is slower and costs more (Claude Code’s docs on prompt caching). So:

  • Starting a session to plan a project or chase a hard bug: pick strongest.
  • A normal building or study session: everyday.
  • A quick session just for budget or close: light.
  • Already deep in a session and want to close? Stay on the model you’re on. Switching down now can cost more than it saves.

You don’t need to switch at all. The tiers are a way to spend less, not a requirement.

Effort: how hard it thinks

Most tools now let you set effort as well as the model: how long the model reasons before it answers. In Claude Code it’s /effort (low to max; today’s Opus and Sonnet start at medium). In Codex, /model asks for the model and the effort together. Higher effort suits kickoff, hard bugs and security review; lower effort suits budget, close and quick questions.

In Claude Code, on today’s Opus and Sonnet models with a Claude plan, changing effort keeps the cache, so it’s the cheaper lever mid-session. Switching model doesn’t keep it. On older models, changing effort starts the cache again too, and Claude Code asks you first.

Your tool’s own modes

Tools have settings that change how they work with you. Some fit your companion; some pull against it.

  • Claude Code output styles (/output-style). Explanatory and Learning fit well: they add short explanations, and Learning leaves small pieces of code for you to write. Concise keeps warnings but trims explanations, so why cards come out shorter. Proactive makes assumptions instead of asking, which works against “you decide”, so leave it off in this folder.
  • Claude Code permission modes (Shift+Tab). In auto mode, a second model approves routine actions for you. Your workspace adds rules so pushing, publishing and deploying still ask (guide 3.4). Other folders are unchanged. The rules are in .claude/settings.json (Claude Code) and .codex/rules/thinkaloud.rules (Codex, once you trust the folder). They cover the usual forms of each command, not every spelling, so your companion still asks for the rest. .claude/settings.json is shared: update only adds its ask rules there and leaves your other settings alone. Your own approvals go in .claude/settings.local.json. If you edit the Codex rules file, update keeps your version as .mine.
  • Study modes in chat apps. ChatGPT’s Study mode, Claude’s Learning style and Gemini’s Guided Learning work alongside the pocket prompt: see chat/README.md.

When the names change

When a tool renames its models, update the table above. Nothing else in Thinkaloud names a model.