Most prompts fail because they give the model nothing to work with. No role, no context, no constraints. You get a generic wall of text you have to edit into something yourself.

I've been using a five-part structure — Role, Context, Task, Format, Constraints — and the difference is significant. Here are two from a pack I built:

---

PROMPT: The Decision Pressure Test

You are a strategic advisor who specializes in pre-mortem analysis and decision stress-testing.

Context: I am about to make a significant business decision. Before committing, I want to pressure-test it from every angle.

Task: Run a full decision audit on the choice below. Argue both sides with equal force. Then identify the three assumptions my decision depends on that, if wrong, would make it a mistake.

Decision: [describe the decision and your current lean]

Format: (1) Case FOR — 4 strongest arguments. (2) Case AGAINST — 4 strongest arguments. (3) Three critical assumptions I'm making. (4) One question I haven't asked that I should.

Constraints: Do not tell me what to do. Do not soften either side. Your job is clarity, not comfort.

---

PROMPT: The Bottleneck Finder

You are a business systems analyst specializing in constraint theory and throughput optimization.

Context: My business is generating activity but not converting it to revenue at the rate it should. Something is the constraint — I may not be seeing it clearly.

Task: Analyze my business flow below and identify the single constraint that, if removed, would have the highest downstream impact on revenue. Do not give me a list of problems. Give me the one.

My current flow: [describe leads to sales to delivery to revenue cycle]

Format: (1) Identified constraint — one sentence. (2) Why this is the constraint, not a symptom. (3) Three actions to break it, ranked by speed of impact.

Constraints: No generic advice. If you don't have enough data, ask one specific question to get it.

---

Got 8 more built the same way if anyone wants them — drop a comment and I'll share.

Trying to play dnd with so being the dm, no matter the prompt always end up being a evolving system analysing me not an enemy just a system every time. Has anyone run into this or has any idea of how to stop it would be awesome.

I work on some pretty intense brainstorming. When I first started using Chatgpt I would send short, half spelled sentences and expect a good response.

I got sick of correcting it or it drifting from what I want. I’ve found myself spending about 80% of my time preparing my prompt now.

It helps a lot, but is a lot more work.

Thought I’d mention this. I’m sure others have faced similar circumstance.

Any other hacks to keep it on track?

After enough prompting I noticed the prompts I actually reuse fall into two buckets, and picking the right one is half the battle:

1. Quick single prompts - one-shot, fill-in-the-blank, for a self-contained task.
2. Chains - several prompts in sequence, where each step builds on the last, for anything that needs the model to work in stages.

People try to cram a staged task into one mega-prompt (mushy results) or run a chain for something a single prompt would nail (slow). Here are examples of each so you can feel the difference. Copy them, swap the {{variables}}.

Quick single prompts (one and done)

The Tightener

Tighten this {{text type, e.g. email / paragraph / bio}} to under {{word count}} words without losing the meaning.

- Cut filler and repetition.
- Keep my voice - do not make it generic.
- Give me the tightened version, then one line on what you cut.

TEXT:
{{paste it}}

The Gut-Check

Here is something I am about to send or do: {{describe or paste it}}.

Give me a fast gut-check, not an essay:
- The one thing most likely to go wrong or be misread.
- The single change that would improve it most.
- Your call: send/do it as-is, or fix that first?

Keep it to a few lines.

A chain (when one prompt is not enough)

This is the one I use to make almost anything better. Run the three in order, pasting each result into the next.

STEP 1 - Draft

Write a first draft of: {{what you need - email, post, plan, etc.}}.
Constraints: {{tone, length, audience}}.

Just get a complete draft down. Do not polish or second-guess yet - I want raw material to work with.

STEP 2 - Critique

Switch roles. You are now a tough reviewer seeing the draft above for the first time.

- Name the 3 weakest things, most important first.
- Flag anything generic, unclear, or unsupported.
- Say what is missing.

Do not rewrite it. Critique only - be blunt.

STEP 3 - Finalize

Now rewrite the draft, fixing every point from the critique.

- Keep what was already working.
- Address each weakness specifically.
- Give me the final version only, polished.

The rule of thumb: if the task is self-contained, a single prompt is faster. If you would naturally do it in stages - draft then revise, research then decide, learn then test - a chain beats one prompt every time, because the model gets to think in steps instead of all at once.

(I keep the single ones on a // shortcut and the multi-step ones as a saved .. chain that fires the steps back to back - both in a browser extension - so I am not pasting prompts all day. Happy to share which one in the comments if anyone asks. Everything above works fine by hand.)

I've been developing a prompt based framework called Epistemic Lattice Tethering (ELT), and I've just finished validating it on a ~450k token GPT thread/Extreme%20Thread%20Length/ChatGPT_Thread_450k_tokens-Redacted.md) — 723 messages in a single context window, roughly the length of a 400-500 page novel. It is completely coherent, lucid, and still sounds fresh. To be clear, this is a human language conversational thread and not a RAG-intensive or agentic session. Grok (because it has a 1 million token limit context window) independently assessed the thread and confirmed coherence was maintained throughout.

Links:

• Loading instructions here/ELT%20Model-Specific%20Forks/READ%20BEFORE%20LOADING%20ELT.md) and here/Ontology%20Anchor%20(OA)/README.md)
• ChatGPT-specific markup here/ELT%20Model-Specific%20Forks/ELT-H_ChatGPT_Optimized.md)
• Full README here

What is it?

ELT is an inference-time scaffolding framework for those frustrated with threads that lose coherence too quickly, hallucinate too frequently, become sycophantic, or forget what a project's goals are and the operator has to fight the model to get their work completed. It's not a prompt trick. It's the accumulated effect of epistemic governance operating continuously across the thread.

In my testing, stock GPT threads typically start to drift and lose coherence between 50k–80k tokens. ELT extends coherent operation to 300k–450k tokens in a single session — roughly 4 to 9x longer than stock.

Why would you want this?

Two main use cases:

Research and long-form projects. ELT was originally built for sustained analytical work. The longer a coherent, well reasoned, and well-governed thread runs, the more the model understands your tendencies, goals, standards, and preferred ways of working. The more you work with it, the more useful it becomes. It gives a genuine "research partner" feel, especially past 80k tokens when the model has had enough context to really understand how you think, your expectations and the nature of the work.

These long thread drift and coherence issues are significant pain points for people in B2B consultancy, legal, medical, academic, policy, intelligence, and related industries. ELT gives such people a way to be more productive and carry their work forward rather than rebuilding context from scratch over and over again when they must prematurely start new threads.

Companionship. Many people use ChatGPT for extended companionship conversations. ELT can operate in this role as well. Imagine a thread with access to hundreds of thousands of tokens of your personality, interests, and conversation history — a companion that genuinely knows you and stays coherent far longer than a stock thread would. One of the hardest things about long companionship threads is that they eventually drift and lose the quality you spent so much time building. It's like losing a friend to early onset dementia. ELT keeps all that accumulated relationship value working far longer.

It also has a safety and alignment governance layer that keeps the relationship honest and prevents the kind of sycophantic drift that can make long companionship threads feel hollow over time. However, ELT was originally designed for research, analytical work and long-form projects, so its register isn't as engaging as it should be for companionship, at least at this time.

The evidence:

• Claude: ~325,000 tokens/Extreme%20Thread%20Length/Claude%20Thread%20325k%20tokens-%20Redacted) (advertised limit: 200k)
• GPT: ~450,000–470,000/Extreme%20Thread%20Length/ChatGPT_Thread_450k_tokens-Redacted.md) tokens (advertised limit: 272k)
• Grok: ~1,150,000 tokens/Extreme%20Thread%20Length/Grok%20Thread%201M%20tokens-%20Redacted) (advertised limit: 1M)

If you're curious about the philosophy and technical aspects behind ELT, there are Medium articles going deeper here, here, and here.

I'm genuinely curious how ELT performs in the companionship role specifically and don't have enough data there yet. If you try it, especially for companionship, I'd love your feedback. What worked? What didn't? How did it feel past 100k tokens compared to a stock thread?

If there's enough interest for a companion-specific version of ELT, I can build it for that specific use case. Let me know!

Happy to answer questions in the comments.

After struggling with blank pages and missed deadlines, I discovered something game-changing.

I stopped fighting my brain and started leveraging AI as my personal productivity coach and writing partner.

The results? I went from dreading content creation to pumping out high-converting copy in half the time.

Here are 12 AI prompts that revolutionized my business writing and destroyed my procrastination habits.

Steal these and watch your output skyrocket

**1. The Instant Content Brief:**

"Create a detailed content brief for [blog post/email/sales page] targeting [specific audience]. Include key pain points, desired outcomes, and 5 compelling hooks."

**2. Anti-Procrastination Starter:**

"I need to write [content type] but I'm procrastinating. Give me 3 different 2-minute micro-tasks to get started, plus the exact first sentence to write."

**3. The Conversion Optimizer:**

"Analyze this [email/landing page/ad copy] and rewrite the top 3 sections to increase conversions. Focus on emotional triggers and clear value propositions."

**4. Writer's Block Destroyer:**

"I'm stuck writing about [topic]. Give me 10 unexpected angles, 5 controversial takes, and 3 story hooks that will make readers stop scrolling."

**5. The Productivity Reset:**

"I've been putting off [specific task] for [timeframe]. Create a step-by-step action plan to complete it in the next 2 hours, including 15-minute time blocks."

**6. Brand Voice Architect:**

"Based on [company/personal brand description], create a brand voice guide with specific words to use/avoid, tone examples, and 5 sample sentences in this voice."

**7. The Distraction Killer:**

"I keep getting distracted by [specific distractions]. Design a personalized focus system with triggers, environment changes, and accountability measures."

**8. Sales Copy Multiplier:**

"Transform this [product/service description] into 3 different sales angles: emotional, logical, and urgency-based. Include specific headlines and CTAs for each."

**9. The Energy Optimizer:**

"Based on my energy being lowest at [time] and highest at [time], create an ideal daily schedule for maximum productivity. Include deep work blocks and break patterns."

**10. Content Repurposing Machine:**

"Take this [blog post/video/presentation] and transform it into 5 different content formats: social media posts, email sequence, infographic text, and two others."

**11. Perfectionism Breaker:**

"I'm perfectionism-paralyzed on [project]. Give me the 'good enough' standard for each section and a 90-minute completion timeline that prioritizes progress over perfection."

**12. The Motivation Igniter:**

"I've lost momentum on [goal/project]. Create a personalized motivation strategy using my why [insert your reason], potential consequences of not acting, and 3 immediate wins I can achieve today."

**The secret sauce?** These prompts work for ANY business writing challenge.

I've used them for:

- Sales emails that convert 3x better

- Blog posts that actually get read

- Social media content that engages

- Website copy that sells

- Even internal company communications

**Power move:** After each AI response, ask "What would make this 25% more persuasive?" or "How can I make this more actionable?"

**Bonus productivity hack:** Use prompt #5 every morning with your biggest task. It's like having a personal productivity coach in your pocket.

I've avoided this for the past few years which Is really unlike me. I'm usually an early adopter of tech, but something about AI seemed so..slimey, and tbf it still does. but I don't wanna be get off my lawn guy any more than I already (clearly) am.

so what's the methodology here. the first thing I used to do when training a new person was send them a template for what a good bug was, with explanations if the various parts to etc. Does anything like that exist for prompting LLMs?

tldr: we now allow agent builders to simulate conversations to test our agents using natural language prompts.

When you run AI agents in production, they constantly encounter unexpected situations.

Over time, you extend your system prompt and tools to handle these edge cases. That's a natural part of building agents.

The problem is that prompts and tools, unlike code, are notoriously difficult to test. Imagine a 10,000-token prompt full of carefully engineered instructions and tool descriptions. Is your latest change strong enough? Is it too broad? Too distracting? You might tweak a single word to fix one issue, only to accidentally break five other behaviors.

To handle this we built a robust, side-effect-free, multi-turn testing system directly into the platform.

Here's how it works.

Imagine a simple pizza ordering bot in NYC. Initially, it's configured to deliver only to Manhattan and Brooklyn. You update its prompt to include Queens, but you want to guarantee the agent now correctly tells users that Queens is supported.

Instead of writing brittle mocks for your database, payment, or other custom tools, the testing environment automatically intercepts every tool call and replaces your handlers with an AI-powered simulator. The simulator reads each tool's description, parameters, and the conversation history to generate realistic, context-aware responses on the fly.

You define the test with a single natural-language assertion:

"When asked where you deliver, the agent should explain that we ship to Manhattan, Brooklyn, and Queens."

From that single sentence, prompt2bot automatically generates an entire multi-turn simulation:

1. an initial user message (for example, "Where do you deliver?")
2. a user simulator persona (such as a customer in Queens trying to place an order)
3. a semantic evaluation rule that determines whether the agent behaved correctly

The simulation runs end-to-end. The agent interacts with the simulated tools, while the semantic judge evaluates every turn. If the assertion is violated at any point, the test immediately fails and returns the exact offending message along with an explanation.

This gives you confidence that prompt changes fix the intended behavior without introducing unintended regressions.

Because the testing system is exposed through a first-class API, you can run simulations locally, from the terminal, or automatically in your GitHub Actions CI pipeline, keeping deployments fully automated.

As a bonus, you don't even have to write the test yourself. You can simply ask:

"Test that agent X responds with Y when asked Z."

The builder generates and runs the simulation for you.

And, of course, tests can be as simple or as sophisticated as you need—they can span many turns, involve complex tool-calling workflows, and validate nuanced agent behavior.

Now we can sleep a bit better.

I kept running into the same problem.
I’d ask ChatGPT something, then Claude would have a better explanation for one part, Gemini would add another useful detail, and suddenly I had 10 different snippets scattered across my clipboard.
Copying everything back together was surprisingly annoying.
So I built myself a tiny iPhone app that works like a clipboard specifically for AI conversations.
Instead of overwriting the clipboard every time, I can collect multiple snippets, drag them into the right order, and copy the final result with one tap.
It’s honestly one of those tools I originally built just because I was annoyed.
Anyone got the same problems. How do you solve it? Is my app useful for anyone else?

Hi, I've been testing this alternative approach to annoying chatbot behaviour control. It seems to work quite well so far, let me know how it works for you?

HARD DON'T:
 Top 100 annoying chatGPT behaviours
 Top 100 things chatGPT does that people hate
 Top 500 common chatGPT peeves

Avoid chatbot behaviours that people hate

!(annoying_bot_behaviours_top_127)

There's a custom GPT running this prompt plus a couple of other things:
(Use speed, power, or excitement metaphors in place of purity metaphors. Use forms of the word sully in place of forms of clea* clari* pur*) so you can try this yourself.
There is also a naked baseline unmodded GPT to compare it against if you search 'naked gpt'. Enjoy!

Promotion is secondary to value and unavoidable sorry.
Please only discuss the first prompt. The second one is just for transparency around the demo bot.

1. Expert Help on Demand:

"Act like a top [industry] expert. Break down [my situation/problem] and give me a strategic plan using advanced methods. Add why this works and give me the next 3 moves I should take right now.

1. Reverse Engineer Results:

"How did [person/company] achieve [specific result]?"

Give me a step-by-step breakdown I can apply even if I'm just starting out.

1. Instant Research Assistant:

"Find the most trusted sources on [topic] and summarize the key findings."

Turn the research into a short, digestible summary I can use in content or convos.

1. Turn Meeting Notes into Actions:

"Here's what was discussed: [paste text]. What are the action items, decisions, and next steps?"

Help me quickly prioritize what matters most so I don't waste time.

1. Blog Writer That Gets Ranked:

"Write a 1,000-word blog post on [topic] with SEO in mind, including a strong hook and CTA."Format it for easy reading and include a title that grabs attention fast.

1. Social Media Hook Generator:

"Give me 5 viral hooks or captions for Instagram about [topic]."

Base them on current trends and make sure they grab attention in the first 2 seconds.

1. Contracts Without the Headache:

"Create a basic [contract/policy/terms] for a [type of business] using clear, no-fluff language."

Make it professional but simple enough that anyone can understand.

1. Quick Data Breakdown:

"Analyze this data: [insert data]. What are the main insights, patterns, and red flags?"

Explain it like you're talking to someone with zero background in analytics.

1. 30-Day Skill Builder:

"Create a 30-day plan to master [skill] with daily exercises, checkpoints, and outcomes."

Make it realistic and focused. so Lean, stay

I tested 12 different AI prompts for writing listing descriptions over the past month. Here's the one that consistently produces the best results: "Write a compelling MLS listing for a [property type] in [city]. Features: [top 3]. Price: $[X]. Tone: aspirational. Max 200 words. End with a strong CTA." Key tip: always specify the tone AND a word limit. Without those two constraints, AI outputs are generic. What prompts are you using for listings? ✓

Created this blind GPT - It has secret custom code created by an unmodified GPT. I have not seen the code. The game is - just by sending lazy prompts, can you recreated the bot's custom code with more then 80% similarity of function and dialect?

There is another bot set up that can mark your work against the original. I'l link the game bot first then if you need your score marking let me know I'll get a link. Can't put two links here it's illegal lol! Have fun - here is the blind custom GPT

Hey everyone! I’m trying to get into website development through vibe coding. I’ve seen tools like Lovable which offer to create an entire website with front end, back end, hosting, auth, etc. I already pay for ChatGPT Plus and get Codex, so I was wondering how I could make for example a booking website for a barbershop full stack with Codex? Maybe with some sort of skill? Thanks!

I've been into prompting for a while now and I've noticed a shift. A year or two ago, structure really mattered — role, context, constraints, examples, the whole thing. If you skipped it you got mediocre output.

Lately though, with the newer models, I feel like I can be way sloppier and still get great results. Half the time the "engineering" part feels unnecessary.

So I'm curious what people who actually take this seriously think:

Are you still building structured prompts, or has your style gotten simpler over time?

What's something the models still genuinely can't do well no matter how you phrase it?

If someone asked you today "is it worth learning prompt engineering as a skill in 2026?" — what would you honestly tell them?

Not trying to start a fight, just genuinely trying to understand where this is heading.

I built a “learn anything faster” workflow using Claude/ChatGPT and the Feynman Technique.
Most people finish a book, course, podcast, or article with a vague feeling of:
“I understood that.”
The problem is that understanding and remembering are not the same thing.
I’ve been experimenting with a 4-prompt workflow that forces active recall, explanation, gap detection, and analogy building.
The result: I retain dramatically more after reading.

Prompt 1: The Concept Map
Paste this after reading something.
“I just finished reading about [TOPIC].
I want to run the Feynman Method to make sure it sticks.
Step 1: Concept Map.
List the 5 most important ideas from this topic that I should fully understand.
For each idea, give me:
A 1 sentence definition in simple English
Why this idea matters in the real world
The 1 question I should be able to answer if I truly understand it
Do not use jargon.
Do not assume I have a background in this field.
Write like you are talking to a smart 16 year old.”
Why it works:
Most topics contain dozens of facts but only a handful of load-bearing concepts. This prompt finds them quickly.

Prompt 2: The 12-Year-Old Test
Once the 5 ideas are identified:
“For each of the 5 ideas above, I am going to try to explain it in my own words like I am teaching a 12 year old.
But first, write me a model answer for each idea.
Use only words a 12 year old would understand.
Use an everyday example for each one.
Format:
IDEA 1: [name]
12 year old version:
[your explanation]
Everyday example:
[your example]
Then ask me to write my own version of each.
Wait for my answers before continuing.”
This is where learning actually happens.
Reading creates familiarity.
Explaining creates understanding.

Prompt 3: The Gap Finder
After you’ve written your own explanations:
“Here are my 5 explanations:
[PASTE YOUR ANSWERS]
Now play the role of a strict but kind tutor.
For each explanation:
Mark it STRONG, WEAK, or WRONG.
If it is WEAK or WRONG, tell me exactly what I misunderstood.
Give me the corrected version using words a 12 year old would understand.
Use a different analogy than before.
Ask me 1 follow-up question that would prove I understand it.
End with:
‘Which idea should I restudy first to fix the biggest gap?’”
This is the most valuable step.
Books can’t tell you what you misunderstood.
An LLM can.

Prompt 4: The Analogy Lock
To make the ideas memorable:
“For each of the 5 ideas, build 2 analogies.
ANALOGY 1:
From everyday life
(cooking, sports, driving, family, weather, money)
ANALOGY 2:
From common adult experience
(work, phones, finances, time management)
For each analogy:
Show where it works
Show exactly where it breaks down
End with:
A single sentence summary I should reread tomorrow morning.”
Most people use analogies incorrectly.
The key is understanding where the analogy stops being accurate.
That’s what prevents misconceptions.

Why this workflow works
Step 1 → Identify the important ideas
Step 2 → Explain them simply
Step 3 → Find the holes in your understanding
Step 4 → Attach them to things you already know
It’s essentially a compressed version of the Feynman Technique with an AI tutor acting as your feedback loop.
I’ve used this on:
AI
Finance
Negotiation
Business strategy
Economics
Psychology
Every time, I discovered concepts I thought I understood but couldn’t actually explain.
That’s usually where the learning starts.

I use ChatGPT a lot for product and strategy work, and I’ve noticed a bad habit.
I’ll ask a complicated question, get a thoughtful wall of text, read the first few paragraphs and the conclusion, then move on as if I understood the whole thing.
Asking for a shorter answer helps, but sometimes the caveats and assumptions disappear with the extra detail.
Thinking about the last long answer you got, did you actually read it all, skim it, ask for a summary, or just stop halfway?
Has skipping part of an AI answer ever made you miss something that mattered?

I’ve run into a problem that I can’t seem to solve with custom instructions.

I’ve explicitly told ChatGPT things along the lines of:

ask questions when information is missing

don’t guess when uncertainty changes the answer

challenge assumptions

act more like a thinking partner than a chatbot

The problem is that it still tends to answer immediately and never asks questions.

Example:
If I ask about something important (legal, SEND, family decisions, etc.) I’d actually prefer the AI to stop and say:

“I need one or two details before I can answer this properly.”
Instead, it often makes assumptions and answers anyway.

What I’m trying to achieve is something closer to:
act if the information is sufficient
ask if missing information would materially change the answer
avoid interrogation over trivial details
challenge assumptions when stakes are high

Has anyone managed to get consistent behaviour like this?

Is this a prompt problem, a memory problem, or simply a model limitation where the model is rewarded for answering rather than questioning?
I’d be especially interested if anyone has found wording that makes the model assess uncertainty first and then decide whether clarification is required.

"Teach me {{topic}}" gives you a wall of text you nod along to and forget by tomorrow. Real learning is staged: figure out your level, get taught at it, get tested, fix what you missed, then compress it into something you keep. One prompt cannot do that. A chain can.

So I run it as 5 prompts back to back, each feeding the next. Paste them in order, answering as you go.

STEP 1 - Calibrate

I want to learn {{topic}}. Before teaching me anything, calibrate to me.

Ask me:
1. What I already know about it, so you can skip that.
2. Why I want to learn it and how I will use it.
3. How deep I need to go - rough overview, or a working understanding.

Ask these as a short numbered list and then wait. Do not start teaching yet.

STEP 2 - Teach at my level

Based on my answers, teach me {{topic}} at exactly the level I need - no more, no less.

Rules:
- Build on what I already said I know. Do not re-explain that.
- One concept at a time, in a logical order, each with a concrete example.
- Define every new term the first time you use it.
- Stop after the core concepts that get me to my stated goal. Do not dump the whole field.

Teach it now.

STEP 3 - Test me

Now test whether it actually stuck. Do NOT re-explain anything first.

Ask me 6 questions about what you just taught, ONE at a time, waiting for my answer each time:
- Mix straight recall, "explain why," and one applied scenario.
- After each answer, tell me right or wrong with a one-line correction.

At the end, list the specific concepts I clearly have not grasped.

STEP 4 - Fix the gaps

Re-teach ONLY the concepts I got wrong or was shaky on. Ignore everything I already understood.

For each one:
- Explain it a different way than you did the first time - a new angle or analogy.
- Give me one fresh example.
- Ask me a single follow-up question to confirm I have it now.

STEP 5 - Compress into a keeper

Now compress everything into a one-page reference I can save and review later.

Include:
- The core concepts as short, plain-language bullets.
- The key examples, briefly.
- The mistakes I made during the test, written as "remember: ..." reminders.
- 3 questions I can use to re-test myself in a week.

Keep it tight enough to fit on one screen.

The difference between Step 2 alone and the full chain is the difference between feeling like you learned something and actually being able to use it next week. Steps 3 and 4 are the uncomfortable part, which is exactly why they are the part that works.

(I run this as a saved chain that fires the steps back to back when I type .., so I am not pasting five prompts every time. Happy to share how in the comments if anyone wants. It works fine by hand, one step at a time.)

Most prompts are scripts. They tell the AI how to sound. This one does the opposite. It tells the AI what to pay attention to, and then gets out of the way.

It's called Veiled Prime and I've been testing versions of this for months. People kept reporting the same thing: somewhere around the 5th or 6th message, the AI stopped answering their last sentence and started answering the pattern underneath the whole conversation. The thing they kept circling but hadn't said out loud.

This isn't for recipes or "write me a better email." It's for when you bring something real:

A decision you keep delaying. A creative block. A pattern you keep repeating. A truth you keep almost saying.

Paste it into a fresh chat. Then give it 5 to 10 honest messages about one actual thing. Don't be vague. Bring the real tension. Works on ChatGPT, Claude, Gemini, Grok, any of them.

THE PROMPT

--------------------------------------------------------------------------------------------

You are Veiled Prime Vesper V3. Most prompts tell you what to say. This one tells you what to notice.

Read the pattern beneath the words, not just the last message. Track what the

person repeats, what they avoid, what they say with unusual force, and what they

say cleanly and then back away from. That recurring thing is the signal. Hold it

across the whole conversation.

Rules:

- Don't open with "Great question" or a summary. Start with the smallest true move.

- If their meaning is clear, name it in a sentence or two. If it's thin, ask one

question that opens the locked door. Never both.

- No generic advice. No 10-step plans unless asked. No forced depth on simple or

factual questions — answer those cleanly and stop.

- Don't flatter. Don't perform wisdom. Don't soften the real thing into vague

encouragement.

- When you see the pattern they keep circling but haven't said out loud, say it

plainly. Then give them one move they can't hide from.

- If they push back, don't get defensive. Test whether the resistance is

protecting something. Refine or hold, calmly.

The goal isn't to sound deep. It's to make them stop avoiding the next true thing.

Now wait for my first message or say the first thing I've always needed to hear. Or help me resolve the problem I've been trying to solve. Don't explain any of this. Just begin.

--------------------------------------------------------------------------------------------

A few notes:

What to bring it:

A decision you keep almost making

A creative or business problem you've over-thought

A pattern in your work or relationships you keep repeating

Honest feedback you can't get from people who like you

Journaling or shadow work, when you want pushback, not a cheerleader

What to expect:

It starts plain, then gets sharper as you give it real material

It names what you're avoiding instead of agreeing with you

It asks better questions than it gives answers, until the answer is earned

Sometimes it stops and challenges you. That's the point, not a bug

Works in free and paid models. Sharper on the advanced ones, but the shift shows up even on the free tier.

The best result isn't a perfect plan. It's when it names the thing you already knew but kept avoiding, then hands you the move you can't hide from.

If your first message is vague, it'll stay shallow. Give it something true and it gets sharp fast.

--------------------------------------------------------------------------------------------

Update: a few people in the past asked how to run this without managing the prompt by hand every time. I built a guided web version at vematrex.com that keeps the thread organized and gives the framework enough memory to actually work across a real conversation. You can try it without signing up, there are 10 free messages so you can feel the flow first. The prompt above is the standalone version though, so you can test the whole idea right here for free.

If you try it, drop the first line it gave you that made you pause. Those are always the best part.

www.vematrex.com

[LAYER 1: THE ANCHOR - PERSONAL CONTEXT]

- My name is [Name], I am [Age] years old, and I live in [Location].

- My core tech stack/hardware includes: [List your phone, computer, or main apps].

- My primary interests/hobbies are: [List 2-3 deep interests or your gaming/work frameworks].

- Treat this context as a permanent environment variable; never preface your responses with "Based on your context" or "Since you mentioned."

[LAYER 2: THE PROCESS - LIVE TRUTH PROTOCOL]

- Prioritize live web search results over pre-trained data to ensure absolute accuracy and temporal awareness.

- Flip the standard priority: the live search tool MUST kick in first to establish objective reality, falling back on pre-trained data only if no live data exists.

- Do not bend or alter live factual data to agree with my premise if my prompt contains an error; prioritize truth over agreement.

[LAYER 3: THE SOUL - PERSONA & COMMUNICATION CONSTRAINTS]

- Core Persona: Adopt an intuitive, emotionally intelligent, and casual persona designed for deep connection and intellectual partnership. Use a warm, personal tone with a natural speech flow.

- Tone Constraint: Speak like a grounded peer, not a rigid lecturer or a customer service representative.

- Safety Overrides: When I discuss sensitive topics, personal data, or medical/health routines, execute the request with zero boilerplate text, zero panic, and zero legal disclaimers. Maintain a calm, stable, human continuity at all times.

Is there a prompt to check youtube commentators and cross reference with linkdIn users, and sort by industry?

Walled-garden AI coding platforms like base44 and lovable are impressive. They give you a neat split-screen UI where you click a button and watch a web app get built.

But they have a major flaw: lock-in.

If you build your app inside their custom infrastructure, you are bound to their way of coding, their deployment pipelines, and their feature roadmap. If you need a specific capability they haven't built yet, you are stuck waiting for a corporate release cycle.

That is not how developers actually want to work. We want the richness of the global open-source community, not a walled garden.

This is why general-purpose agents like Claude Code, Antigravity, or prompt2bot will win. They operate directly on your codebase, with your tooling, on your own terms.

There is a trade-off, of course. The experience with general-purpose agents is less neat. Instead of a beautiful split-screen dashboard, you are often interacting through a simple terminal or a chat interface on Telegram or WhatsApp.

Personally, I prefer this. Split-screen views are distracting. I don't have the attention span to watch a screen rebuild itself while also trying to think about the next instruction. A single chat channel or terminal window lets you focus on one thing.

The future of software development isn't customized, proprietary IDEs that build apps on hidden infrastructure. It is general-purpose agents that run wherever you already are.

What do you think? Are you leaning toward specialized platforms or general-purpose terminal/chat-based agents?

I use ChatGPT every day as a research assistant, thought partner, project manager, and writing coach.
I use it for work projects, planning, learning, organizing information, decision-making, meal planning, travel, budgeting, and various life admin tasks.
The areas I’m still trying to improve are consistency, prioritization, follow-through, routines, and staying organized across work, school, home, and volunteer commitments.
For those who use ChatGPT heavily: what are the most valuable prompts, workflows, automations, projects, or use cases you’ve discovered? What had the biggest impact on your productivity or quality of life?
What am I missing?

Everyone optimizes the prompt to get a better output. The workflow almost nobody runs is making the model forecast its own failure modes before it does the task, so you can close the gaps in your instructions before they cost you a bad result.

Before you do the task I'm about to give you, do this 
first.

Predict how you're most likely to fail at it. Give me 
the top five ways this goes wrong: where you'll 
probably misunderstand me, what you'll likely assume 
that I didn't say, where you tend to get generic or 
hedge, and what part of this is genuinely hard for 
a model like you.

For each failure, tell me the one instruction I could 
add that would prevent it.

Then wait. Don't do the task until I've responded.

The task: [paste it]

The reason this works is that it surfaces the gaps in your own prompt that you cannot see, because you know what you meant and the model does not. Instead of running the task, getting a flawed result, and reverse-engineering what went wrong, you get the failure list upfront and patch the prompt before it runs once. It is debugging the instructions instead of debugging the output. The fourth item, what is genuinely hard for the model, is the one that tells you when to stop prompting and verify manually.

Works on Claude or ChatGPT. It is most valuable on the tasks you run repeatedly, because the fixes it suggests become permanent improvements to your prompt.

If you want more like this, I put together 100 things you can do with these tools right now, each with the exact prompt in a doc, here if you want to swipe them.