DEV Community: Rob Methven

How to Use AI to Turn Meeting Notes Into Action Items (Without Re-Reading an Hour of Rambling)

Rob Methven — Wed, 14 Oct 2026 13:02:17 +0000

You've just sat through an hour-long meeting. Somewhere in the transcript (or your frantic notes) are the three things people actually agreed to do. The rest is small talk, tangents about lunch orders, a ten-minute debate that ended with "let's table that," and someone's story about their cat. You need to find the action items, but re-reading the whole thing sounds about as appealing as alphabetizing a junk drawer.

Enter the AI: a detective who specializes in sifting through hoarder apartments looking for the one sticky note that says who owes rent. Everything else (the grocery lists, the inspirational quotes, the half-finished sudoku puzzles) gets left on the floor. You just have to tell the detective what evidence actually looks like.

The Scene of the Crime

Picture the apartment. Papers everywhere. Most of it is noise. Buried in there is "Sarah will mock up three homepage concepts by Friday," but it's sandwiched between fifteen minutes about someone's vacation and twenty minutes of brainstorming that went nowhere.

The detective needs instructions about what counts as evidence. In AI terms, this is called a prompt: the specific instructions you give the model to tell it what to extract. Think of it as handing over a checklist. Tasks with owners and deadlines? That's evidence. Everything else? Clutter.

When you're working with a tool like ChatGPT, the prompt is just the text you type before pasting your notes. Something like: "Extract all action items from this transcript. An action item has a person's name, a task, and ideally a deadline." Without it, you get everything that vaguely resembles a to-do, including the stuff nobody actually committed to.

Teaching the Detective What Rent Notes Look Like

The detective doesn't walk in knowing what a rent note looks like versus a phone doodle. You teach it by giving examples in your prompt.

This technique is called few-shot learning: you show the model a couple examples of what you want, and it learns the pattern. You might paste two sample action items into your prompt. "Alice will review the contract by Tuesday. Bob owns the client follow-up." Now the detective knows that "John will send the report" is a rent note, but "We should probably think about reports" is just clutter.

Real-world example: you paste your messy product planning transcript into ChatGPT along with those two sample sentences. The AI picks up on the structure (person, verb, task, optional date) and pulls out only the lines that match. It ignores the brainstorming, the questions, and the vague "someone should look into that" statements. You get a clean list of who's doing what.

Ignoring the Sudoku Puzzles

AI is helpful to a fault. It will try to extract everything that looks vaguely task-like unless you tell it what to ignore.

Add a line like this to your prompt: "Skip ideas that weren't agreed on, questions without answers, and vague maybes." The model uses something called context understanding to distinguish between "We need to fix the bug" (someone was assigned) and "Maybe we could fix the bug?" (nobody was assigned). It reads the surrounding sentences to figure out whether a statement is a commitment or just a floating thought.

In practice, this saves you from drowning in half-ideas. Picture a brainstorming session where your team floated ten ideas but only assigned two. Without the negative instructions, your AI-generated list has ten items and you have to manually cross out eight. With them, you get the two that actually matter.

Getting the Evidence Report in the Right Format

Raw extraction is helpful, but what you really want is a usable list. Owner, task, deadline, formatted so you can forward it to your team without retyping anything.

Tell the AI exactly how to format the output. "Create a table with columns: Owner, Task, Deadline." This is called structured output: asking the model to return information in a specific, machine-readable (or spreadsheet-ready) format instead of a paragraph of text.

The detective doesn't just hand you a pile of sticky notes. They type up a clean report with headers and rows. You can paste it directly into Notion, Slack, or your task tracker. If you want to get fancy, ask for JSON format and import it straight into your project management tool without touching a keyboard.

Real example: you finish a client call, dictate your notes into a voice memo, run it through a transcription tool, paste the transcript into ChatGPT with your formatting request, and ten seconds later you have a Markdown table ready to share. No manual cleanup. No reformatting by hand.

So What Can YOU Do With This?

Start simple. Paste your meeting transcript or notes into ChatGPT with a prompt like this: "Extract all action items with owner and deadline. Format as a table. Ignore unassigned ideas." Hit enter. You'll get a clean list in about ten seconds.

Use it on recorded Zoom transcripts (Zoom's built-in transcription works fine), voice memos you dictated after a client call, or that sprawling Google Doc from your team offsite. If you use a transcription tool like Otter.ai (which records and transcribes meetings automatically), feed that transcript straight to the AI for extraction. You don't even have to take notes during the meeting anymore. Just listen, let the recorder run, and clean up later.

Save your prompt as a template. Write it once, save it in a note or a text file, and reuse it every week without rewriting instructions. Tweak it over time as you figure out what works. Maybe you need a "Priority" column. Maybe you want high-priority items flagged with an asterisk.

Share the formatted output immediately with your team so everyone knows what they signed up for before memory fades. Every Monday morning, you paste your Friday team meeting transcript into ChatGPT using your saved prompt, get a clean action-item table in ten seconds, and Slack it to the team before your coffee is cold. Nobody has to ask "wait, who was supposed to do that?"

You can also combine this with other tools. Export the table to a spreadsheet. Import it into Asana or Trello. Forward it to your manager. The hard part (reading an hour of rambling to find three commitments) is done. You're left with the useful part, formatted exactly how you need it.

TL;DR

AI can extract action items from messy meeting notes by following specific instructions (called prompts) about what to look for and what to ignore.
Give it examples of what an action item looks like (person, task, deadline) so it learns the pattern and skips the noise.
Tell it how to format the output (table, bullets, JSON) so you get something you can paste directly into your tools instead of a wall of text.
Paste transcripts from any meeting into ChatGPT with a reusable prompt, and you'll have a clean task list in seconds instead of re-reading an hour of rambling.

Turns out the detective is very good at finding rent notes. The sudoku puzzles, however, remain unsolved.

What Is Context Window? (And Why AI Forgets the Beginning of Your Conversation Midway Through)

Rob Methven — Wed, 07 Oct 2026 13:02:12 +0000

You've hired a goldfish to guide you through the aquarium. He's enthusiastic, knowledgeable, and surprisingly articulate for someone with gills. There's just one small problem: he can only remember the last seven tanks you've visited together. Stand in front of the seahorses and he'll expertly recall everything about the stingrays, the coral reef, the tropical zone, and the four exhibits before that. But the jellyfish tank where you started? The one where you mentioned you're terrified of tentacles? Gone. Vanished from his mind completely. He will, with absolutely no sense of irony, suggest you circle back to see the jellyfish again.

This is how AI chatbots experience conversation with you.

The goldfish has a very specific memory problem

The technical term is a context window, which is the maximum amount of text an AI model can "see" at any given moment. That text gets measured in tokens (chunks of roughly three to four characters each, not full words, just fragments). A 4,000-token window holds about 3,000 words total, including everything you've written and everything the AI has responded with.

Here's the cruel part: once you exceed that limit, the oldest information doesn't get filed away for later or condensed into helpful notes. It gets shoved off the edge of a cliff. The model literally cannot see it anymore. Those early messages have ceased to exist in its world.

ChatGPT-3.5 has a 4,096-token limit, which sounds generous until you're 20 messages deep into brainstorming a project and realize the goals you outlined at the start have fallen into the void. GPT-4's 128,000-token window (roughly 96,000 words) gives you far more room before the amnesia kicks in, but even that has edges. Every window does.

By the time you reach the sharks, you're a stranger again

You established your name, your project constraints, your budget, and three absolute deal-breakers in your opening message. Twenty exchanges later, the AI cheerfully suggests something that violates deal-breaker number one. You point this out. It apologizes. Five messages after that, it asks for your name.

You are not talking to an AI that's being careless. You are talking to an AI that is meeting you for the first time, over and over, because the early part of your conversation has dropped out of the window.

Say you're debugging code with Claude across 25 messages. You defined a variable called userPreferences way back in message two. In message 23, you reference it. Claude tells you it doesn't see that variable anywhere in your code. This feels like gaslighting, but it's simpler than that: message two fell out of the window six exchanges ago. Claude is telling you the truth about what it can see, which is an incomplete picture.

The repetition gets eerie. You'll reject a suggestion, explain exactly why it won't work, and move on. Ten messages later, the AI will propose the same idea again with fresh enthusiasm. You'll say no a second time. It will apologize. Another dozen exchanges pass, and here comes that same suggestion, now dressed up with slightly different wording.

The AI has no memory of your earlier "no" because that rejection has slipped out of view. Every time it encounters your current question, it's working from scratch with only the visible context. Your previous refusal might as well have happened to someone else.

You tell a chatbot in message one that you're vegetarian. You're planning a dinner party together. By message 35, having discussed appetizers, drinks, and dessert, it enthusiastically suggests beef Wellington as the main course. Your dietary restriction dropped out of the window somewhere between the cheese plate and the cocktail napkins. The AI isn't messing with you. It genuinely has no idea.

So what can YOU do with this?

First, stop trying to have one infinitely long conversation about everything. Start fresh chats for new topics instead of threading 40 messages deep. Each conversation has a shelf life.

When you're stuck in a genuinely long session (debugging complex code, drafting a document through multiple revisions, planning something with lots of moving parts), repeat your critical constraints every 10 to 15 exchanges. Yes, this feels redundant. Do it anyway. A quick "Remember: this is for a teen audience, needs to stay under $500, and cannot include dairy" every so often keeps essential context alive.

Use custom instructions or system prompts where available. Many chatbots let you set persistent instructions that sit outside the regular window, so they don't get pushed out by the conversation itself.

Copy and paste key information back into the chat when you notice the amnesia. Those signs are easy to spot: contradictions of earlier statements, questions you've already answered, or suggestions you've already rejected.

Pick models with larger windows for multi-step projects. Claude 3 Opus and GPT-4 Turbo both offer significantly more room than their smaller cousins. If you're going to have a 50-message work session, you want the biggest tank available.

Structure long documents by working in smaller chunks rather than pasting 50 pages at once and asking for feedback. Break it into sections, work through each, and start fresh conversations as needed. When using ChatGPT for a long research project, create separate chats for literature review, outline, and drafting instead of one 100-message marathon.

TL;DR

Context window is the maximum amount of text an AI can process at once, measured in tokens (roughly 3 to 4 characters each), typically between 3,000 and 96,000 words depending on the model.
Once the conversation exceeds that limit, the oldest messages disappear completely from the AI's view, causing it to forget instructions, repeat rejected ideas, and ask previously answered questions.
Work around it by starting fresh conversations for new topics, repeating critical context every 10 to 15 exchanges, using custom instructions, and choosing models with larger windows for complex projects.

At least he never gets bored of the seahorses.

6 Tricks to Get AI to Write Shorter (Because Not Everything Needs to Be a TED Talk)

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

You know that person at dinner parties who responds to "How was your weekend?" with a 45-minute monologue complete with flashbacks, character development, and a three-act structure when you were just being polite? That's your AI chatbot. Every single time.

ChatGPT and its cousins were trained on millions of articles, books, and essays where thorough meant good and comprehensive meant correct. The training data (all the text used to teach the model how language works) rewarded depth, nuance, and multiple examples. So when you type a question, the model interprets your polite inquiry as an invitation to deliver the director's cut with bonus commentary. A simple "explain API" becomes six paragraphs with historical context, multiple metaphors, real-world applications, and a thoughtful conclusion when you just needed one sentence before your meeting started three minutes ago.

The good news? You can teach your enthusiastic guest that sometimes "fine, thanks" is the correct answer length.

Set a Word Limit (And Threaten to Leave)

The simplest trick is telling the model exactly how much space it gets to work with. Add explicit constraints right in your prompt: "in 50 words," "one sentence only," "three bullets max," or "under 100 words." The model treats these as hard boundaries the same way your guest suddenly discovers the gift of brevity when you glance at your watch and mention an early morning.

Format constraints work even better because they come with built-in length limits. Try "as a tweet" (280 characters), "fit it on a post-it note," "text message length," or "subject line only." These phrases trigger compression into a container that physically can't hold a novella.

Real example: asking for "a 30-word summary of this contract" when you need to paste something into Slack gives you exactly that, instead of a three-paragraph legal analysis you'd have to summarize yourself anyway.

Ask for the Ending First

Instead of letting the model build up to its point with careful exposition, demand the conclusion immediately. Use phrases like "bottom line up front," "TL;DR first, then details only if I ask," "give me only the answer," or "just the conclusion, skip the explanation."

Language models generate text sequentially, predicting one word after another. When you specify that the conclusion comes first, you're interrupting the weekend saga with "wait, did you have fun or not?" before your guest can set the scene with Friday morning traffic conditions.

Try "Should I accept this job offer? Yes or no first, reasoning after" when you're trying to make a decision, not read a career philosophy treatise. You get the verdict in the first word, and you can always ask for the supporting logic if you actually want it. Most of the time, you won't.

Train Your Guest With Feedback

The model learns within a conversation. If the first response runs long, just reply with "shorter" or "too long, try again in half the words." It will revise its answer on the spot, using your feedback as a new constraint.

For a permanent fix, use Custom Instructions in ChatGPT's settings. Add something like "Keep responses under 100 words unless I ask for more detail" or "Always give brief answers first. I'll request elaboration if needed." This system-level setting modifies behavior across every conversation, so you stop saying "make it shorter" three times per chat.

Think of it as a standing preference. Your guest finally learns that when you ask how their weekend was, you're making polite noise while reaching for the appetizers, not requesting their autobiography.

So what can YOU do with this?

Start adding word limits when you're drafting quick Slack updates or text messages. "Write a response to this email in 40 words" gives you something you can actually send without editing, instead of a formal letter you need to trim yourself.

Request verdict-first format any time you're researching a decision about vendors, tools, or strategies. "Compare these two project management apps, verdict first" gets you the answer in sentence one. Read the reasoning only if the conclusion surprises you.

Set Custom Instructions once if your job requires lots of quick AI queries. Marketing managers asking for social post drafts, developers wanting code explanations, or anyone who checks ChatGPT twelve times a day will save hours by not manually trimming every response.

Use format constraints when you need to paste answers directly into other documents. "Summarize this article as three tweet-length bullets" gives you something presentation-ready. "Give me five subject-line options under 60 characters" means you're not counting letters yourself.

Train with "shorter" feedback mid-conversation instead of rewriting your entire prompt. If the first attempt misses, one word of correction usually fixes it.

Real workflow: combine techniques by setting Custom Instructions for default brevity, then adding "in 3 bullets" when you ask AI to summarize meeting notes you need to forward in 30 seconds. The standing instruction keeps things tight, and the specific format makes it copy-paste ready.

TL;DR

AI defaults to long answers because its training data rewarded thoroughness, not efficiency. You have to explicitly override that learned behavior.
Add hard limits to your prompts with word counts ("50 words"), sentence limits ("one sentence"), or format constraints ("as a tweet") that force compression.
Request conclusions first using "bottom line up front" or "yes/no, then explain only if I ask" to skip the windup.
Respond with "shorter" for instant revision, or set Custom Instructions once to stop re-explaining your brevity preference in every conversation.

And if all else fails, you can always just stop inviting it to dinner parties.

How to Use AI to Translate Jargon-Heavy Documents Into Actual English (Without Losing the Important Bits)

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

You know that person at medieval court whose entire job was standing between the king and the villagers, turning "Henceforth, by royal decree, all subjects within the realm shall remit unto the crown the customary levies as prescribed by ancient tradition, to be delivered no later than the final day of the harvest moon" into "Taxes are due Friday"? That interpreter got really, really good at spotting which ten-dollar words actually contained information and which were just His Majesty enjoying the sound of his own voice.

That's what large language models do with your insurance policy, medical records, legal contracts, and every other document designed to make you feel stupid. And you can put them to work right now.

Your Interpreter Has Seen Every Royal Decree Ever Written

The AI sitting inside ChatGPT or Claude wasn't taught to translate jargon by reading a dictionary. It read millions of documents (ordinary and technical, simple and complex, across every field humans write about) and learned patterns from that pile of text.

When you feed it a dense paragraph about "failure to maintain adequate security protocols pursuant to subsection 4.2.1," the model recognizes the phrasing. Somewhere in those millions of examples, it encountered insurance policies, their plain-language summaries, forum posts where confused customers asked what their policy actually meant, and explanations that boiled it down. The model learned that this particular flavor of bureaucratic throat-clearing usually translates to something like "we won't pay if you forget to lock your door."

This isn't simple word-swapping. The model understands context. It knows "adequate security protocols" means something different in a cybersecurity document than in a home insurance policy. It preserves the actual meaning while stripping away the decorative language that makes the king sound important but tells villagers nothing useful.

Buried on page 34 of your insurance policy, there's probably a section with five paragraphs of wherefores and heretofores that boils down to a single obligation. The model has seen enough insurance documents to recognize that pattern and extract what actually matters.

Briefing Your Interpreter on What Matters

Before court, you'd brief your interpreter on what the villagers actually need to know. Are they worried about deadlines? Penalties? What they're allowed to do? Same principle applies here.

You can tell the model your role and what you need preserved. "I'm a patient reading my test results. Explain this in plain English but keep any numbers that indicate a problem." Or "I'm a small business owner reviewing this contract. Flag any obligations, deadlines, or costs, and simplify everything else."

Better yet, you can show examples of what you want. "Here's a jargon-heavy sentence and here's how I'd like it translated." The model adjusts based on these instructions.

Medical test results are perfect for this. Your doctor's report might say "glomerular filtration rate of 92 mL/min/1.73m² indicates adequate renal clearance within established parameters." What you actually need to know is "your kidney function is normal." But if you're tracking specific numbers over time, you can ask the model to preserve those values while explaining what they mean.

When Some Words Carry Weight

A good court interpreter knows that some words can't be simplified. You can't translate "knighted" as "got a fancy title" because knighthood comes with specific legal rights. The word itself matters.

Software licensing agreements throw around terms like "perpetual license" and "subscription," and those aren't interchangeable. One means you own the software forever. The other means you're renting it monthly, and it vanishes if you stop paying. Simplifying that distinction into "you can use the software" loses crucial information that might cost you thousands of dollars.

You can ask the model to flag terms that carry specific legal or technical weight, then explain what those terms mean rather than paraphrasing them into mush. Some people request a two-tier output: a simplified version for quick understanding plus footnotes explaining the critical details that need precision.

The interpreter knows when to say "the king used a specific legal term here, and here's what it means" instead of guessing at a casual equivalent that misses the point entirely.

So what can YOU do with this?

Start with anything you're about to sign. Paste that contract into ChatGPT or Claude with the prompt "explain this in plain English and flag any obligations or deadlines." Read both versions before you commit. You'll spot the buried auto-renewal clause or the paragraph that quietly makes you responsible for someone else's mistakes.

Got technical specifications for a product you're considering? Upload them and ask "what does this product actually do and what are its limitations?" You'll learn whether that router really covers 3,000 square feet or if that's only under ideal laboratory conditions that don't exist in your house.

Your company's legal or technical team just sent meeting notes full of jargon, and you need to update the rest of your department? Feed those notes to the model and ask for a version that non-specialists can understand.

Medical documents and bills are notoriously impenetrable. Run them through AI to understand what you're actually being told or charged for. "Translate this explanation of benefits and tell me what I owe and why" turns a six-page insurance document into actionable information.

Here's a sneaky one: use it on your own writing. If you work in a specialized field, you've probably gone nose-blind to your own jargon. Ask the model to simplify your email or report. If it struggles to translate something you wrote, that's a sign you've accidentally buried your point where nobody will find it.

That 47-page employee handbook section on PTO policy? You don't need to read it. You need to ask the model "how many vacation days do I actually get and when do they expire?" Get your answer in 30 seconds instead of 30 minutes of cross-referencing subsections.

TL;DR

AI models trained on millions of documents can translate jargon-heavy text into plain language while keeping the details that actually matter to your situation. Give the model context about your role and what you need preserved (dates, costs, obligations) for output tailored to your needs. Use it on contracts, medical records, technical specs, legal documents, or any impenetrable text before making decisions or signing anything. Always review the output for critical details, especially on legal or financial documents, and ask the model to flag terms that need precision.

The king's still going to write his proclamations in the fanciest possible language. At least now you don't have to pretend you understood them.

What Is Prompt Chaining? (And How to Stop Asking AI to Do Five Things in One Breath)

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

Imagine you've decided to train a squirrel to make you a sandwich. You could try screaming "MAKE LUNCH!" while gesturing wildly at the kitchen counter, then stand back and watch as the squirrel tears through the bread bag, flings peanut butter across the floor, and somehow gets jelly on the ceiling. Or you could teach it one micro-task at a time: open the bread bag (just that, nothing else), remove two slices, set them on a plate, fetch the peanut butter jar, unscrew the lid. Methodical. Focused. Surprisingly effective.

This is prompt chaining. It's the difference between asking AI to juggle five flaming torches at once and handing it one torch at a time while you make sure nothing's on fire.

Why Your Squirrel Keeps Shredding the Bread Bag

When you ask AI to handle a complex task in one massive prompt (write a report, analyze data, format it beautifully, add citations, make it persuasive), you get back something that looks like a sandwich but tastes like confusion. The model tries to juggle everything simultaneously, which means it has no idea what you actually care about most.

Too many steps crammed into one instruction means too much room for the AI to misunderstand priorities, skip crucial steps entirely, or spend three paragraphs on something you needed in one sentence. The AI can't check its work mid-process. It can't pause and ask, "Hey, should I focus more on the pricing section or the timeline?" Errors compound. By the time you reach the end of the output, you're reading something that wandered off the path six paragraphs ago.

Prompt chaining solves this by breaking one complex request into a sequence of smaller, focused prompts where each output becomes the input for the next step. Instead of asking ChatGPT to "write a client proposal with research, pricing, timeline, and executive summary" in one breath, you split it: first, research the client's industry and current challenges. Then, draft three key pain points based on that research. Next, generate three solution options with rough pricing for each. Finally, write an executive summary that ties together the chosen option. Each step does one job. Each job gets done properly.

Teaching One Trick at a Time

Each link in the chain is a single, specific instruction with one clear purpose. You hand the squirrel the bread bag. It learns to open it without shredding the plastic. You check the result. Success looks like an intact bag with the twist tie removed. Only then do you move to step two.

You run the first prompt, review what comes back, then feed that output into the next prompt with a new, focused instruction. Each step builds on verified results from the previous one, so you catch problems early instead of discovering at the end that everything's been slightly wrong since step one.

The full workflow is a chain. Each individual prompt is a link. The beauty is that you're never asking the AI to hold seven things in working memory at once. It gets one task, completes it, and waits for the next instruction.

Say you're building a cold email campaign. First prompt: extract key details from this prospect's LinkedIn profile (their role, company size, recent posts about challenges they're facing). Second prompt: write three subject line options based on those specific details. Third prompt: draft the email body using the best subject line and weaving in the pain points you identified. Fourth prompt: suggest a three-email follow-up sequence if they don't respond. Each link produces something concrete. Each new prompt references what came before.

The Peanut Butter Doesn't Touch the Jelly Until Step Seven

Order matters enormously because each output carries forward into the next step. If your squirrel grabs the jelly jar before locating the bread, you're eating jelly off the counter with your fingers and calling it lunch.

You design the sequence so information flows logically. Research happens before writing. Outlining happens before drafting. Drafting happens before editing. You can't edit what doesn't exist yet, and you can't write persuasively about a topic you haven't researched. This seems obvious, but it's shocking how often people ask AI to do all three simultaneously and wonder why the output feels thin.

You can also branch. One prompt's output might feed into two different next steps depending on what you need. Maybe your research step uncovers two distinct audience segments, so you split into two parallel chains: one crafting messaging for enterprise clients, another for small businesses.

Creating a social media content calendar becomes manageable this way. First prompt: analyze my last month of posts and identify the five topics that got the most engagement. Second prompt: generate ten new topic ideas that build on those patterns. Third prompt: write captions for the top five ideas, matching the tone of my best-performing posts. Fourth prompt: schedule these across optimal posting times based on when my audience is most active. Each step is simple. Together, they're a system.

When Your Squirrel Finally Presents a Sandwich

The magic moment arrives when the final output appears and it's actually good. Not "good for AI" or "good enough to heavily edit." Just good. This happens because each step was allowed to do one thing well instead of trying to do five things poorly.

You've also built something more valuable than a single result. You've created a reusable process. Next time you need a sandwich, the squirrel knows the routine. You don't have to retrain from scratch or hope it remembers. The workflow is explicit and repeatable.

Chaining creates consistency because nothing is left to chance or the AI's interpretation of vague instructions. Each link is specific. The sequence is documented. You can save it as a template and run it again with different inputs.

You can swap out individual links without rebuilding everything. New peanut butter brand? Same process, different jar. Need to adjust your email tone? Modify link three, leave the rest untouched.

A customer support team might chain prompts to handle every incoming inquiry: first prompt categorizes the issue (billing, technical, general question). Second prompt retrieves relevant help documentation based on that category. Third prompt drafts a response incorporating those docs. Fourth prompt checks the tone for clarity and empathy. They save this chain and run it for every ticket, adjusting only the customer's original message each time. The workflow stays consistent. The quality stays high. Nobody's winging it.

So What Can YOU Do With This?

Stop writing 300-word mega-prompts and getting back mush. Break any complex task into three to five smaller prompts. You'll get better results in less time because the AI isn't trying to read your mind about which part matters most.

Start with the end in mind. What's your final output? A slide deck? A blog post? A project plan? Work backward to figure out what information each earlier step needs to provide. If the final step is "write an executive summary," what does that summary need to reference? Probably the analysis from step two and the recommendations from step three. Build the chain accordingly.

Use the output from prompt one as explicit input for prompt two. Copy-paste the AI's response directly into your next prompt along with new instructions. Don't make the AI guess what you're referring to. Show it.

Try chaining for research summaries that become slide decks. Brainstorm lists that become prioritized action plans. Raw data that becomes charts that become written explanations. Interview transcripts that become blog post outlines that become full drafts. Anytime you're thinking "this feels complicated," that's your cue to chain.

Save your best chains as templates in a document so you're not reinventing the wheel every Tuesday. Label each link clearly: "Step 1: Extract key themes," "Step 2: Generate headlines," and so on. Next time you need similar output, you've got a recipe.

For a presentation, chain it. First: "Summarize these three articles into five key takeaways." Second: "Turn these takeaways into five slide titles." Third: "Write bullet points for slide two based on takeaway two." Continue until you have a full deck. Each step is simple. Together, they're professional-grade output that didn't require you to do everything in your head first.

TL;DR

Prompt chaining breaks complex tasks into a sequence of smaller, focused prompts where each output feeds into the next step, preventing the AI from juggling too much at once and producing generic mush. Each link in the chain does one job well, letting you catch errors early and build toward a final result that's actually usable. Order matters: structure your chain so information flows logically (research, then outline, then draft, then edit) because you can't spread peanut butter on bread you haven't removed from the bag yet. Save successful chains as reusable templates so you've got a reliable system instead of starting from scratch every time.

Frankly, your squirrel's getting pretty good at this, and last Tuesday it added lettuce without being asked.

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

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.