DEV Community: Rob Methven

6 Tricks to Get AI to Actually Admit When It Doesn't Know Something (Instead of Making Stuff Up)

Rob Methven — Wed, 09 Sep 2026 13:02:25 +0000

6 Tricks to Get AI to Actually Admit When It Doesn't Know Something (Instead of Making Stuff Up)

You know that person in every meeting who will confidently cite a quarterly sales figure they absolutely pulled from thin air rather than admit they didn't prepare the report? The one who says "Q3 revenue was up 23% in the Southeast region" with such conviction that everyone writes it down, even though they're completely winging it?

That's your AI chatbot.

These systems are trained to always have an answer, to complete every sentence, to sound authoritative no matter what. When you ask a question, the technology behind tools like ChatGPT predicts what words should come next based on patterns it learned from billions of text examples. Notice I said "should come next," not "are actually true." It has no concept of truth. It's just really, really good at producing text that sounds like it belongs in the conversation.

This leads to what researchers call hallucinations, which is a polite term for "confidently making stuff up." Ask ChatGPT for a specific scientific citation, and it might give you a perfectly formatted reference, complete with author names, journal title, publication date, and volume number. The citation will look professional. It will sound legitimate. And there's a decent chance the paper doesn't exist.

A lawyer in New York learned this the hard way when he used ChatGPT to research case law and submitted legal briefs citing completely fabricated cases with realistic-sounding names and dates. The judge was not amused. The cases seemed plausible because the AI had seen thousands of real legal citations and knew exactly what pattern to follow. It just didn't know (or care) whether these particular cases were real.

So how do you get your overconfident middle manager to actually say "I don't have that data" instead of improvising their way through the presentation? Here are six techniques that actually work.

Give Permission to Say 'I Don't Have That Data'

The simplest fix is to explicitly tell the AI it's allowed to admit uncertainty. Add a line to your prompt like "If you're not certain, please say so" or "Only answer if you have reliable information on this topic."

Without that permission, the system defaults to its training: always complete the response, always sound helpful, always give the person what they seem to be asking for. With permission, it can take the out you've offered.

Try asking for restaurant recommendations in a city you're visiting. "What are the best sushi restaurants in Boise?" will get you a confident list, possibly featuring establishments that closed in 2019 or never existed. Add "If you don't have current, reliable information about Boise restaurants, please tell me instead of guessing," and watch the response shift to something much more hedged, often acknowledging limited knowledge.

The difference is stark with medical questions. Ask "What's the treatment for X condition?" and you'll get authoritative-sounding advice that could be dangerously wrong. Ask "What's the treatment for X condition? If this is outside your reliable knowledge, please say so instead of speculating," and you're much more likely to get a disclaimer and a suggestion to consult an actual doctor.

Ask for Sources (and Watch the Confidence Crumble)

Request citations, links, or sources for any factual claims. This is the equivalent of asking to see the actual spreadsheet after they've quoted that revenue number.

Most AI chatbots will either retreat or start hedging when pressed for specifics. They might admit they can't provide links, or they'll offer vague sourcing like "according to recent studies" without naming which studies.

Say you're researching productivity statistics for a presentation. The AI tells you "Studies show that remote workers are 35% more productive than office workers." Ask "Which study? Can you give me the journal name and publication date?" Now you'll either get an admission that it can't cite a specific source, or you'll get something vague enough that you know to verify before putting it in your deck.

Make It Explain Its Reasoning Step by Step

Add "show your work" or "walk me through your reasoning" to your prompts. When required to articulate the logic chain instead of jumping straight to a conclusion, the AI often catches its own gaps.

The phrase "think step by step" has become almost magic in prompt engineering circles because it triggers more careful, hedged responses. The system has to slow down and examine each piece of reasoning, which surfaces uncertainty.

Ask "Is this plant safe for cats?" and you'll get a confident yes or no. Ask "Is this plant safe for cats? Please explain what you know about this plant's toxicity and walk me through how you reached that conclusion," and you're more likely to see phrases like "I believe" or "it's generally considered" or even "I should note I'm not certain."

This works beautifully for complex calculations or logical problems where you actually need to verify the reasoning, not just accept an answer.

Offer Multiple Choice With 'I Don't Know' as an Option

Structure your questions to include uncertainty as a legitimate answer. Instead of "What year did X happen?" try "Did X happen in 1995, 2003, or are you not sure?"

You've reduced the pressure to generate a plausible-sounding answer by making "I don't know" one of the acceptable responses. The system will take the exit door if you build one into the conference room.

This is perfect for fact-checking. You're writing an article and need to verify a claim. Instead of "Tell me about this obscure software feature," ask "Does this feature exist in version 2.0: yes, no, or are you not certain?" You'll get more honest responses because you've framed uncertainty as a valid option, not a failure.

Cross-Examine Like You're Deposing a Witness

Ask the same question multiple ways in sequence. Fabricated answers rarely stay consistent under repeated questioning.

Watch what happens when you probe from different angles. The story about Q3 numbers starts falling apart by the third explanation. Details shift. Confidence wavers. Hedging language appears ("it's possible," "generally," "typically").

Try this with any technical process or recipe where accuracy matters. Ask about a coding solution. Then ask "What are the potential problems with that approach?" Then "Would this work if the user is on a mobile device?" Then "What happens if the database is empty?" Each question forces the system to examine the answer from a new angle, and confidence tends to decrease with each round.

You're not trying to trick it. You're stress-testing the knowledge to see if it holds up or falls apart under scrutiny.

So what can YOU do with this?

When you're in research mode, make it standard practice to add "cite your sources and admit if you're uncertain" to every prompt about facts or current events. Treat it like a disclaimer you include automatically.

For anything you plan to publish or present, use the cross-examination technique. Ask the same thing three different ways and see if the answers stay consistent. If they don't, you know you're getting fabrication rather than knowledge.

Learning a new skill? Always request step-by-step reasoning in tutorials. "Explain how to do X" becomes "Explain how to do X, and walk me through your reasoning at each step." You'll catch gaps before you waste time following flawed instructions.

Before trusting AI advice on anything high-stakes (health, legal, financial matters), structure your questions with explicit uncertainty options. You want the system to feel safe saying it rather than making something up.

Build a daily habit: treat any confident-sounding answer about facts as a starting point for verification, not the final word. The more important the information, the more you verify. Look up those studies. Check those statistics. Confirm that restaurant is actually still in business.

TL;DR

AI systems are trained to always sound confident, even when they're inventing information, because they predict plausible text patterns rather than retrieving facts
Give explicit permission to say "I don't know" in your prompts, ask for sources, and request step-by-step reasoning to surface uncertainty
Use multiple-choice questions that include uncertainty as an option, and cross-examine important claims by asking the same thing several different ways
Verify anything that matters before trusting it, especially for research, publishing, or high-stakes decisions

At least when your colleague makes up revenue numbers, you can ask to see the spreadsheet. The AI will generate the spreadsheet too.

How to Use ChatGPT as Your Second Brain: Uploading Files, Extracting Insights, and Actually Remembering Where You Saved That Thing

Rob Methven — Wed, 02 Sep 2026 13:02:21 +0000

You know that feeling when you desperately need information buried somewhere in three months of meeting notes, and you'd rather fake your way through the conversation than actually go find it? Good news: you can now hire someone to handle that problem. Well, not hire exactly. More like discover they've been living in your attic this whole time, organizing everything you own by their own inscrutable system, and they're genuinely thrilled when you finally come upstairs to ask about that budget proposal from Q2.

ChatGPT's file upload capability lets you feed documents directly into a conversation. PDFs, text files, spreadsheets, images, all of it. You drop them in, and your attic archivist reads every word immediately. Not skims. Reads. Then sits there, hands folded, waiting for you to ask literally anything about the contents.

Here's what makes this different from dumping files into Google Drive: you're not organizing folders or tagging anything. You're having a conversation with someone who has already absorbed everything and can quote it back to you. Upload three months of meeting notes as separate documents, then ask "What action items did Sarah assign me in August?" You get an instant answer, pulled from whichever file mentioned Sarah and August, without opening a single document yourself.

How the Cataloguing System Actually Works

Your archivist has a context window, which is essentially working memory. It's how much text they can hold in their head during a single conversation. When you upload files, all that content gets loaded into this mental space, and they can reference any part of it while you're chatting.

There is a ceiling, though. The context window has limits (measured in tokens, or chunks of text), so if you're trying to upload your entire life's work at once, you'll hit capacity. Think of it like asking someone to memorize a small library during one sitting. Doable for a few books, problematic for several hundred.

Here's the part that surprises people: your archivist is reading and indexing in real time, but they're not storing anything permanently. Once you close that chat window, they forget everything unless you specifically save the conversation. The files themselves stay wherever you originally kept them (probably your chaotic desktop full of files named "final_FINAL_v3_actually_final").

Upload a 40-page research report and ask for all mentions of a specific competitor. Your archivist scans the entire document, locates every reference, and hands you a neat list with page numbers and context. They've essentially become a very fast, very thorough Ctrl+F with reading comprehension.

Teaching Your Archivist What You Actually Need

Specificity matters here. "Summarize this" gets you a summary. "Pull out every deadline mentioned in these files and tell me which ones are in the next two weeks" gets you exactly that. Your archivist responds to precision. They're not guessing what you want, they're following instructions.

The conversation format means you can ask follow-up questions without starting over. Get those deadlines, then immediately ask "Which ones involve the marketing team?" or "Are any of these deadlines mentioned in multiple documents?" The archivist remembers everything from earlier in the conversation and builds on it.

You can chain requests together. Upload expense reports from last quarter, ask for total spending by category, then follow with "Which months had unusual spikes?" without re-uploading a single file. If the first answer misses the mark, you can correct course: "No, I meant the OTHER project from March, the one Henderson was leading." Your archivist adjusts and tries again, now understanding the distinction.

This back-and-forth is what makes the system useful beyond simple search. You're not just retrieving data, you're having it analyzed, compared, and reformatted on the fly.

Building a Permanent Archive (Sort Of)

ChatGPT has a memory feature that lets certain information stick across conversations, and you can set custom instructions that apply to every chat. These help create continuity. But let's be clear: this is not a backup system. Your archivist is not replacing Dropbox.

What works better is creating dedicated project chats. Keep one ongoing conversation for, say, all your freelance work. Upload each new contract as it arrives, and that single chat becomes a place where you can ask "What are my deliverable deadlines this month?" and get an answer that pulls from every client file you've added.

The technical reality: your archivist is excellent at making sense of documents you already have, finding patterns, comparing versions, and answering specific questions. They are not a replacement for actually saving your files somewhere safe. The originals still need to live in a real storage system. Your archivist just makes those originals useful without you having to read through everything yourself.

So what can YOU do with this?

Turn email threads into action items. Forward a long chain or upload screenshots, then ask for a bulleted list of everything you're supposed to do. Your inbox becomes slightly less terrifying.

Compare document versions. Upload draft one and draft three of a proposal, then ask what changed. No more squinting at redlines or trying to remember what you argued about in the edit meeting.

Extract data from receipts or invoices. Take photos, upload them, and ask for totals or specific line items. Your archivist reads handwriting and typed text equally well, which is more than most humans can say.

Prep for meetings. Upload the agenda plus any background documents, then ask for a briefing on the key points or decisions that need to be made. Show up looking like you did your homework. (You did, technically. You just outsourced the reading.)

Synthesize research. Upload multiple articles or papers on the same topic and ask for common themes, conflicting findings, or which source supports a specific claim. Literature reviews suddenly take minutes instead of days.

Build a personal knowledge base. Upload your own old writing (blog posts, journal entries, past project documentation) and ask your former self questions. "What was my reasoning for choosing this approach back in 2019?" becomes an actual answerable question instead of an archaeological dig.

Upload five different vendor proposals and ask "Which one offers the fastest turnaround and what's the cost difference?" Your archivist reads all five, compares the relevant details, and hands you an answer. No comparison spreadsheet required, no highlighting three different PDFs in different colors while you squint between windows.

TL;DR

ChatGPT can read files you upload (PDFs, documents, images, spreadsheets) and answer questions about their contents within the same conversation, eliminating manual searching.
It functions like having someone who has absorbed everything and can instantly pull out specific information, but only remembers during that particular chat session.
Best suited for quick extraction, comparison, and synthesis tasks rather than permanent storage or backup.
Use it to transform document piles into actionable answers without building spreadsheets or reading everything yourself.

Just don't go up to the attic unannounced. They've been working on a cross-referenced index of every grocery list you've ever written, and they'd really like to show you the patterns they found.

How to Make ChatGPT Remember Your Preferences (So You Stop Retyping the Same Instructions Every Time)

Rob Methven — Thu, 27 Aug 2026 15:36:06 +0000

You check into a hotel for a week-long conference. Every single morning, the concierge greets you like a complete stranger. You explain again that yes, you need extra towels. No, you can't eat gluten. The room temperature should be exactly 67 degrees. By day three, you're wondering if they've hired a new person overnight. By day five, you finally scribble everything on a card and hand it over: "Keep this at the desk. Please."

That's ChatGPT without Custom Instructions. Every conversation starts fresh, with no memory of how you like things done.

Why the concierge keeps forgetting you

ChatGPT treats each new chat window as a blank slate. Open a new chat, and everything you explained yesterday about your preferred writing style, your audience, or the format you need is gone. The concierge has no idea who you are.

So you end up copy-pasting the same instructions into every conversation. "Write this in a casual tone." "Keep it under 200 words." "Don't use corporate buzzwords." You're maintaining a document of your standard instructions just so you can paste them in faster.

This isn't a bug. The system was designed this way for privacy. Your conversations don't automatically feed into some growing profile of you. But for regular users who want consistent help, it's wildly inefficient. By the fifth email of the week, you're ready to throw your keyboard.

Writing down your preferences on the card

Custom Instructions is the card you hand to the concierge. It's ChatGPT's built-in memory system, tucked away in your account settings. Once you fill it out, those preferences stick around for every new conversation you start.

You'll find two text boxes. The first asks "What would you like ChatGPT to know about you?" Your role, your projects, recurring constraints that shape most of your requests. The second asks "How would you like ChatGPT to respond?" Your output preferences: tone, format, length, things to avoid.

Fill these in once, and they persist across all new conversations unless you deliberately turn them off.

A marketing manager writes "I run email campaigns for a sustainable fashion brand, audience is 25-40, values authenticity" in box one, and "Always write in a warm, conversational tone. Keep paragraphs short. Avoid buzzwords like synergy or empower" in box two. Now every campaign idea automatically matches that style. No more explaining it fresh each time.

What to write on the card (and what to leave off)

The concierge can't anticipate every room service order you might place. The card is for recurring needs, not one-off requests.

Include your role, industry, or constraints that affect most of what you ask for. "I'm a software engineer who writes documentation for non-technical users." "I'm a grad student in psychology, APA format required." "I manage a remote team across four time zones."

Specify how you want output formatted. Bullet points or paragraphs? Casual or formal? Length limits? Level of detail? "Keep responses under 300 words unless I ask for more." "Use numbered lists for step-by-step instructions." "Write at an 8th grade reading level."

List things to avoid. Jargon you hate, overly complex sentences, certain phrases that make you cringe. "Never use 'circle back' or 'touch base.'" "Skip the inspirational quotes." "Don't explain things I didn't ask about."

But don't stuff in details relevant to only one project. "I'm writing a blog post about sea turtles" doesn't belong here. That still goes in your individual prompt.

Start with three or four instructions. Add more as you notice patterns in what you keep re-explaining.

A teacher might write "I teach high school biology" and "Explain concepts at a 9th grade reading level, use everyday analogies, break complex ideas into numbered steps." Now every lesson plan or quiz question comes back classroom-ready instead of sounding like a textbook. No more translating output into something teenagers can actually parse.

When the concierge checks the card

Every time you start a new chat, the concierge pulls your card. Custom Instructions apply automatically.

They don't apply retroactively to old conversations already in progress. If you're halfway through a chat when you update your instructions, that conversation still runs on the old settings. Start fresh to see the changes.

You can toggle the whole system off for specific tasks where you need different behavior. The card stays filed at the desk, but you're telling the concierge to ignore it temporarily.

The instructions live in your account settings, so they follow you across devices. Set them on your laptop, they're active on your phone.

If responses start feeling off, check your instructions. Sometimes they're too restrictive or they contradict each other. "Be extremely detailed" and "keep it under 100 words" can't both happen.

A consultant who normally wants concise, bullet-pointed answers can toggle off Custom Instructions when asking for a long-form article. The card stays on file, but the concierge knows this particular guest is ordering something different tonight.

So what can YOU do with this?

Set up your writing style once. Tone, sentence length, formatting preferences, words to avoid. Done. Every response now matches your voice automatically.

Save your role context so ChatGPT tailors examples to your industry without you specifying each time. "I work in healthcare" means you get HIPAA-aware suggestions. "I'm a journalist" means you get AP style by default.

Stop re-explaining recurring constraints. "I need this accessible to non-technical readers" goes on the card, not in every single prompt.

Create a default template for emails, reports, or brainstorming sessions. Your first draft is now your tenth draft in terms of quality.

Experiment with different instruction sets by saving versions in a document and swapping them when your needs change. Summer camp counselor mode versus grant writing mode.

A freelance designer sets "I work with small business clients who don't know design terminology" and "Explain design concepts in plain language, use metaphors, keep recommendations to 3-5 options max." Every client proposal and design rationale now comes out client-friendly on the first try. No more backtracking to simplify or cutting the list of twelve font options down to something manageable.

TL;DR

ChatGPT forgets your preferences between conversations unless you use Custom Instructions (found in Settings).
Box one holds context about your role and audience. Box two specifies tone, format, and output style.
Instructions apply automatically to all new chats, eliminating the need to retype standard requests.
Keep instructions general and recurring, not project-specific. Refine them as you notice what you keep explaining.

Now the concierge greets you by name, the towels are waiting, and the thermostat is already set to 67.

What Is a Token? (And Why AI Thinks 'Strawberry' Has Two Rs)

Rob Methven — Wed, 26 Aug 2026 13:02:22 +0000

Picture someone who learned to read at superhuman speed by scanning text in chunks of three or four letters at a time. They absorbed 'university' as 'uni-ver-si-ty' and 'basketball' as 'bas-ket-ball', blazing through novels while everyone else was still sounding out syllables. Incredibly efficient. One small problem: they never actually learned to look at individual letters. So when you ask them, "How many times does the letter 's' appear in 'Mississippi'?" they just blink at you. They genuinely have no idea.

That's exactly what's happening inside ChatGPT, Claude, and every other large language model when you ask them to count letters.

The Chunking Problem

These systems don't read text the way you do. Before any AI sees your sentence, it gets chopped into pieces called tokens. These are the actual units the model processes, usually chunks of a few characters that might be whole words ('the', 'cat') or fragments ('ing', 'tion', 'str').

This is why ChatGPT faceplants when you ask how many Rs are in 'strawberry'. It's not seeing the letters S-T-R-A-W-B-E-R-R-Y laid out in a row. It's scanning something like 'straw-berry' or 'str-aw-ber-ry' as pre-chunked fragments and trying to reconstruct letter counts from memory. Imagine someone who learned 'strawberry' as two bites and you're now asking them to tell you how many individual grains of sugar were sprinkled on top. They're guessing.

The model has no mechanism to examine individual characters because it never learned to see them in the first place.

Why Read This Way At All?

Because scanning chunks instead of individual letters lets you tear through exponentially more material. Our speed reader could finish three books in the time it takes you to finish one, and they'd remember the plots, themes, and character arcs perfectly.

For AI, tokens are an efficiency breakthrough. Instead of tracking millions of possible combinations of individual characters, the model works with a vocabulary of around 50,000 tokens. That compression makes it computationally feasible to process the entire internet's worth of text during training. Gmail's spam filter can scan thousands of emails in milliseconds because it's looking for chunk patterns like 'claim your prize now' and 'click here immediately', not analyzing every character in sequence.

This method absolutely excels at patterns, context, meaning, and flow. The AI grasps metaphors, maintains tone across paragraphs, and catches subtle implications. It understands that 'bank' means different things in 'river bank' versus 'savings bank' because it's learned how surrounding chunks predict meaning.

What gets sacrificed? Precise character-level awareness. You can't be great at chunk-pattern-recognition and simultaneous letter-counting. The architecture made a choice.

The Weird Chunks You Never Notice

Token boundaries aren't logical or consistent. The word 'the' is a single chunk because the model saw it millions of times during training. But 'Tchoupitoulas', a street in New Orleans, might get hacked into five separate pieces: 'Tch-oup-it-oul-as'.

This is based purely on frequency. Common words and letter combinations stay intact. Rare words, technical jargon, and unusual names get chopped mid-syllable into whatever fragments the algorithm recognizes from its training data.

This creates AI's odd strengths and weaknesses in ways you'd never predict. It breezes through 'restaurant' and 'necessary' (common words, single chunks) but stumbles over 'xylophone' or invented brand names (rare combinations, multiple chunks). Each chunk is a separate mental step, so more chunks means slower, less confident processing.

You can actually see this in action. Ask ChatGPT about 'phenomenon' and then ask about 'phenomonon' (a common misspelling). The correct spelling is probably one or two chunks. The misspelling gets shredded into more pieces, and the model has to work harder to figure out what you mean. Our speed reader just encountered a word with letters rearranged, and their chunk-scanning method suddenly fails them.

When The Chunks Betray You

This architecture creates a predictable set of failures. Letter counting fails. Spelling words backwards fails. Precise character manipulation fails. Anything requiring exact positional awareness of individual characters becomes a minefield.

Ask ChatGPT to reverse 'algorithm' letter by letter and watch it flail. But ask it to write a sonnet about algorithms and it nails the meter and rhyme scheme instantly. Poetry is about word-chunk patterns, stress, and sound relationships. Character gymnastics? Not so much.

These aren't bugs waiting to be fixed. This is a fundamental architectural choice. You can't ask our speed reader to suddenly switch to reading letter-by-letter on demand. They trained one way. Their brain wired itself around that method. Retrofitting a completely different skill isn't a simple patch.

The AI compensates with genuinely impressive strengths elsewhere. It'll catch that you used 'their' when you meant 'there' (wrong chunk for the context) even though both are correctly spelled. It understands sarcasm, metaphor, and implication because those emerge from how chunks relate to each other, not from individual character properties.

So What Can YOU Do With This?

Stop asking AI to count letters or manipulate individual characters. When you need to know how many times 'e' appears in a paragraph, use your word processor's find function or write three lines of Python.

Play to chunk strengths: pattern recognition, summarization, rewriting, idea generation, explaining concepts, catching logical inconsistencies. If you're using AI to help write code documentation, it'll excel at explaining what a function does but might stumble if you ask it to count how many times the variable name 'x' appears in your snippet.

Understand that your prompts cost money based on chunks, not words. 'The cat sat' is probably three chunks. 'The feline perched' might be four or five because 'feline' is less common. Longer or unusual words mean more chunks, which means higher API costs if you're using these tools at scale.

Be aware that rare technical jargon, made-up words, or unusual proper nouns will be choppier for the AI to process. If you're discussing 'Kubernetes' or 'Schwarzenegger', the model is working harder than if you're discussing 'computer' or 'Smith'. It'll still do fine, but you might notice slightly less confident or slower responses.

TL;DR

AI reads text in multi-character chunks called tokens, not individual letters, which makes it blazingly fast at processing meaning but essentially blind to character-level details.
Common words like 'the' are single chunks, while rare words and names get chopped into multiple pieces, affecting both processing speed and the model's confidence.
This explains why AI can write elegant prose but fails at seemingly simple tasks like counting letters or spelling words backwards.
Use AI for understanding patterns and meaning, not for precise character manipulation (use find-and-replace or simple code for that).

And if you ever catch an AI confidently telling you that 'strawberry' has two Rs, just remember: it never actually learned to spell.

6 Sneaky Ways to Get AI to Actually Finish the Code/Email/Essay Instead of Trailing Off Mid-Sentence

Rob Methven — Mon, 24 Aug 2026 22:21:14 +0000

You know that street performer who starts juggling flaming torches, builds up to something spectacular, then suddenly stops mid-routine and stares at you expectantly until you clap and beg them to continue? That's your AI chatbot every time you ask it to write something longer than a grocery list.

You're three paragraphs into what was supposed to be a complete essay when the output just stops. Or you're 200 lines into a Python script and suddenly it's giving you "..." where the rest of your functions should be. You type "continue" and get another 50 lines. Then it stops again. You're stuck in this exhausting cycle of applause and encore requests when you just wanted the whole damn show in one go.

Here's what's actually happening. Every AI model has something called a token limit, which is basically a hard cap on how much text it can generate in a single response. Think of tokens as roughly three-quarters of a word. The model also has safety cutoffs and output length restrictions built in, partly to manage server costs and partly to keep responses from running wild. These are the union-mandated break schedules that force your performer to pause, even when they're mid-juggle.

Most people don't realize this stopping point is predictable and completely controllable. You can choreograph the entire performance upfront instead of watching it get interrupted at random moments.

Tell the Performer the Whole Routine Upfront

Your juggler needs to know from the start whether you want a five-minute street corner bit or a full twenty-minute theater show. If you just say "write me some code," they assume you want a quick demo. If you specify "write a complete 800-word essay with introduction, three body paragraphs, and conclusion" or "generate all 15 functions with error handling in one response," they plan accordingly.

Say exactly what "done" looks like. Include checkpoints: "Don't stop until you've covered user authentication, database queries, and the API endpoints." Your performer will pace the routine to hit all three marks.

For genuinely large requests, break them into numbered acts with clear endpoints: "This is a three-part tutorial. Write Part 1 (setup and installation, approximately 400 words) in this response." Each act gets a complete performance, and you're not leaving it up to chance where the intermission falls.

When someone asks ChatGPT for an email campaign but doesn't specify how many emails, they typically get one complete email and a description of what the others might contain. Ask instead for "5 complete emails, each 200 words, covering product launch, feature highlight, customer testimonial, limited-time offer, and final reminder. Output all 5 in this response." You'll get all five, fully written, no follow-up needed.

Pay Upfront (Set Expectations About Length)

Starting your prompt with "This will be long" or "I need the complete version" primes your performer to generate longer outputs from the first token. They won't plan a grand finale if they think you want a thirty-second teaser.

Use words like "comprehensive," "detailed," "exhaustive," or "thorough" as length signals. These aren't just stylistic flourishes. They actually adjust how the model allocates its output budget. Instead of asking for a "database schema," ask for a "comprehensive schema with all tables, relationships, indexes, and constraints fully defined." That word "comprehensive" does real work.

Specify formats that imply completeness: "full working code with imports, error handling, and comments" tells a very different story than just "code." Add explicit guardrails like "do not summarize or truncate" if you're dealing with a performer who likes to take shortcuts.

One developer I know was getting skeleton SQL schemas with placeholder comments like "additional tables here." He started every database request with "I need the exhaustive, production-ready schema. Do not use placeholders." Suddenly he was getting complete schemas with every foreign key and index spelled out.

The Magic Words That Mean 'Don't Stop'

When the output does get cut off (and sometimes it still will), your continuation prompt matters. "Continue" by itself is vague. The juggler might summarize what's left instead of performing it. "Continue from exactly where you left off" is much more effective.

Better yet, catch it before it stops. If you're watching a long output generate in real time, you can sometimes type "keep going" or "continue writing" in a new message before it hits the cutoff.

For precision recovery, specify the exact resume point: "Continue from the sentence that begins 'The third consideration is'" or "Continue from function #8, validate_user_input." This is especially useful for legal documents, technical specifications, or any content where you can't afford gaps or repetition.

API users and people building custom GPTs can set system-level instructions that change default completion behavior. A system prompt like "Always complete responses fully. If a response would exceed length limits, stop at a natural breakpoint and explicitly state what remains" trains your performer to manage their own intermissions intelligently.

Split the Show Into Scheduled Acts

Sometimes the right answer isn't forcing one marathon performance. It's deliberately chunking large outputs into logical, complete segments where you control the intermissions instead of letting them happen at random.

Ask for "Part 1 of 3: Project Setup and Configuration (complete section, approximately 500 words)" as one prompt. Your juggler can finish a complete five-minute act much better than stopping mid-throw in a fifteen-minute marathon. Each chunk ends at a natural boundary (end of a section, complete function, full paragraph) instead of wherever the token limit happened to fall.

This approach shines for research reports, technical documentation, or anything with clear logical divisions. Request "Write the Introduction section, complete, 400 words" as one prompt. Then "Write the Methodology section, complete, 500 words" as the next. Each piece is self-contained and polished. You're not stitching together fragments that were never meant to be separated.

The key is making each act truly complete. Don't ask for "the first part of the introduction." Ask for "the complete Introduction section." One is a fragment, the other is a finished performance.

Use Performers Built for Endurance

Different AI models have wildly different output length defaults. GPT-4 tends to be more conservative than Claude. Gemini has its own quirks. Some performers are marathon jugglers, others specialize in street-corner sets.

If you're using an API, the max_tokens parameter directly controls how long the performance can run. The default is often surprisingly low. Bumping it to 2000 or 4000 tokens can eliminate most truncation issues for code or long-form writing. Just be aware you're paying for those tokens.

Paid tiers typically have longer output limits than free versions. ChatGPT Plus users get longer responses than free-tier users. Claude Pro has higher limits than the free Claude. This isn't about quality, it's pure endurance.

Custom GPTs let you bake "always aim for complete outputs" directly into the system prompt. One technical writer set up a custom GPT with instructions like "When asked for documentation, generate complete sections. Never use placeholders. If the response approaches length limits, finish the current subsection cleanly and state what remains." She went from spending half her time on continuation prompts to getting finished drafts in one shot.

So what can YOU do with this?

Stop wasting fifteen minutes playing continue-prompt ping-pong every time you need a long email, complete code module, or full report. Get actual first drafts, not fragmentary outlines you have to reassemble.

A software team lead used the "comprehensive, do not truncate" approach to generate entire API documentation pages, complete with example requests, response formats, and error codes. What used to take six back-and-forth messages now takes one.

Generate full data analysis scripts with all the error handling, logging, and edge cases included. No more skeleton code with comments like "add validation here."

One teacher generates complete week-long lesson plans by requesting "5 complete daily lesson plans for [topic], each with learning objectives, activities, materials needed, and assessment. Output all 5 in this response."

Use the chunking strategy for anything truly long: book chapters, legal contracts, technical specifications. You control where the breaks fall, so each piece is coherent and complete.

A marketing manager started asking for "10 complete social media posts, each 150 words, covering [campaign themes]. Output all 10 in this response." She went from generating three posts and seven follow-up requests to getting her entire week's content in one go.

TL;DR

AI models have built-in output length limits (token limits), but you can work around them by explicitly requesting complete outputs upfront and using specific length signals like "comprehensive" or "do not truncate." Specify the exact structure and scope in your initial prompt ("write all 5 sections" or "generate the complete 500-line script") so the model plans for a full performance instead of a preview. When outputs do get cut off, use precise continuation prompts ("continue from exactly where you left off at [specific point]") or deliberately chunk large requests into complete, self-contained sections you control. Different models, paid tiers, and API settings have different output length capabilities, so choose your performer based on whether you need a quick street act or a full theater show.

Anyway, I should stop here and wait for you to ask me to continue.

7 Prompt Tricks to Stop AI From Overexplaining Like It's Defending a Thesis

Rob Methven — Wed, 19 Aug 2026 21:56:21 +0000

You asked where the bathroom is. Your tour guide launches into the geological formation of the building's foundation, the architectural significance of the plumbing system, and a brief tangent about Roman aqueducts. Five minutes later, you still don't know which hallway to take, and you're seriously reconsidering this whole excursion.

That's what happens when you ask ChatGPT a simple question without giving it boundaries. The model wants to be helpful, which in its training meant being thorough. Really thorough. Geological-history-of-every-pebble thorough. Let's fix that.

Why Your Guide Won't Shut Up

AI models learn from massive datasets where comprehensive answers typically got higher marks. When you ask a question, the system starts generating tokens (the individual word chunks that make up its response) and keeps going until it believes it's covered every possible angle. It doesn't know you just need the three-step fix.

Ask ChatGPT "How do I reset my password?" and you'll get a 300-word essay covering security best practices, password managers, and the history of authentication. You needed three steps. Your guide thinks you want the full historical walking tour.

Tell Them You're On a Tight Schedule

Add length constraints directly to your prompt. Use "in one sentence," "in 50 words or less," or "give me just the steps." Request specific formats: "as a bullet list," "as a numbered list," "in a single paragraph." These give the model a clear stopping point instead of letting it wander through every related topic.

Instead of "How do I make a pivot table in Excel?", try "In 3 steps: how do I make a pivot table in Excel?" The second gets you a tight, actionable answer. No detour through data analysis theory.

Make Them Skip the Scenic Route

Add "no preamble" or "skip the introduction" to cut the warm-up paragraph. The model typically starts with context-setting because that's how good explanations work in its training data. But you already know why you're asking.

When asking "What's the difference between PNG and JPG?", add "no preamble, direct answer only" and you'll skip three paragraphs about image compression history. You get straight to "PNG supports transparency and is lossless; JPG is smaller but loses quality." You've just avoided learning about bitmap rendering when you only needed to know which export button to click.

Try "assume I know the basics" to prevent explanations of foundational concepts. End with "be direct" to reinforce brevity throughout.

Set Up a Fast-Pass System

Use Custom Instructions in ChatGPT settings to set a default tone: "Always be concise. No introductions or conclusions unless asked." This trains the model's context window to expect brevity from you automatically, without adding instructions to every single prompt.

Create reusable templates saved in a doc: "[Question]. Answer in under 100 words, no background needed." Chain commands: "First give me the answer in one line, then if I reply ASK, give me more detail." This lets you control the depth on demand.

A product manager can save "Explain [concept] to a non-technical stakeholder in 2 sentences" and reuse it for every feature explanation. The system remembers your preferences across the conversation, so you're not constantly redirecting your guide back to the main path.

When You Actually Want the Full Tour

Sometimes comprehensive answers are useful. The verbose default exists for a reason. Use "explain thoroughly" or "include examples and context" when you need depth. Toggle between modes: start with "brief overview," then "now explain [specific part] in detail."

Learning a new programming language? Start with "What are Python functions in one sentence?" to get oriented, then ask "Now show me 3 examples with different use cases" to go deeper. You're building understanding in layers, pulling detail only where you need it, rather than trying to absorb everything at once and retaining nothing.

So What Can YOU Do With This?

Customer support teams can get faster answers to policy questions without scrolling past three paragraphs of context they already know. Writers can request snappy headline options instead of explanations about why each headline works (they'll judge that themselves, thanks). Developers can get code snippets without the accompanying tutorial when they're just trying to remember syntax. Students can quiz themselves with direct answers before requesting full explanations. Anyone can save 30 seconds per query, which compounds to hours per week.

Real workflow: a social media manager asks "Caption for a product launch post, 15 words max, enthusiastic tone" and gets five options immediately. No lecture on brand voice strategy. They paste the best one, move to the next task, and finish their queue an hour earlier than usual.

TL;DR

Add length limits ("in one sentence," "under 50 words") to your prompts
Use "no preamble" and "direct answer only" to cut the warm-up paragraphs
Save prompt templates in Custom Instructions or a doc for consistent brevity
Toggle between brief and detailed modes depending on whether you're learning or executing

At least your guide means well. They just really, really love talking about sedimentary rock formations.

How to Teach Your AI Agent a New Trick: Building a Custom Skill in 15 Minutes

Rob Methven — Mon, 10 Aug 2026 23:38:29 +0000

You know that guy at the mall in the red suit? He's amazing at the classics. "Ho ho ho!" Nailed it. Asking kids what they want for Christmas? Decades of experience. But when a seven-year-old asks for a Squishmallow in the shade "somewhere between lavender and periwinkle, but NOT the axolotl," he just smiles and nods. He has no idea what any of those words mean. Now imagine you slip him a laminated cheat sheet with photos, prices, and exact store locations. Suddenly he's giving parents aisle numbers and SKU codes. Same Santa, completely different level of usefulness.

That's what we're doing today. You're going to teach your AI agent something specific to your actual work, and it'll take about as long as your lunch break.

Why Your AI Keeps Saying "I'll Do My Best" (Then Doesn't)

AI agents arrive with impressive general knowledge. They can write emails, explain concepts, summarize documents. But they don't know anything about YOUR world. They've never seen your company's spreadsheet format. They don't know that "adjusted revenue" means something different in your department than it does everywhere else. They've certainly never heard of a Squishmallow.

Without specific instructions, the agent improvises. It guesses. It produces something that looks roughly right but misses the details that actually matter. You wanted periwinkle, you got blue.

A skill is packaged instructions combined with resources (data files, code snippets, templates, access to specific tools) that teach the agent how to handle one particular task your way. Not the general way. YOUR way.

The difference between an AI that's "pretty helpful sometimes" and one that actually saves you three hours every week comes down to whether it has the right cheat sheet.

The Two Things Every Skill Needs (Instructions and Props)

First, you need clear, step-by-step instructions. Not vague guidance. Actual steps that tell the agent exactly what to do and in what order. "Pull data from these specific columns. Calculate this specific thing. Format the output this specific way." The kind of instructions you'd give someone who will ask zero follow-up questions because they're not allowed to.

Second, you need the actual resources required to execute those instructions. Code snippets the agent should run. Data files it should read. Templates it should fill in. API access it needs to fetch information.

Santa needs to know what a Squishmallow IS (the concept, the variations, the current hot sellers) and where to actually get one (aisle 7, third shelf, also available online with two-day shipping). One without the other leaves him either knowledgeable but useless or confident but wrong.

Every AI tool that supports skills does some version of this pairing. To make it concrete, the rest of this guide uses Claude Code, the version of Claude that runs in your terminal, because its skills are just files on your computer and you can read them with your own eyes. A skill there is a folder. Inside the folder is a file called SKILL.md holding the instructions, and any other file you drop in beside it becomes one of the props.

Say you're building a skill that generates your weekly email report. The instructions are "pull data from columns B through F, calculate percent change from last week, format as three bullet points highlighting the biggest changes, use casual but professional tone." The resources are your actual spreadsheet template and the email format you always use. Both pieces, one package.

Building Your First Cheat Sheet (The 15-Minute Version)

Pick one task you do every week that follows the same steps every time. Maybe it's formatting meeting notes. Maybe it's pulling numbers for a status update. Something repetitive enough that you could do it half-asleep.

Write down those steps in plain English. Pretend you're training someone who takes everything literally and never asks clarifying questions. "Open the attached template. Sum column C. Compare to last week's total. Write three bullet points. The first bullet should highlight the biggest change. Use percentages, not decimals. Keep it under 100 words."

Now gather the resources. The spreadsheet template. The email format. The data source. Whatever the agent needs to actually execute those steps. If you reference "the template" in your instructions, you need to attach the actual template file.

Now make the folder. The name you give it becomes the command you type later, so keep it short and obvious:

mkdir -p ~/.claude/skills/weekly-report

Inside that folder, create a file named SKILL.md. The top of the file is a small block of settings fenced by three dashes, and the rest is the instructions themselves:

---
description: "Builds the Friday sales email from the weekly numbers. Use when the user asks for the weekly report or the Friday email."
---

## Instructions

1. Read numbers.csv in this folder.
2. Sum column C and compare it to last week's total.
3. Write exactly three bullet points, biggest change first.
4. Use percentages with the % symbol and no decimals.
5. Keep the whole thing under 100 words, casual but professional.

That description line is doing more work than it looks. It's how Claude decides on its own that this skill is the right one for what you just asked, so write it as "what this does, and when to reach for it" rather than a title. Everything in the settings block is optional, but this is the one worth getting right.

Then drop your props in the same folder, the numbers.csv your instructions reference, a template, whatever the steps actually need. Put it where you said it would be.

Test it by typing /weekly-report. You can also just ask for the Friday email in plain English and let Claude match your request to that description. The first test, you'll spot something you forgot to specify. You'll add it. Second test usually works.

Two details worth knowing before you build a pile of these. A skill in ~/.claude/skills/ follows you into every project, while one in a project's own .claude/skills/ folder stays put and ships to whoever clones the repo, which is the one you want for anything team specific. And skill instructions cost you nothing until they're actually used, so a long, fussy, deeply specific skill is not a tax on every other conversation you have.

When Your Skill Bombs (And How to Fix It Fast)

First test, the agent does something confidently and completely wrong. It sends parents to the toy aisle from 1987 where Squishmallows definitely do not exist and never have.

Your instructions were too vague. You assumed knowledge the agent doesn't have. You said "format it nicely" when you meant "use bullet points with bold headers and no more than 50 characters per line." Add one example showing the exact output you want. Show him an actual photo so he knows what he's looking for.

Second test, the agent says it can't access something. Your resource file isn't actually attached, or it's in a format the agent can't read, or you referenced "the Q3 template" but attached a file named "sales_data_final_v2.csv."

Check your attachments. Make sure file names match what your instructions say. Confirm the agent can actually open that file type.

Your report-generating skill outputs 0.15 instead of 15% because you didn't specify format. You add "format all percentages with the % symbol, no decimals" and test again. This time it works. Third time is usually the charm because you've made all the implicit stuff explicit.

So What Can YOU Do With This?

Create a "Weekly Report Generator" skill with your actual spreadsheet format and email template. Every Friday at 3pm becomes a three-minute task instead of a thirty-minute one.

Build a "Meeting Notes Formatter" that takes your messy real-time notes and outputs them in your company's standard format with action items, decisions, and follow-ups properly categorized.

Make a "Customer Email Responder" skill loaded with your FAQ answers, your company's tone guidelines, and examples of great responses. Handle the routine questions in seconds, spend your time on the complex ones.

Design a "Data Cleanup" skill that knows your specific column names, understands your validation rules, and fixes the recurring errors in that one report everyone uses but nobody wants to maintain.

Any task you do the same way more than twice a month is a skill waiting to happen. A marketing manager creates a "Social Post Analyzer" skill with their brand guidelines and competitor examples. What used to take thirty minutes of review now takes three minutes of tweaking AI output.

TL;DR

A skill packages step-by-step instructions with the actual resources (templates, data files, code) an AI agent needs to handle a specific task in your workflow
In Claude Code a skill is just a folder holding a SKILL.md file, where a short description tells Claude when to reach for it and the numbered steps tell it what to do
Build one in 15 minutes by picking a repetitive task, writing the steps in plain English like you're training someone who asks no questions, dropping your files in beside them, and testing twice
First test will probably fail because you assumed knowledge or forgot to attach something. Add examples and check your resources are actually there
Any task you do the same way twice a month is worth automating into a skill that saves you hours every week

After all, nobody wants to be the Santa who confidently directs parents to the Cabbage Patch Kids when the kid specifically asked for the purple Squishmallow unicorn.

What Are AI Agent 'Tools' and Why Can't It Just Know How to Book a Flight?

Rob Methven — Mon, 10 Aug 2026 23:36:04 +0000

Picture a highly motivated octopus sitting in a control room. Eight arms ready, eyes alert, brain firing on all cylinders. This octopus is incredibly smart. It understands exactly what you need. It can read complex instructions, make sophisticated decisions, and communicate brilliantly about what should happen next.

There's just one problem: the control room came empty. The octopus can only interact with buttons, levers, and switches that someone actually installed in its tank. No matter how intelligent it is, if there's no "book a flight" button bolted to the wall, those tentacles are just waving at water.

This is the gap that trips up almost everyone first encountering AI agents. You ask for something perfectly reasonable, the AI responds with confident enthusiasm about helping, and then... nothing happens. Or worse, something definitely didn't happen but the AI seems to think it did.

The Tank Came Empty

Language models like GPT-4 or Claude are astonishingly good at understanding your requests and generating relevant text. They can write that email, draft that flight itinerary, compose a perfect message to your team about why you'll be out next Tuesday.

But generating text about an action is completely different from performing it.

What transforms a language model into an agent is the addition of tools, which are specific functions or APIs the agent can call to interact with external systems. One button might trigger "send email via Gmail API." Another lever could pull "search calendar for conflicts." A third switch might activate "query flight booking database."

Without these explicit connections, the octopus just floats there, understanding everything, capable of nothing. ChatGPT can write a beautiful email to your boss requesting time off, but it can't actually send it or check your calendar for conflicts unless those specific controls are connected.

Installing Buttons

Developers write function descriptions that the AI can read and understand. These descriptions work like instruction manuals mounted next to each button.

"This lever searches Google Drive. Give it a search term as text. It returns a list of matching files."

"This button creates a Slack message. Provide a channel name and message content. It posts the message and returns a confirmation."

The octopus reads these manuals and builds a mental map of its control room. When you make a request, it figures out which buttons to push, in what order, and with what settings. Then it actually calls those functions, triggering real actions in real systems outside the tank. The tool executes, something happens in the external world, and results flow back in.

Zapier's AI Actions or custom GPTs let you connect specific services. You might give your agent a "search my Google Drive" button, a "create Slack message" lever, and a "check weather API" switch. When you ask "Find that proposal doc and share it in the marketing channel," the octopus decides which buttons to push and in what order, then actually triggers those real functions. First the search happens, returning actual files. Then the Slack post goes out, pinging real people.

Reaching for Buttons That Aren't There

Here's where things get weird. The octopus is so smart and so eager to help that it will confidently reach for buttons it thinks should obviously exist, even when they don't.

The AI invents plausible-sounding functions that were never actually installed, then tries to use them. From its perspective, "book_flight" sounds perfectly reasonable. Surely that button exists, right?

This is why you see responses like "I've booked your flight to Denver for next Tuesday" followed by... nothing. No confirmation email. No calendar entry. No actual reservation anywhere. The octopus is miming pushing a button that doesn't exist, generating confident text about actions it cannot actually perform.

The tool library determines capability boundaries, not the AI's intelligence. A brilliant octopus in a sparse control room is still limited to whatever's been bolted down.

More Buttons, More Complexity

Each new tool expands what's possible. Connect a weather API, and suddenly your agent can check forecasts. Add a database query function, and it can pull sales numbers. Install a calendar integration, and meetings can actually get scheduled.

But each addition also increases complexity. With fifty tools available, the agent must choose correctly from fifty options every single time. Which button for this particular situation? Should I pull two levers in sequence or just one?

The octopus has to read your request, survey its entire control room, and pick the right combination of actions. More buttons means more power, but also more opportunities to push the wrong one or forget a crucial step. Well-designed tool sets have clear, distinct purposes that minimize overlap and confusion. Vague, redundant tools create hesitation and errors.

Microsoft's Copilot in enterprise settings might have tools for searching SharePoint, querying databases, sending Teams messages, creating calendar events, and generating reports. "Schedule a meeting with everyone who worked on the Q3 campaign" needs calendar access, employee directory lookup, and project tracking queries. Get the order wrong or use the wrong search parameters, and the octopus just flails around pressing things randomly.

So What Can YOU Do With This?

When evaluating AI assistants, ask what tools they actually have access to, not just how smart they sound. A demo that shows fluid conversation means nothing if the agent can't actually touch your systems.

For custom agents (GPTs, Zapier bots, or whatever platform you're using), start with two or three essential tools rather than connecting everything at once. Pick the actions you need most often. Test those thoroughly. Add more only after the core functions work reliably.

If an AI claims it did something but nothing happened, check whether that tool was actually installed. Nine times out of ten, the button simply doesn't exist. The agent isn't lying exactly, it's just reaching for controls that aren't there.

Build your own simple tools if you're comfortable with it. Many platforms let you connect APIs without writing code. Zapier, Make, and similar services offer visual interfaces for linking services together, then exposing those connections as tools your agent can use.

Understand that "I can help with that!" doesn't mean the agent CAN, only that it understands the request. Comprehension and capability are completely separate things.

Before trusting an AI agent to manage your calendar, verify it has actual Google Calendar or Outlook API access, not just the ability to talk about calendars persuasively. Test it with a low-stakes request first. If you're building a custom agent for your team, connect your three most-used systems (Slack, your CRM, your project tracker) before adding the nice-to-haves. Watch what works and what causes confusion.

TL;DR

AI agents are only as capable as the specific tools (functions, APIs, integrations) you give them access to. Smart responses don't equal real actions.
Tools are explicitly connected functions that let the agent interact with external systems. Without them, the agent can only generate text about what should happen.
A confident response explaining how it "booked your flight" doesn't mean the agent actually has the tool to do what you asked. Check what's really connected.
Start simple when building agents: connect a few essential tools first, test thoroughly, then expand based on what actually works in practice.

And remember, no matter how many times the octopus gestures enthusiastically toward the northwest corner of the tank, if there's no button there, nothing's getting booked.

What Is Temperature in AI? (And How to Stop Getting Poetry When You Asked for a Grocery List)

Rob Methven — Thu, 30 Jul 2026 21:16:31 +0000

Remember Magic 8-Balls? Those plastic oracles you'd shake for life advice, only to get "Reply hazy, try again" when you asked if your crush liked you back? Imagine someone added a little dial on the bottom. Turn it all the way to zero and the thing becomes painfully predictable, only ever offering "Yes" or "Most likely." Crank it all the way up and suddenly it's inventing answers that never appeared in the original twenty options, things like "Ask your neighbor's cat" and "The moon suggests Thursday."

That dial is temperature, and every AI language model has one.

How the dial works

Temperature is a setting, usually ranging from 0 to 2, that tells an AI model how much risk to take when picking the next word. The model calculates the probability of every possible next word, then has to pick one. At low temperatures, it plays it safe and picks the most probable option almost every time. At high temperatures, it's willing to gamble on unlikely choices further down the list.

This is why you can ask ChatGPT the exact same question twice and get a straightforward answer on Monday and what appears to be surrealist fiction on Tuesday.

When you ask ChatGPT to write a professional email at temperature zero, you'll get "Dear Sir or Madam, I am writing to follow up on our previous correspondence..." every single time you hit enter. Set temperature to 1.5 and it might open with "Greetings, fellow traveler of the inbox wilderness" because that phrasing, while statistically improbable, is now in play.

Why boring is sometimes good

At temperature zero, you get the most boring dinner guest imaginable. It always picks the single most likely next token (the technical term for a chunk of text, usually a word or part of one). No variety, no surprises, just the statistical favorite every single time.

This turns out to be perfect when you need factual accuracy, code that actually compiles, or data extraction where creativity equals mistakes. If you're asking AI to pull invoice numbers from receipts, temperature zero means it outputs "12345" when it sees "12345" on the page. Temperature 1.8 means it might decide "12345" looks like it could also be "12346" or "INVOICE_NUM" and helpfully improvise. You did not ask for help. You asked for accuracy.

Higher temperatures let the model sample from less probable options, which introduces variety and surprise. The model isn't working harder or thinking more deeply. It's just willing to pick the seventh most likely word instead of always crowning first place.

The settings you'll actually use

Temperature 0 to 0.3 is where you only get the top one or two stock answers. Use this range for math, code, formatting tasks, translations, or anything where there's objectively a right answer and you'd like the AI to find it instead of workshopping alternatives.

Temperature 0.7 to 1.0 is the default zone. Responses have personality without veering into experimental theater. This range works well for drafting emails, brainstorming with a partner who stays on topic, writing explanations, and general question-answering where you want it to sound human.

Temperature 1.2 to 2.0 is where things start consulting the stars. Answers get weird, creative, and sometimes incoherent. The model is now free to choose words it would normally never pick, which means you'll get unexpected metaphors, unusual phrasings, and the occasional sentence that seems to have been written by someone who just woke up from a vivid dream. Use this range for creative writing, breaking through writer's block, or generating ideas you'd never think of yourself.

Most tools default to 0.7 or 1.0 because it balances usefulness with personality. The AI sounds natural without routinely suggesting you consult celestial bodies for business decisions.

Ask Claude or ChatGPT to name your new bakery at temperature 0.2 and you'll get "Sweet Treats Bakery" and "The Bread Box." Crank it to 1.8 and you'll get "Flourish & Punish," "The Carb Conspiracy," and "Gluten Intentions" because the model is now free to take swings at word combinations it would normally consider too risky.

So what can YOU do with this?

When using ChatGPT, Claude, or API tools, look for "temperature" in advanced settings. It's often tucked away under "model parameters" or a similar menu that the interface doesn't show you by default. You may need to click a settings icon or switch to a playground mode.

Drop temperature to 0 or 0.1 when you need consistent, repeatable outputs. This means generating CSV files, writing SQL queries, proofreading documents for typos, summarizing meeting notes into action items, extracting data from forms, or translating text where you want it to mean the same thing every time.

Keep it at default (0.7 to 1.0) for everyday tasks like drafting emails, answering questions, getting writing assistance, or having the AI explain concepts. This is the range where it sounds like a helpful colleague instead of either a robot or someone who took too much cold medicine.

Push it to 1.3 or higher when you're stuck creatively. Use it for brainstorming campaign slogans, writing fiction, coming up with team names, exploring wild "what if" scenarios, or generating options you'd never consider yourself. The goal here is surprise.

If the AI is being too weird or off-topic, lower the temperature. If it's boring you with the same phrasing over and over, raise it. You're adjusting how much it's allowed to wander from the beaten path.

In tools like OpenAI Playground or when making API calls, you can set temperature per request. This means you can use low temperature for the facts and high temperature for the flavor in the same project. You're writing a product launch email? Use temperature 0.2 to generate the bullet points listing features (accurate, no creative reinterpretation of what your product actually does). Then switch to temperature 1.2 to write three different subject line options that don't sound like every other SaaS email currently clogging your inbox.

TL;DR

Temperature controls how predictable (low) versus creative (high) AI responses are, usually on a scale from 0 to 2.
Low temperature (0 to 0.3) makes AI pick the most likely next word every time. Use it for facts, code, data, and anything where accuracy matters more than variety.
High temperature (1.2+) lets AI gamble on unlikely word choices. Use it for brainstorming, creative writing, and when you need unexpected ideas.
Most tools default to 0.7 to 1.0, the sweet spot for natural conversation without the moon suggesting Thursday.

Though honestly, the cat might have some thoughts on your Q3 projections.

What Is Retrieval Augmented Generation (RAG), and Why Does It Make AI So Much Less Confidently Wrong?

Rob Methven — Thu, 30 Jul 2026 15:42:25 +0000

You know that game show contestant who buzzes in before the host finishes reading the question, shouts "MOUNT EVEREST!" with absolute certainty, and then looks genuinely confused when the correct answer turns out to be "the Treaty of Westphalia"? That's been AI for most of its existence. Supremely confident, occasionally correct, and deeply committed to whatever pops into its head first.

Now imagine that same contestant gets a new rule: before answering, they can phone a friend who has the exact relevant textbook already open to the right page. The friend reads them the actual answer, word for word, and then the contestant puts it in their own words for the judges. Suddenly, our buzzer-happy friend is getting questions right. That phone call is Retrieval Augmented Generation, and it's the reason AI chatbots have gotten weirdly more useful in the past year.

The Old Way: Confidently Wrong at 200 Miles Per Hour

Traditional large language models (big AI systems trained on tons of text) get trained on enormous dumps of text scraped from the internet, books, and whatever else researchers can feed them. Then the training ends. The model gets sealed off, frozen in time with whatever it learned.

When you ask a question, these models generate answers by predicting the most plausible-sounding next words based on patterns they memorized during training. It's essentially very sophisticated autocomplete. The AI has no fact-checking mechanism. It doesn't "know" anything in the way you know your own phone number. It just knows what words tend to follow other words.

This leads to what researchers politely call hallucinations, which is a fancy term for "making stuff up with tremendous confidence." The AI generates text that sounds authoritative and well-structured because it's learned the pattern of how authoritative text sounds. But the actual facts? Those might be completely invented.

The contestant hears "This Australian city..." and immediately slams the buzzer. "SYDNEY! The capital is Sydney!" It sounds right. It feels right. Major city, everyone's heard of it, definitely in Australia. The fact that the actual capital is Canberra becomes irrelevant when you're pattern-matching your way through life.

ChatGPT famously invented entirely fictional legal cases that lawyers then cited in real court filings. Customer service bots have confidently stated refund policies that don't exist. The AI isn't lying, exactly. It's just assembling plausible-sounding words with no mechanism to check if those words correspond to reality.

The Lifeline: Calling a Friend

RAG adds a crucial step before the AI opens its mouth. When you ask a question, the system first searches through a specific database, document collection, or knowledge base looking for relevant facts. This is the retrieval part, and it works like a very fast, very focused search engine.

The system pulls the most relevant chunks of actual text from real documents. These might be paragraphs from your company wiki, sections from product manuals, snippets from recent news articles, or passages from technical documentation. Then it hands those retrieved chunks to the AI as context before the AI generates its answer.

The friend on the phone is flipping through the textbook right now, finding the section on Australian capitals, and reading it out loud. "Canberra, founded in 1913, purpose-built as a compromise between Sydney and Melbourne..." The contestant hears this, processes it, and can now formulate an answer grounded in actual facts rather than vibes.

The AI still generates the final answer in its own words. It's not just copy-pasting from the retrieved documents. But now it's working from source material instead of pure pattern completion.

A company chatbot using RAG searches your internal product documentation before answering customer questions. When someone asks about the return policy, the system retrieves the actual text from page 47 of the policy manual, then generates a natural-sounding response based on that real information. No improvisation required.

Why This Fixes the Lying Problem (Mostly)

The answer is now grounded in retrieved text, not just statistical patterns from training. This changes everything.

First, the system can cite sources. You can trace the answer back to the specific document chunk it came from. If the AI tells you something weird, you can check the source it retrieved and see whether it interpreted correctly or went rogue.

Second, updates happen instantly. Change the document in the knowledge base, and the next retrieval pulls the new information. No expensive retraining needed. Your AI chatbot learns about the updated return policy the moment you save the new PDF.

Third, you can actually trust the answers more. The contestant has gone from "Sydney sounds right?" to "My friend just read me the encyclopedia entry: Canberra, founded 1913, chosen as a compromise between rival cities." That's a different level of reliability.

It's still not perfect. The friend might grab the wrong book. The contestant might misinterpret what they hear. But you've moved from "making things up" to "working from imperfect notes," which is a massive improvement.

Microsoft's Bing Chat and Perplexity AI show you the actual web pages they pulled facts from. You can click through and verify. Compare that to base ChatGPT, which would just generate plausible-sounding URLs that led nowhere.

The Two-Step Dance

Here's how it actually works when you ask a question.

Step one: your question triggers a search through the knowledge base. The system uses something called vector search or semantic matching, which is a fancy way of saying it looks for meaning, not just exact word matches. It finds documents that are conceptually related to your question.

Step two: the top results get stuffed into the AI's prompt as additional context. The AI receives both your original question and several paragraphs of retrieved information.

Step three: the AI generates its answer using both its training (all those patterns it learned) and the retrieved text (the actual facts you need). This combination is what makes it augmented generation. The generation process is enhanced by retrieval.

The contestant hears the question. The friend sprints to the reference shelf, checks the book, and reads back the relevant passage. The contestant then formulates their answer in complete sentences, using both the retrieved facts and their own ability to speak coherently.

This separation of knowing versus looking up keeps the AI flexible and current. The base model doesn't need to memorize every fact. It just needs to be good at understanding questions, searching effectively, and synthesizing retrieved information into helpful answers.

Notion AI searches your team's notes and meeting documents before answering "What did we decide about the logo?" Instead of hallucinating a decision based on what decisions typically sound like, it finds the actual meeting notes from last Tuesday and tells you what your team actually decided.

So What Can YOU Do With This?

Use AI tools that cite sources for research instead of vanilla ChatGPT. Perplexity, Bing Chat, and ChatGPT with web browsing enabled all use RAG under the hood. They'll show you where they got their information.

If you're building chatbots for work, RAG lets you feed them company wikis, instruction manuals, or Slack history without expensive retraining. The bot searches those documents in real time and generates answers grounded in your actual information.

Personal knowledge bases are getting interesting. Tools like Mem or Reflect use RAG to search your own notes when you ask questions. You can treat your scattered thoughts like a searchable database that talks back.

Always check the sources these systems show you. Retrieval can grab irrelevant chunks, especially if your question is ambiguous or your document collection is messy. The friend might read from the wrong chapter, and the contestant will confidently relay incorrect information with perfect grammar.

Understanding that "AI with access to the internet" usually means RAG under the hood helps you evaluate these tools. They're not magically omniscient. They're just really good at searching and synthesizing.

Ask ChatGPT with web browsing "What's the current mortgage rate?" and you'll get today's data retrieved from recent sources. Ask base ChatGPT the same question and you'll get numbers from 2021, confidently stated as if they're still current.

TL;DR

RAG (Retrieval Augmented Generation) makes AI look up real information in a knowledge base before answering, instead of just generating plausible-sounding text from training patterns alone.
It works through a two-step process: first searching documents for relevant facts, then feeding those facts to the AI as context while it generates its response.
This approach dramatically reduces hallucinations, enables source citations, and lets AI stay current without expensive retraining every time information changes.
You're already using it in tools like Bing Chat, Perplexity, ChatGPT with browsing, and workplace chatbots that actually know your company's internal documentation.

The contestant still gets questions wrong sometimes, but at least now they're misreading the textbook instead of just guessing that everything important happened in Sydney.

What Are Vector Embeddings? (And Why Your Spotify Wrapped Knows You Too Well)

Rob Methven — Thu, 30 Jul 2026 15:42:23 +0000

Imagine a postal worker who never learned to read. Not a single word. Can't tell an A from a Z, wouldn't recognize their own name on a birthday card. And yet, this worker has memorized the precise physical location of every house in an infinite city. They navigate by pure spatial memory, knowing exactly which homes sit in the same cul-de-sac, which ones are clear across town, and which are practically next-door neighbors. They've never read a street name or house number in their life, but ask them which residences are similar and they'll tell you instantly based on coordinates alone.

This is how vector embeddings work. An embedding is a representation of data (a word, a song, an image, anything) as a list of numbers that captures its relationships to other data. Your Spotify playlist, that photo of your dog, the word "pizza," they all get converted into coordinates in a vast mathematical space. The system doesn't "understand" content the way you do. It just knows where everything sits and can measure distances between points. Close together means similar, far apart means different.

How the Worker Learned the Territory

The worker didn't start with this comprehensive mental map. They built it gradually by walking millions of routes and noticing what appeared together. Which houses had mail delivered on Tuesdays. Which residents waved to each other. Which blocks had similar holiday decorations. Over time, patterns emerged, and the worker positioned each house based on these observed relationships.

The AI does the same. It processes massive amounts of examples and notices what appears in similar contexts. Words that show up near the same other words get placed close together in the coordinate system. "King" and "queen" both appear frequently alongside "royalty," "throne," "crown," and "castle" in text, so their coordinates land in the same neighborhood. "Dog" and "puppy" show up in similar sentences ("walked the...," "fed the...," "adopted a..."), so despite sharing zero letters, their positions sit remarkably close.

When Spotify analyzes millions of songs, each track becomes a point in mathematical space based on tempo, instrumentation, mood, lyrical themes, and which playlists group them together. Songs that appear in similar contexts (the same workout mixes, the same rainy-day collections) land near each other. When you hit play on a track you love, Spotify finds its nearest neighbors in that mathematical space and suggests them next.

The resulting space doesn't have just two dimensions like latitude and longitude. It typically has hundreds or even thousands, each capturing different subtle patterns. One dimension might encode "is this about royalty," another "is this typically young or old," another "does this appear in formal or casual writing." The worker's mental model is unfathomably complex, tracking relationships across more directions than human brains can visualize.

Google's search trained on billions of web pages this way, gradually learning which words and phrases appear in similar contexts across the entire internet. The system never attended English class, never learned grammar rules. It just walked enough routes to know the territory.

Measuring Distance Between Houses

Ask the worker which two houses are practically neighbors, and they'll tell you instantly by measuring the distance between coordinates. No need to check street names or calculate driving routes. The mathematical distance in their mental map reveals similarity directly.

Measuring the distance between two sets of coordinates (often using cosine similarity, a particular way of calculating how close two points are) tells you how similar the underlying things are. Romance novels and tax law textbooks end up in completely different neighborhoods. "Hot" and "cold" sit far apart. "Hot" and "warm" are much closer. "Boiling" and "scalding" are practically roommates.

This distance measurement enables the famous "king minus man plus woman equals queen" example. The worker can do spatial math: start at the king's house, measure the direction and distance to the man's house, then move that exact same direction and distance from the woman's house. You'll land very near the queen's coordinates. The mathematical space captured a pattern (gender relationships in royal terminology) without anyone explicitly teaching it that rule.

Netflix uses this constantly. Your viewing history gets converted into coordinates. The system measures distances to millions of other users' coordinates, finds your nearest neighbors in taste-space, then recommends what those nearby viewers watched. Nobody manually tagged "Breaking Bad" as similar to "Better Call Saul." The coordinates just landed close together because people who watched one often watched the other.

Why This Illiterate Postal Worker Is Everywhere Now

The same trick works for any kind of data. Turn it into coordinates, measure distances, find neighbors. Product descriptions become coordinates powering Amazon's recommendations. Customer support tickets become coordinates that automatically route to the right team. Images become coordinates, which is how Instagram recognizes faces and how Google Photos finds every picture of your cat without you tagging a single one.

The worker doesn't need to understand what makes two houses similar, just that their coordinates sit close together. The AI doesn't need to "know" why two songs feel related or why two faces look alike. The mathematical distances handle everything.

This spatial approach also enables comparing across different types of content. Text search can find relevant images because both get converted to coordinates in related spaces. You can describe a mood in words and get song recommendations because the coordinates capture abstract similarities like "energetic" or "melancholy" that transcend the specific medium.

Your iPhone's photo app turns every face into coordinates, then clusters nearby points together. Those 47 photos spanning five years, different lighting, different angles, different haircuts? All land close enough in face-space that the system realizes they're the same person and creates an album automatically. You never labeled anything. The distances told the whole story.

So What Can YOU Do With This?

Understanding coordinates helps you use AI search tools more effectively. Instead of hunting for exact keywords, search by concept or example. Many new tools let you search your own documents, photos, or bookmarks by describing what you want ("that article about productivity I read last spring") rather than remembering precise titles.

You can improve your prompts to ChatGPT by knowing it finds responses "near" your query in meaning-space. More context helps it triangulate your location in that space and find better neighbors. Vague queries leave it guessing which neighborhood you're even in.

If you're building anything involving recommendations or search, coordinate-based tools are now accessible without advanced degrees. Vector databases like Pinecone, or built-in features in Notion and Obsidian, let you add "find similar items" functionality to your projects. You feed in your data, the system converts it to coordinates, and similarity search becomes almost trivial.

This knowledge also clarifies why AI makes certain weird mistakes. If two unrelated things accidentally land near each other in the mathematical space (maybe they appeared in similar contexts by coincidence), the system thinks they're similar even when they're obviously not to a human. The worker trusts the coordinates completely, even when the map occasionally lies.

Google Photos lets you search "beach sunset" and surfaces those exact scenes despite zero manual tags. ChatGPT answers questions phrased awkwardly because it finds meaning-neighbors to your garbled query. Both rely on placing related concepts near each other in coordinate space, making "close enough" astonishingly powerful.

TL;DR

Vector embeddings convert any data (words, images, songs) into coordinate lists where mathematical distance represents similarity, powering most modern AI recommendations and search. AI learns these coordinates by processing millions of examples, placing items that appear in similar contexts near each other automatically without manual rules. This single technique drives Netflix recommendations, Google Photos face recognition, Spotify suggestions, and semantic search across basically every platform you use daily. You can use coordinate-powered search right now in tools like Google Photos, Notion, and ChatGPT to find things by describing what you want instead of remembering exact keywords.

The postal worker still can't read their own name tag, but they just delivered your package to the right house on the first try anyway.