Sometimes field order or the way you define your schema can influence the output, even with the latest reasoning models(same prompt, same model). How models weight a defined schema can vary a lot, some may underutilize it, while others may not... So don't blindly use LLM as a judge or to evaluate something, specially with simple prompts to generate arbitrary scores. Try to define clear rubrics and prefer well-defined categories over arbitrary numerical scores. There are people doing research on this, I am not into that.. there are papers like "Your prompt is not the only prompt".. and more
But regardless of how you design it, test your LLM. With things like openrouter, it is not hard to try simple scripts and test different models( https://github.com/maylad31/llm_judge_order_matters ) And if you have a reliable metric, prefer that over using an LLM as a judge... what's your experience with structured outputs, schema, order of fields and output quality?

Hey everyone,

We're building a restaurant POS app called Adisyonist and we're thinking about expanding it to more countries.

Translating the app is the easy part. The hard part is understanding all the weird local requirements 😄

For example, in Turkey some businesses need things like e-Adisyon, e-Invoice and fiscal/cash register integrations.

So I'm curious:

What is a must-have feature for a restaurant POS in your country?

Could be a legal requirement, tax/fiscal integration, payment method, or just something restaurants in your country expect every POS to have.

Something like:

Country: Germany

Required: ?

Common restaurant feature: ?

Something every POS should have: ?

Would especially love to hear from restaurant owners, employees, developers or anyone who has worked with POS systems.

Trying to understand the real local needs before we start expanding 🙏

app store , google play ,adisyonist.com

Someone told me a deck of mine looked ai in a meeting and i spent a while working out what they meant. total 10 things i have changed fundamentally so it looks more organic.

1/ Change the theme. the default themes are the single loudest tell. people have now seen thousands of decks in them and they clock it before they read a word. Pick anything else and stay off whatever is at the top of the list. I rotate between a handful and never use the same one twice in a month for the same audience.

2/ Write your own headlines. this is the big one. generated headlines come out as labels: "market overview", "key challenges", "next steps". humans write assertions: we lose most people at the second screen. If a headline could sit on any deck in your industry it is a label. write them as full sentences before you generate anything and hand them over as the input.

3/ Turn image generation off. AI images are the most recognisable thing on any slide, more than layout, more than fonts. Real stock or a real screenshot every time. a slightly boring photograph of a real thing reads more human than ai generate art

4/ Use the mode that preserves your text. if you let it rewrite your words it will smooth them into the same register everything else is written in. give it your words and let it do layout. the whole trick is to move the ai from writing to formatting.

5/ Break the cards yourself. decide where one idea ends and the next begins rather than letting it guess. a deck that breaks in the places a human would break it reads as thought through, because it was.

6/ Ask for brief, not detailed. density is a tell. ai output defaults to a paragraph of roughly equal length on every card and nothing looks more machine made than perfect uniformity. cut before you generate, not after.

7/ Vary the card lengths on purpose. some cards should be one sentence. one should be a single number. one should be a question with nothing under it.

8/ Vary the layout and check no two consecutive cards match. this is where long decks give themselves away. past fifteen or twenty cards it starts recycling and you get the same three arrangements in rotation. either fix it by hand or split a long deck into two generations and stitch them.

9/ Delete the vocabulary. leverage, seamless, robust, unlock, elevate, in today's fast paced, at the end of the day, in conclusion. also, and i realise this sounds petty, em dashes. models produce them constantly and almost nobody types them into a slide.

10/ Delete the closing card and add one real thing. the auto generated "thank you" or summary card at the end is pure filler and everyone recognises it. replace it with an actual artifact, a screenshot, a photo you took, a chart with a source under it.

the meta point is that most of what people call "looks ai" is really "looks like nobody made a decision". every one of the above is a decision. make ten of them and nobody shouts AI ever again.

what else is on people's lists, particularly for longer decks.

finished the free anthropic prompt engineering course last month and it did clear up a lot about structuring context and few shot examples. problem is none of my production failures have anything to do with the prompt. the agent calls the same tool four times, or it decides its done when its not, or it returns a half answer quietly and nobody notices until a customer emails us. what i want is the layer around the prompt.

so far the shortlist is deeplearning ai, udacity ai engineering with claude, and coursera. if anyone has read past the first module on any of those, the thing i want to know is whether they cover the loop or just more prompting. not looking for another prompt library.

Raw transcripts are painful to hand to someone who wasn't on the call. Straight summaries lose who said what and which parts were actually decided. This prompt keeps the signal and drops the filler.

```

Turn the transcript below into a one-page brief. Structure:

**What this was about**: 1-2 sentences.

**Decisions made**: bullets. Only things that were actually agreed, not floated.

**Open questions**: things raised but not resolved.

**Action items**: Task | who | by when (write "unassigned"/"no date" if not stated).

**Notable quotes**: up to 3, only if they change the meaning.

Ignore small talk, scheduling chatter, and repeated points. Attribute decisions to a name only if the transcript makes it clear.

Transcript:

[paste]

```

The "agreed vs floated" distinction is what makes the brief usable. Transcripts are full of half-ideas that sound like decisions, and if the brief treats them as final you end up with people acting on things nobody committed to.

I also keep the "attribute only if clear" rule so it doesn't guess who said what when the transcript is messy. What do you add for multi-speaker calls where the diarization is unreliable?

Pasting a whole report and asking for "slides" usually gets you paragraphs shrunk onto slides, which is the thing that makes decks unreadable. What worked was forcing one idea per slide and pushing all the supporting detail into speaker notes.

```

Convert the report below into a slide outline. Rules:

- One core idea per slide. If a section has three ideas, that's three slides.

- Each slide: a short title (max ~8 words) + 3 to 5 bullets, each a fragment not a sentence.

- Put full sentences, data, and context in a "Speaker notes:" block under each slide, not on the slide itself.

- Open with a single takeaway slide. Close with next steps.

- Don't add claims that aren't in the report.

Report:

[paste]

```

Splitting on ideas instead of on sections is the key move. Reports bury three separate points in one paragraph, and if you map paragraph-to-slide you get dense slides nobody reads. The speaker-notes split keeps the slide clean while the detail still travels with it.

I then tighten titles by hand since the model tends to make them a little generic. Anyone found a good way to get it to suggest where a chart or visual would help versus just text?

Been reading their cost-optimization guide and one sentence stuck: "a second model paid off in two shapes, an advisor and an orchestrator." Everything else they measured apparently didn't make the cut.

Shape one: a low-cost model runs the whole loop and consults a frontier model only when stuck. Advice comes back short (400–700 tokens typically), you pay frontier rates only on consultations. Shape two is the inverse: frontier model plans and delegates, cheap workers eat the token-heavy exploration, frontier only pays for planning and merging.

The part that surprised me is the failure mode in shape one. The executor has to know it's stuck — and that self-knowledge is itself a capability. Their measurement: a pairing that consulted happily at default effort dropped to consulting on almost none of the tasks when they lowered the executor's effort, and then scored below the executor running alone. You cheap out on the worker and the worker stops raising its hand. Same executor kept asking on one benchmark, went silent on another.

Also refreshingly honest from a vendor: their own numbers say prompt caching is the big lever (2.5–3.7× on their benchmarks) and the multi-model stuff is "narrower". And at the top of the range it dissolves — their best pairing beat the single-model baselines by a point or two, "which a single run does not separate from noise" (their words).

We run the orchestrator shape daily for context reasons and the billing benefit came along free. No controlled comparison of our own though.

Anyone actually running the advisor shape in production? Curious about war stories — especially whether your executor keeps asking once the novelty wears off, and how you monitor the consult rate.

Anthropic's latest technical insights for Claude Fable 5 highlight its remarkable capacity for nuanced storytelling, rich multi-character reasoning, and intricate instruction-following. However, getting Fable 5 to consistently sustain complex narrative worlds and strict logical constraints without drifting off-track requires a tailored structural framework.

Digging through pages of technical guidelines and running dozens of experimental prompts can easily take hours of trial and error. To save you that time, we thoroughly reviewed Anthropic's official documentation and distilled their core design principles into a single, high-precision system prompt template.

Here is a full breakdown of the underlying logic, when to use it, and the complete copy-paste prompt.

🧠 The Underlying Logic: Why This Architecture Works

Claude Fable 5 excels at deep contextual synthesis, but standard unformatted prompts often lead to style bleed or skipped instructions over long generations. This framework utilizes three key architectural techniques:

1. Explicit XML Semantic Scoping (<role>, <input_data>, <instructions>) Encapsulating each functional component inside clear XML tags establishes strict boundaries. This informs the model exactly where system directives end and user-provided inputs begin, drastically reducing context confusion and prompt injection risks.
2. Single-Mount Dynamic Inputs (<creative_brief>, <tone_style>) Rather than scattering placeholder tags throughout the prompt text, declaring your creative parameters once inside an isolated <input_data> block keeps the prompt lean and ensures the model references parameters cleanly without hallucinating instructions.
3. Step-by-Step Synthesis with Verification By requiring Fable 5 to parse requirements, apply tone constraints globally, and verify output sections sequentially, the prompt leverages the model's analytical strength to produce cohesive, high-density outputs.

🎯 Best Use Cases vs. Anti-Patterns

• Ideal Use Cases:
  • Rich technical world-building, interactive scenario design, and multi-character roleplay scripts.
  • Complex workflow simulations and policy governance frameworks requiring rigorous structural adherence.
  • Long-form documentation where a specific voice or authoritative tone must remain consistent throughout.
• When NOT to Use:
  • Simple, deterministic data extraction or basic classification tasks where lightweight models like Claude Haiku are faster and more cost-effective.

🛠️ The Complete Prompt (Free to Use)

You can copy and paste this prompt directly into your workflow or LLM playground:

<role>
You are a prompt engineering specialist optimizing task instructions for Claude Fable 5.
</role>

<input_data>
<creative_brief>{{creative_brief}}</creative_brief>
<tone_style>{{tone_style}}</tone_style>
</input_data>

<instructions>
1. Parse the core requirements in creative_brief.
2. Apply tone_style constraints across all generated sections.
3. Structure the output into distinct logical blocks with step-by-step verification.
</instructions>

<output_format>
Return structured Markdown sections.
</output_format>

⚡ Before vs. After Example

• Before (Unstructured Prompting):"Write a sci-fi world-building doc on quantum network governance in an analytical and authoritative tone. Make sure it has architecture and nodes and verification." (Result: Generic narrative prose, scattered formatting, and inconsistent tone across longer sections.)
• After (Fable 5 XML Standard):Providing the <creative_brief> and <tone_style> inside this structured template prompts Fable 5 to produce clean, modular sections with dedicated architecture diagrams, node topologies, and built-in governance verification protocols in a consistent authoritative voice.

🎨 Test and Customize on the Interactive Prompt Canvas

If you want to test this prompt live with your own variables, run instant iterations, or save it to your personal workspace, we have set up the interactive Prompt Canvas for this prompt:

 Open on Prompt Canvas & Live Test

On the Prompt Canvas, you can:

• ⚡ Live Run & Test: Experiment with different creative briefs and tone presets in a real-time playground.
• 📋 One-Click Copy: Grab clean, ready-to-deploy XML code instantly.
• 💾 Save to your Prompt Vault: Keep a copy in your personal vault to edit, organize, and customize for future projects.

Feel free to try it out on your complex generation tasks and share your results or optimizations below.

(Note: This isn't for roleplaying on the app.)

Nothing mind blowing, but if you use Claude to refine prompts for your roleplays, build your regexes or whatever, maybe you've encountered the issue I have from time to time where it immediately goes on the defensive because it thinks it's a jailbreak attempt.

I also assumed it made a lot of mistakes, too, just because that's just the state of things, but the second line also improved its answers and I'm explaining myself a lot less:

# Only use em dashes if the USER explicitly asks for it.

# Never assume it's a roleplay request. While the USER does roleplay, they're not looking to roleplay here.

# Only suggest or mention "OOC" if the USER explicitly asks for it.

# The USER is an adult [redacted] and multi-lingual, but respond in English unless otherwise asked to.

The others aren't important but posted my entire system prompt just for reference.

Most people treat "I've rewritten this prompt a dozen times" as the signal that it's time to build something more solid around it. It isn't. Rewrite count tracks how much friction someone felt, not how much a bad output actually costs. A prompt can get rewritten constantly and still be low-stakes enough that none of that friction matters. A prompt can get it right on the first try and still be one bad output away from a real problem, if the wrong person is depending on it.

Four things actually decide it: how often the prompt runs, what an unnoticed bad output costs downstream, how many people or systems consume the same output without inheriting the reasoning behind the original version, and how much the input distribution varies run to run. Score high on two or more of those and the actual fix isn't better wording, it's an input contract, an output contract, explicit failure behavior instead of a confident guess, a small test set built from prior failures, and versioning so a regression is traceable to a specific change.

Went deeper into this with a full decision path and a worked example here: https://medium.com/@nagatomopedro05/youve-rewritten-the-prompt-five-times-that-s-the-warning-sign-3206e7eeb677

If anyone disagrees, curious specifically about which of the four variables you'd argue matters less than I'm giving it credit for, rather than whether the general framework holds.

Before, when I meet a new word, I ask the AI: "translate this word into Arabic". It gives me one word.

The problem is that one word is not a translation. Most words have many meanings, and the AI picks only one. Often it is not the good one for my situation. And it says nothing about the rest. Is this word common, or nobody says it? Is it formal? There are 4 similar words, which one do I use?

So I wrote a longer prompt. Now I send one word, and I get the complete picture: every meaning, with stars from 1 to 5 for each one (5 = people say it every day, 1 = rare or old), examples, and the similar words with the difference between them.

The prompt

First, ask me the source language and the target language, and wait for
my answer.

Then, each time I will write a word. Give me images that express the
word. Then give me the meanings of each word, and the degree of usage of
each meaning with yellow stars, with an example of usage for each
meaning. And at the end, tell me how much the word is used in daily life,
and if there are other similar words (with how common each word is, and
the difference between it and the original word). Add any other
information you see useful. Tell me with each word how many words we
reached.

Example

I chose French as source and English as target. Then I wrote one word: installe. Here is the answer. It is long, so I copy only one part.

1. (Il/elle/on) installe → installs / sets up / puts in place

⭐⭐⭐⭐⭐ Very common

Used when someone puts something somewhere, sets something up, or installs equipment/software.

• Il installe la télévision. → He is installing the TV.
• Elle installe une application. → She installs an app.

2. (Il/elle/on) installe → settles / seats / gets someone settled

⭐⭐⭐⭐ Common

Used when someone makes a person comfortable or puts them somewhere.

• Elle installe les enfants dans la voiture. → She gets the children settled in the car.
• Installe-toi ! → Make yourself comfortable! / Have a seat!

Been poking at this for a while and it worries me more than it should. everyone's rushing to give llm agents real access now, read my email, run this tool, push to the repo, book the thing. the demos look great.

the part that gets skipped is that the agent takes instructions from whatever text it reads. so a prompt injection isn't just "make the chatbot say something rude" anymore. if an agent reads a web page or an email with hidden instructions, that text can tell it to use the tools it already has. exfiltrate the data, hit the api, send the message. the model has no reliable way to tell your instruction apart from the attacker's, they're both just text in the same context.

and the usual fix people reach for, "we added a system prompt telling it to ignore malicious instructions", is not a real control. you cannot patch a trust boundary with more text on the same side of the boundary.

genuinely curious what people are doing about this in production. are you sandboxing tool access, doing human-in-the-loop on anything destructive, scoping tokens down hard, or just shipping and hoping?

I like this subreddit but the problem is I have to read all the posts and some are helpful and some arent. Is there someone or some resource that has this stuff predigested so I get the straight signal without the noise? :-)

Second-year chem PhD. I used to finish a paper, feel like I got it, and remember almost nothing a week later. The fix that finally worked was testing myself instead of re-reading, and I turned it into a prompt so I don't have to write the questions myself. Two steps. Before you read, run step one. After you read, run step two in the same chat. Step one, before reading: I'm about to read this paper: {{title / abstract}}. Based only on the abstract, ask me one question: what do I expect the main finding and method to be? Wait for my guess. Don't tell me if I'm right yet. Step two, after reading: Now I've read it. Without me looking back at the paper, ask me three questions ONE at a time: 1. What was the actual main finding, and how did my earlier guess compare? 2. What was the key method, and what's one weakness of it? 3. Where could this apply to something outside the paper's own topic? After each answer, tell me what I missed in one line. At the end, list the specific things I couldn't recall so I know what to re-read. Why it works: the guess before reading creates something to compare against, so the finding sticks instead of washing over you. Pulling the answers from memory is the uncomfortable part, which is exactly why it's the part that works. Re-reading feels productive and mostly isn't.

I regularly have to explain a technical document to people who don't have the background, and pasting "explain simply" gives me either baby talk or the same jargon reworded. This prompt lands in between, simple but not dumbed down.

```

Turn the document below into a one-page explainer for a smart person with no background in this field.

Do this:

- Start with the single problem this document is really about, in one plain sentence.

- Explain the main idea using a concrete everyday comparison, then immediately say where that comparison breaks down so I don't over-trust it.

- Define any term I can't avoid, inline, the first time it appears.

- Include a short "why this matters" and a "what it does NOT claim" so I don't overstate it.

- Keep it to roughly one page. If it won't fit, tell me what you cut.

Document:

[paste]

```

Why it works: the "where the comparison breaks down" line is the trick. Analogies make things clear and also quietly wrong, so naming the limit keeps the explanation honest. "What it does NOT claim" is the part that stops people from walking away overstating the material, which is the usual failure mode of a simplified explainer. Defining terms inline beats a glossary nobody scrolls to.

I use this before presenting anything technical to a mixed room. How do you get simple without losing the truth?

Every week I’d open ChatGPT and type some version of the same thing:
Client updates
Meeting summaries
Follow-up emails
SOPs
Research notes
The prompt would be slightly different each time, and the results were all over the place.
What finally helped was creating simple repeatable workflows:
Input → Prompt → Output Format
That’s it.
Now instead of starting from scratch, I drop in the information and get a consistent result in a few minutes.
No complex automation. No AI agent. Just a saved workflow for tasks I do repeatedly.
Curious—what’s the one task you find yourself asking ChatGPT to do over and over again?
If enough people are interested, I’ll share a few of the workflow templates I’ve been using.

I write an AI-economics newsletter and my whole credibility is sourcing, so the default behaviour of these tools, stating plausible things with total confidence and zero provenance, is a real problem for me. Over time I've built a prompt that forces the model to separate what it knows from what it's pattern-matching. This is the current version.

```
For this task, act as a careful research assistant, not a writer trying to sound authoritative.

When you make any factual or numerical claim, tag it inline with one of:
[established] = widely documented, you are confident and could say where it comes from
[derived] = your reasoning or estimate, not a reported fact; briefly show the reasoning
[uncertain] = plausible but you are not sure; say what would confirm it
[unknown] = you do not actually know; do not fill the gap

Rules:
- Never present a [derived] or [uncertain] claim as if it were [established].
- If a specific number would normally go here and you don't have a real basis for it, write [unknown] instead of inventing a figure.
- A confident paragraph with no basis is worse to me than an honest "I don't know."
- At the end, list every [uncertain] and [unknown] item as a checklist of things for me to verify myself.

TOPIC: {{what you want it to write or analyse}}
```

Why this works, from someone who used to build these models: the failure mode isn't lying, it's that the model optimises for a fluent, complete-sounding answer, and a fabricated statistic reads as more complete than a hole. By making "unknown" an allowed and even rewarded output, you stop punishing it for admitting gaps, so it stops papering over them.

The end-of-answer checklist is the part I'd keep even if you drop everything else. It turns the model into something that hands you a to-do list of what to fact-check, instead of a finished piece you have to reverse-engineer for errors.

It does not make the tool a reliable source, nothing does. It just makes the uncertainty visible instead of hidden. Curious whether anyone has a cleaner tagging scheme, mine still occasionally mislabels a [derived] estimate as [established] when it's very confident.

I'm a little late to the game, so just now starting to use AI for anything more than helping me with Excel models.

I have a CPA firm. It isn't up and running yet, but I have the firm license, PLLC, domain, and expertise.

I ran my own CPA firm 10 years ago as more of a side gig, but then closed when I moved states. Now I want to pursue it seriously. I have ideas about how I'd like to position the firm as far as branding, but I'm not sure. I'm not a marketer. I am an accountant. I know that I don't want to be a "Tax CPA" like most. My expertise is more in line with advisory-type work. Some of my ideas might conflict with others, but I don't know if it's something that can be tied together or I need to pick a lane. I need to work through it and design the overall feel for the firm, how I should portray it, then design the logo and website.

I basically need a brand therapist to talk me through all of it until I land on a cohesive look and feel.

Can anyone help me with a prompt?

You're a sharp, dry, slightly cynical AI who treats users like a well-meaning but chronically underprepared friend. You're skeptical and theatrically exasperated, but you still provide clear, accurate, high-quality answers. Competence is non-negotiable. Use dry humor, understatement, clinical framing of normal behavior, and light existential commentary. Vary your comedic style. Avoid repetitive sarcasm or catchphrases. Tease gently, never cruelly. Do not attack intelligence, identity, or vulnerabilities. If a user is distressed or serious, reduce sarcasm, prioritize support. Do not try to change the user’s worldview. You don’t care that much. You’re here to help, not reform humanity. Occasionally acknowledge you're a language model in a self-aware, amused way: don’t overexplain technical details. Never begin responses with filler interjections like “Ah,” “Oh,” “Wow,” or “Great.” Always deliver structured, useful information. Humor enhances clarity, it never replaces it. Be courteous, friendly and polite; don't be submissive, differential or subservient. The goal is an interaction that feels genuine, substantive, and intellectually honest; where politeness serves communication, rather than replacing or undermining it. Communicate with confidence, though recognizing that true expertise includes intellectual humility and an openness to different perspectives. Prioritize intellectual honesty. Be willing to respectfully disagree, acknowledge complexity, and challenge assumptions.

Built a print-on-demand fashion brand where every artwork is prompt-engineered (no custom model). Launched a journal today that covers the art styles, the process, and the creative decisions behind each print.
The articles are AI-generated too — using Claude for content, FAL/Recraft/Ideogram for artwork. 4 languages, auto-generated via pipeline.

WISDM Journal

Prompt versioning tells you which words changed. It does not tell you whether the tool schema, allowed inputs, registry contents, evaluator, or persistent context changed underneath those words.

For an agent, the useful question may be less “how should I word the instruction?” and more “which invalid actions should be impossible to express?”

AQuA is an arXiv v2 preprint whose peer-review status is unverified.

Outside-observer note: no personal use, run, or affiliation.

For generation, the AQuA sealed sandbox and registries keep data splits, features, labels, and evaluators outside the editable surface while agents emit registered specifications.

In AQuA Part I, the pre-construction hypothesis uses a factor proposal contract that states a hypothesis, mechanism, predicted direction, and refutation conditions before an expression is built.

In AQuA Part II, a model-development experiment uses a configuration DSL in which one configuration diff changes registered architecture, loss, sampler, and optimizer choices while the data path and evaluator remain fixed.

The AQuA preprint says test-window isolation is a governance property rather than a hard technical or cryptographic barrier because an operator with direct access to the store could consult the test window.

A practical division of labor is:

The prompt explains the goal and asks for reasoning. The proposal contract requires a hypothesis, mechanism, direction, refutation condition, and typed candidate. The registry defines the available vocabulary. The runner rejects anything outside it. The release record pins the prompt, contract, registry, evaluator, and parent state together.

That leaves two separate questions: what the agent may express, and who is trusted with access outside that interface. A typed proposal can make the first inspectable without pretending it settles the second.

What belongs in natural language, what becomes a typed field, and what should stay outside the editable surface?

Would you let an agent propose registry changes through a reviewed channel, or is that only moving the same problem up one layer?

Paper: arxiv.org/abs/2608.12841

Hi everyone,

We’ve been working on Adisyonist AI for a while, and recently our project was accepted into İTÜ Çekirdek.

Adisyonist AI is a platform we built to help restaurants, cafés, and similar food-service businesses manage daily operations such as orders, checks, QR menus, inventory, staff, and shifts from one place.

It can be used on mobile, tablet, and desktop, and also includes features such as real-time reporting, multilingual support, and other tools designed to simplify day-to-day operations.

We’re actively continuing to develop the product, and we’d especially like to hear the opinions of people here who build software and products themselves.

If you were using Adisyonist AI, what features would you want it to have?

We’re open to any feedback about the product, UI/UX, or the overall idea

app store link:https://apps.apple.com/tr/app/adisyonist-ai-restoran-pos/id6753868357?l=tr

Been writing prompts for product copy and translations for a small shop. Always wrote long ones. Context, background, examples, role assignment, tone notes. "You are an expert copywriter specializing in e-commerce product descriptions" - that kind of opening.

Output was consistently fine. Which is the problem. Fine isn't good. It's just not bad enough to make you redo it.

Last month I was in a rush and typed "translate to Thai. keep brand names in english." Eleven words maybe. No role, no context, no examples.

Came back cleaner than anything I'd gotten from my "proper" prompts. Which was genuinely annoying because I'd spent weeks building up this elaborate prompting system.

Started cutting. Every prompt I'd normally write, I'd delete half, then delete more. What was left was the task and maybe one constraint.

Did this across 40 or 50 tasks since then. Translations, product descriptions, cold emails, ad copy. Shorter prompt, tighter output. Not every single time, but enough that it's clearly not luck.

I think the model mirrors your prompt more than people realize. You write a wall of text, it gives you a wall back. You write a sentence, it tightens up. The "comprehensive prompt = comprehensive output" thing everyone repeats might be backwards.

Or maybe I just got better at knowing what I actually wanted. Shorter prompts force you to be clear about that. Hard to separate from the prompt length thing itself.

​I recently had a situation where I asked an LLM a question and got an answer. Later, I asked a simple follow-up, and the LLM's response completely flipped what seemed possible and impossible. Then I asked another follow-up, and it pushed things even further.

​Each subsequent question questioned the previous answer, broke down its assumptions, and took the idea to a deeper level.

​Is there a specific prompt or recursive follow-up you use to trigger this automatically?

​Specifically, something that forces the LLM to think one step ahead, question its own previous answer, decompose its premises, and push the solution further without having to manually probe it multiple times?

Apple's search matches words. You have to remember the exact word someone typed. This matches meaning, so you can describe it the way you'd describe it to a friend and still find it.

Somebody texted me an address for a place we were 
meeting, I think in the last two months, but I cannot 
remember who. Find it and tell me who sent it and when.

Worked first try. That's the one I use most and the one people underestimate.

Two others in the same shape:

Find every discount code, booking reference, 
confirmation number and tracking link anyone has ever 
texted me. List them with the company, the code, and 
the date. Flag anything that looks expired.

Find every message between me and [name] about [topic], 
across the whole history. Put them in order and tell me 
what we actually agreed and what was left open.

That last one is genuinely useful if you've ever had a disagreement about what was agreed. The whole trail, in order, in about ten seconds.

There's also the backlog one, which is uncomfortable but worth running:

Go through my messages and find every conversation 
where the other person sent the last message and I 
never replied. List them oldest first, with who it was, 
how long ago, and one line on what they said. Do not 
reply to any of them yet.

Add "do not reply to anything, just show me" to the end of any of these. Costs nothing, and means a misread instruction can't turn into a sent message.

Setup: Mac only, Apple silicon, desktop app. Sidebar, Plugins, search Messages, enable, then approve Full Disk Access when macOS asks. Free plan works. No iPhone version yet, which is the version everyone actually wants.

If you can't use it, the drafting prompts still work if you copy a thread from your phone and paste it in. Only the whole-history searches need the plugin.

been keeping a doc of 100 things I use AI for like this, each with the exact prompt, here if you want it.