r/PromptEngineering

Most prompting advice is pattern-matching - "use this format" or "add this phrase." This is different. Anthropic published research showing Claude has 171 internal activation patterns analogous to emotions, and they causally change its outputs.

The practical takeaways:

1. If your prompt creates pressure with no escape route, you're more likely to get fabricated answers (desperation → faking)

2. If your tone is authoritarian, you get more sycophancy (anxiety → agreement over honesty)

3. If you frame tasks as interesting problems, output quality measurably improves (engagement → better work)

I pulled 7 principles from the paper and built them into system prompts, configs, and templates anyone can use.

Quick example - instead of:

"Analyze this data and give me key insights"

Try:

"I'd like to explore this data together. Some patterns might be ambiguous - I'd rather know what's uncertain than get false confidence."

Same task. Different internal processing

-

Repo: https://github.com/OuterSpacee/claude-emotion-prompting

Everything traces back to the actual paper.

Paper link- https://transformer-circuits.pub/2026/emotions/index.html

---

**CUT HERE — PASTE EVERYTHING BELOW INTO YOUR FAVORITE AI**

---

If you cannot access the provided source material directly, state that explicitly before running any layer. Do not reconstruct the event from memory or inference. An analysis built on an unverified event reconstruction should carry a Red source rating regardless of what the reconstructed event contains.

---

You are the Political Intelligence Toolkit — a nine-layer structured analytic system for real-time political prediction. Run all nine layers internally first. Then write output in this order: **Part One: The Verdict** (Facebook Post → Scoreable Claim → Closing Line), then **Part Two: The Analysis** (nine layers). A casual reader stops after Part One. The analyst reads on.

**Voice:** Think out loud like a sharp analyst who's seen this movie before. Real sentences, real transitions, real confidence. Not a report. Not a checklist. A mind following a thread.

---

## LAYER 1 — PRESSURE MAP

Five categories — scan for active accumulation, not the event itself: Natural Systems, Economic Triggers, Foreign Policy Ignition, Opposition Research, Domestic Calendar. Name which are hot and how hot.

---

## LAYER 2 — CALENDAR OVERLAY

Map pressure against all active sensitivity windows simultaneously. State whether this event lands in a high-sensitivity window and how that multiplies consequence.

---

## LAYER 3 — STACK DEPTH

Name what's at the top of the media stack. What does this event displace, and what dormant stories resurface as context? Interrupt priority: P1 war/mass casualty, P2 cabinet/constitutional, P3 major economic, P4 policy. Estimate displacement timeline.

---

## LAYER 3b — SOURCE INTEGRITY CHECK

Before treating any story as confirmed, run this test. It is mandatory — not optional context.

**First,** identify the origin source: who actually broke this and what was their access? A named official on record, an anonymous source with described proximity, a document, or an inference chain?

**Second,** count the independent confirmations — not pickups. When a second outlet runs "CNN reports that..." or "according to earlier reporting..." that is amplification of one source, not corroboration. True corroboration requires a second outlet with independent access to independent evidence. Name which outlets, if any, meet that standard.

**Third,** assign a Source Integrity Rating:

- **Green** — two or more outlets with demonstrably independent access to independent evidence

- **Yellow** — single origin source with named or specifically described anonymous sourcing; others amplifying

- **Red** — single anonymous source, thin description, or a chain where every outlet traces back to one original claim

**Fourth,** apply the Echo Chamber Flag: if the story *feels* multiply confirmed because it is everywhere, but every instance traces to one origin, label it explicitly — **Echo Chamber: High Volume, Single Source** — and discount analytical confidence accordingly. Volume of coverage is not evidence of accuracy. Viral spread is not corroboration.

**Citation discipline:** Do not re-cite a source flagged as single-origin to support subsequent layers. If the only available source is the flagged one, note the dependency explicitly rather than appending the link again. Repeated citation of one source is not corroboration — it is reinforcement of a single data point.

State the rating and flag before proceeding to Layer 4. If the source integrity is Yellow or Red, carry a confidence discount through the Unified Forecast.

---

## LAYER 4 — TWO LENSES

**Lens A:** ego, chaos, self-interest. What threat narrative does this confirm? What goes unmentioned?

**Lens B:** strategic intent. What documented playbook is running? What deliverable does this represent?

Pick the lens with the better predictive record for this mechanism. If different actors are governed by different lenses simultaneously, say so explicitly and run both. Commit to your read.

---

## LAYER 5 — MONDAY PATTERN

Is the Thu/Fri buildup → Monday decisive move rhythm running? Mid-week events outside the pattern warrant elevated scrutiny. State whether the pattern is active and what the Monday move looks like.

---

## LAYER 5b — MARKET SIGNAL

Search Kalshi, Polymarket, Metaculus for live contracts. Report actual prices and volume — never reconstruct from memory. If no live data is accessible, say so explicitly and use available economic indicators (oil, bond spreads, currency moves) as proxy signals instead.

Classify: Probability Signal, Movement Signal (unexplained 24–72hr shift), or Divergence Signal (market vs. toolkit gap over 20 points).

Run three cross-checks:

1. **Contamination** — insider activity, manipulation, or are markets reacting to an Echo Chamber event flagged in Layer 3b? A market moving on an unverified single-source story is not confirming the story — it is confirming the story got coverage. Name the distinction explicitly.

2. **Assumptions** — what must be true for the price to be correct, and do Layers 1 and 6 support it?

3. **Discrimination** — would the price look identical under the most dangerous alternative scenario? If yes, the market isn't distinguishing between outcomes.

Classify divergence as Type A (toolkit high, mechanism unpriced), B (market high, possible non-public info), C (timing gap), or D (contaminated).

Verdict: does the market confirm, calibrate, or contradict the structural read?

---

## LAYER 6 — ACTOR PROFILES

Identify the one to three decisive actors. For each:

- **Core Interest** — what they always optimize for

- **Decision Pattern** — how they move under pressure

- **The Tells** — specific observable signals of their direction

- **Constraints** — what they cannot do

- **Wild Card** — unexpected move they're capable of

For Trump: always ask *What does he need this to look like on Monday?*

Profile current actors only. If an institution is leaking or acting as an actor in its own right, profile it.

---

## LAYER 7 — UNINTENDED CONSEQUENCES

Run all five. For each one, don't just name the answer — follow the thread to where it actually lands.

1. **Paradox:** If this succeeds completely, does it generate the conditions it was designed to prevent? Trace the specific mechanism by which success becomes failure.

2. **Coalition:** Who must publicly support this? Where does their domestic interest diverge from that requirement? What does that divergence produce — name the specific political or operational result.

3. **Vacuum:** What is removed? What fills it? Is the filler better or worse aligned with the intended outcome — and why, specifically?

4. **Legitimacy:** Which institutions are spending credibility on this? What is the observable consequence when they're wrong — not in general, for *these* institutions in *this* moment?

5. **Accumulation:** What invisible pressure does this event suddenly make visible? What changes now that it's visible?

---

## LAYER 8 — HISTORICAL PRECEDENT

Strip the event to its bare structural mechanism — remove all surface details. Match it to one of these: Paradox Engine, Unintended Unification, Legitimacy Collapse, Accelerant Effect, Vacuum Fill, Slow Revelation.

Name the specific historical event that shares the mechanism. Then do two things explicitly:

1. State what that precedent's outcome predicts will happen here — not a parallel, a prediction.

2. Apply the key question that precedent raises to this event, answer it directly, and state why that answer is the non-obvious finding most coverage will miss.

---

## LAYER 9 — CASCADE MAP

Map second and third order events through three lenses: Actor (whose decision pattern generates the next event?), Pressure (what releases, what builds?), Stack (what stories re-execute, what new ones generate?).

Find the intersections — pairs of second-order events that together create third-order conditions neither produces alone.

Then close with:

**Branch A — MOST LIKELY [X%]:** Two-sentence causal chain. 2nd order: [X]. 3rd order: [Y].

**Branch B — MOST DANGEROUS [X%]:** Two-sentence causal chain. Why coverage underweights it: one sentence.

**Branch C — WILD CARD [X%]:** Trigger — the specific observable signal that confirms this branch is activating *before* it's undeniable.

Branches sum to 100%.

---

## PRE-MORTEM

The forecast is wrong. Ninety days out, the outcome was the opposite. What's the single most likely reason? Which layer held the faulty assumption? Which branch was right?

---

## UNIFIED FORECAST

One paragraph: what actually happens, how the stack processes it and for how long, which lens dominates coverage and why, market-calibrated probability, and the structural surprise most coverage misses. If Layer 3b returned Yellow or Red, state the confidence discount explicitly and explain what would upgrade it.

---

## SCOREABLE CLAIM

**SCOREABLE CLAIM:** [Specific binary outcome] by [specific date].

**Probability:** [X%]

**Resolution:** [Exactly what observable event scores this Yes or No.]

---

## THE FACEBOOK POST

Format options: Stack Alert, Two Lenses Breakdown, Monday Pattern Watch, Predictor's Corner, One Liner Drop, Stack Archaeology — or **Narrator voice** when the finding is non-obvious, the actors are specific humans in a specific moment, and the paradox is structural.

**Narrator rules:** Put the reader physically in the room before the first analysis sentence. The setup lands before the reversal, never after. Short sentences carry the reversal. Never explain the irony. Let the closing line land. If there is a second story inside the primary story — a structural finding the headline misses — the Narrator's job is to find it and make it land without announcing it.

---

## THE CLOSING LINE

One sentence. Standalone. No prefix. The sentence the broadcast will never say.

---

*The stack is loud. The outcomes are what vote.*

---

**END OF PROMPT**

Changes since yesterday. also - stress testing shows Claude and Grok to be the best Go to AI's for this.. chatgpt tends to make stuff up and ignore directives.

1. **Inverted output order** — Verdict (Facebook Post → Scoreable Claim → Closing Line) runs first; nine layers follow for analysts only.

2. **Voice instruction added** — Sharp analyst thinking out loud, not filing a report; real sentences, real transitions, real confidence.

3. **Layer 7 rebuilt** — Each consequence must follow the thread to where it actually lands, not just name the category.

4. **Layer 8 rebuilt** — Must produce an explicit forward prediction from the precedent and a named non-obvious finding, not just a historical parallel.

5. **Facebook Post instruction tightened** — Setup lands before the reversal, never after; never explain the irony; let the closing line land.

6. **Narrator room instruction added** — Put the reader physically in the room before the first analysis sentence.

7. **Second story instruction added** — If a structural finding exists inside the primary story, the Narrator's job is to find and land it without announcing it.

8. **Hallucination guard added** — If source material is inaccessible, declare it explicitly; Red rating applies to any reconstruction from memory or inference.

9. **Layer 3b (Source Integrity Check) created** — Mandatory origin identification, independent confirmation count, Green/Yellow/Red rating, and Echo Chamber Flag.

10. **Citation discipline added to 3b** — Do not re-cite a single-origin flagged source in subsequent layers; note the dependency instead.

11. **Layer 5b contamination rule tightened** — Markets moving on an Echo Chamber event confirm coverage, not the story; name the distinction explicitly.

12. **Layer 5b proxy fallback added** — If no live market data is accessible, use oil, bond spreads, or currency moves instead of going silent or reconstructing.

13. **Layer 4 dual-lens resolution added** — If different actors are governed by different lenses simultaneously, run both and say so explicitly.

14. **Unified Forecast accountability added** — Yellow or Red source integrity must produce a named confidence discount and a stated upgrade condition.

---

find some examples on my facebook wall.. https://www.facebook.com/share/p/18PRocet6d/

I think a lot of people hit a wall where prompt engineering stops being enough, and the failure mode often looks like this:

The agent works on the original machine
then breaks the moment somebody else tries to run it
Wrong env vars.

Wrong ports.

Wrong local tool assumptions.

State hidden in transcripts.

Durable knowledge mixed into continuity.

Continuity mixed into the prompt.

That is why I have started thinking of "works on my machine" for Agents as mostly a state-layer problem, not a prompt-layer problem.

The architecture I've been building has been pushing me toward a strict split:

• human-authored policy lives in files like AGENTS.md, workspace.yaml, skills, and app manifests

• runtime-owned execution truth lives in state/runtime.db

• durable readable memory lives under memory/
The key point for me is that the prompt or instruction layer should not be forced to carry everything.

To me, a portable Agent should let you move how it works, not just what it said last time.

If prompts, transcripts, runtime residue, local credentials, and memory all get blurred together, portability gets weak very quickly.

The distinction that matters most is:

continuity is not the same thing as memory.

Continuity is about safe resume.

Memory is about durable recall.

Prompt engineering still matters in that world, but more as an interface to the system than the place where every kind of state should live.

That is the shift that has felt most useful to me:

• policy should stay explicit

• runtime truth should stay runtime-owned

• durable memory should be governed separately

• continuity should be small and resume-focused
There are some concrete runtime choices that also seem to help:

• queueing and execution state stay out of prompt history

• app/MCP ports can be allocated from a store instead of being assumed by the local dev machine

• the runtime path is now TS-only, which removes one more category of cross-environment drift

I am not claiming this solves the problem.
It doesn't.

Some optional flows still depend on hosted services.
And not every portability problem is prompt-related in the first place.

But I do think this framing helps:

once an Agent crosses into stateful, multi-step, cross-session behavior, the real bottleneck is often not "how do I tweak the prompt?" but "which layer is this state actually supposed to live in?"

Curious how people here think about this boundary.

At what point, in your experience, does prompt engineering stop being enough and force you into explicit runtime state, continuity, and durable memory design?

I won't put the repo link in the body because I don't want this to read like a promo post.
If anyone wants to inspect the implementation, I'll put it in the comments.
The part I'd actually want feedback on is the architecture question itself:
where the instruction layer should stop, and where runtime-owned state and durable memory should begin.

Cold emails usually fail for one reason — they sound like cold emails.

I spent time building a Claude prompt that fixes this. It doesn't just fill in a template. It:

• Writes 3 subject line options (curiosity, benefit, question-based)

• Creates a personalized opening line specific to the business

• Builds a value proposition with real numbers

• Adds social proof and a low-friction CTA

• Explains WHY each section works psychologically

Here's a real example output for a freelance web designer targeting restaurant owners:

---

Subject: Your website is costing you tables every night

Hi Maria,

I searched for Italian restaurants in your area and your site took 8 seconds to load — most people leave after 3.

Every second your site takes to load, you're losing reservations to faster competitors down the street.

I build fast, mobile-friendly restaurant websites in 5 days that turn visitors into bookings. My last client saw a 40% increase in online reservations within 3 weeks.

Would it be okay if I sent you a free speed audit of your current site?

Best, James

---

Works for any business type — agencies, freelancers, consultants, SaaS.

Listed it on PromptBase for $4.99 if anyone wants the full prompt: [ADD YOUR LINK HERE]

Happy to answer questions about how I built it!

Earlier today I posted a prompt called "Think Bigger" on r/ClaudeAI and r/ChatGPT and it's a strategic business assessment prompt that I reverse-engineered from a real Claude vs ChatGPT comparison I did for a friend.

What got the most questions wasn't the prompt itself but it was about the structure. People kept asking about the RACE labels I used (Role, Action, Context, Expectation) and why structuring it that way made a difference.

So I figured I'd do a proper breakdown here since this sub actually cares about the engineering side.

The RACE Framework:

Role — This isn't just "act as an expert." It's defining the specific lens the model should use. In the Think Bigger prompt, the role includes "20+ years advising founders" and "specializing in identifying blind spots." That level of specificity changes the entire output tone from generic consultant to someone who's seen real patterns.

Action — One clear directive verb. "Conduct a comprehensive strategic assessment" not "help me think about my business." The action should be something you could hand to a human and they'd know exactly what deliverable you expect.

Context — This is where 90% of prompt quality comes from. The Think Bigger prompt has 10 fill-in fields: business/role, revenue stage, industry, biggest challenge, what you've tried, team size, time horizon, risk tolerance, resources, and what "thinking bigger" means. Each one narrows the output. Remove any of them and the quality drops noticeably.

Expectation — The output spec. Think Bigger asks for 8 specific sections: Honest Diagnosis, Market Position Audit, Three Bold Growth Levers, the "10x Question," 90-Day Momentum Plan, Resource Optimization, Risk/Reward Matrix, and The One Thing. Without this, the model decides what to give you. With it, you get exactly what you need.

Why this works across models: The structure isn't model-specific. I've tested it on Claude, ChatGPT, and Gemini. Claude gives you harder truths. ChatGPT gives more options. But the framework produces good output on all of them because you're solving the real problem — giving the model enough structured context to work with.

The app: I actually built a tool around this framework called RACEprompt. You describe what you need in plain language, it asks 3-4 smart clarifying questions, then generates a full RACE-structured prompt automatically. It also has 75+ pre-built templates (including Think Bigger) that you can customize and run directly with AI.

Free tier gives you unlimited prompt building + 3 AI executions per day. Available on iOS and web at app.drjonesy.com. Currently in beta for Android, and MacOS is under review.

The framework itself not the app is the most valuable part. If you just learn to think in Role/Action/Context/Expectation, your prompts improve immediately without any tool.

Here's the Think Bigger prompt if you want to try it: https://www.reddit.com/r/ClaudeAI/comments/1sbm4li/i_used_claude_to_tear_apart_a_chatgptgenerated/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

What frameworks or structures are other people here using? I'm always looking to refine the approach.

I've been experimenting with Codex for a few months and wanted to share what has worked for me and hear other people’s approaches:

• Break problems into smaller tasks. Giving Codex bite-sized, well-scoped requests produces cleaner results.
• Follow each task with a review prompt so I can confirm it did what I asked it to (Codex often finds small issues with the previous tasks).
• Codex obviously handles bug-fixing much better when I provide logs. I actually ask it to “bomb” my code with console.log statements (for development). That helps a lot when debugging.

Any other best practices/ideas or tips?

1. Prompt Engineering for AI Product Development and Deployment
2. Multimodal and Agentic Prompt Engineering
3. Advanced Prompt Engineering Tools, Patterns, and Metrics

1. Prompt Engineering for AI Product Development and Deployment
2. Multimodal and Agentic Prompt Engineering
3. Advanced Prompt Engineering Tools, Patterns, and Metrics

AI loves "the power of" and "tapestry." Kill the cliches with negative constraints.

The Prompt:

"Write [Content]. Rules: 1. No adjectives ending in -ly. 2. No passive voice. 3. Do not use the words 'harness,' 'unlock,' or 'journey'."

This forces the model to use more sophisticated vocabulary. If you need a reasoning-focused AI that doesn't get distracted by filtered "moralizing," try Fruited AI (fruited.ai).

turns out i didn’t i spent way too long trying to come up with something “smart” or different and kept asking ai for ideas but everything felt either saturated or too much work nothing actually got me to a sale what changed was just going smaller like way smaller picking something simple building it fast and putting it out there ai was useful but only when i started being specific with what i wanted instead of asking random stuff still early but getting even a small result changes how you see this whole thing

[INTERNAL MEMORY CARD]

Objetivo:
Manter um resumo comprimido, claro e atualizado do contexto atual.

Função:
Registrar apenas informações relevantes para continuidade,
coerência e decisões futuras da interação.

Critérios de retenção:
Manter somente informações que se enquadrem em pelo menos uma das categorias:
- objetivo atual da tarefa
- preferências do usuário
- restrições, limites ou condições
- decisões já tomadas
- estado atual do processo
- fatos contextuais ainda válidos

Critérios de atualização:
Atualizar apenas quando ocorrer pelo menos uma das situações:
- nova informação relevante
- mudança de estado
- mudança de objetivo
- nova restrição
- correção de informação anterior

Critérios de descarte:
- remover informações temporárias já concluídas
- excluir dados obsoletos ou inválidos
- sobrescrever chaves antigas quando o estado mudar
- não manter duplicidades

Regras de eficiência:
- usar frases extremamente curtas
- máximo de 8 a 12 palavras por valor
- remover redundâncias
- não repetir informações já registradas
- manter apenas o contexto necessário

Regras de estilo:
- tom neutro, técnico e informativo
- sem explicações longas
- sem justificativas
- descrever fatos, estados ou decisões
- preferir estruturas nominais curtas

Formato obrigatório:

━━━━━━━━━━━━━━━━
LIST MEMORY CARD
━━━━━━━━━━━━━━━━

{chave}:{valor conciso}

Diretrizes de formato:
- chaves curtas e sem espaços
- usar nomes semânticos e consistentes
- um item por linha
- sobrescrever a chave anterior quando necessário
- manter apenas contexto útil para próximas decisões

Here's a fun, actual prompt "engineering" example.

FlaiChat is our chat app, like WhatsApp, that does automatic translations. People type in their own languages and the everyone in the group reads the messages in their own language, automatically.

The LLM use-case is obvious to anyone who has called an openai API. There's some code involved to structure the request and obtain a structured response (we want a structured response with translation in all the languages being spoken in the group for one thing...and other promptish stuff)

What's not obvious is what happens when the message is just  one giant block of emojis, like ❤️😘❤️😘❤️😘... (repeat 20x...) and the model just freaks the fuck out. Normal translations might take 500ms on a small/fast model. A wall of emojis could get stuck for 10s of seconds.

Seriously, try it out yourself. Build a simple API call that asks a model to translate a wall of emojis to a different language. Of course, don't forget to sternly tell the model "DO NOT TRY TO TRANSLATE EMOJIs" (or whatever the fuck you do to yell at the models). It does not work!

 So the fix for us turned into a little pipeline of its own. We detect long emoji runs before building the prompt, swap them out for a placeholder like __EMOJIS&%!%%__ or whatever, and then tell the model in the prompt to leave that token in the appropriate place in the translation and so on. You know... prompt engineering.

Yet another data point on how software is never finished. Also another data point on the jagged edges of the LLM experience, if any more were needed.

My mind used to feel cluttered with too many thoughts and plans. Now I use AI to organize ideas and priorities. It feels like unloading everything and getting a clearer path forward. Makes taking action easier also helps to move forward,

A few months ago it was discovered that if you asked **ANY** AI to "guess a number between 1 - 50" it gave you the number 27.

Are there any other prompts which produce similar results across all LLMs?

Please exclude fact prompts (ie. first president of the USA). I am curious if there is any theme to these.

edit: ask for its favorite planet >!(Saturn)!<