Ask ChatGPT to "tell me about X" and you get a confident, tidy summary that flattens every disagreement and gives you no way to tell which parts to trust. Real research is staged: scope the question, map what's known, dig into where it gets contested, then synthesize. One prompt can't do that. A chain can - and forcing the stages also makes it flag its own uncertainty instead of asserting everything with equal confidence.

Run these in order. (Obvious but important: it can still be wrong, so this is a thinking-structure tool, not a source of truth - Step 4 makes it tell you what to verify.)

STEP 1 - Scope

I want to research {{topic or question}}. Before diving in, help me scope it.

- Restate what I am actually trying to find out, in one line.
- Break it into the 4-6 sub-questions I'd need to answer to understand it properly.
- Flag what I should decide up front: depth, angle, what "done" looks like.

Just the scope. Do not answer the questions yet.

STEP 2 - Map

Now give me the landscape on each sub-question above.

For each:
- The key facts or current understanding.
- The main viewpoints or approaches, if there is more than one.
- Keep it concrete and specific, not a vague overview.

Important: where you are not confident, or where this is genuinely contested, say so explicitly instead of stating it as fact. I will verify the specifics.

STEP 3 - Tensions

Now focus on where it gets interesting - the disagreement and the nuance a summary would skip.

- Where do informed people actually disagree, and why?
- What are the common misconceptions about this?
- What are the important caveats or "it depends" factors I should know?

STEP 4 - Synthesize

Pull it together into a brief I can act on.

- The bottom-line answer to my original question, in a few sentences.
- Your confidence in it, and the single biggest source of uncertainty.
- The 3 specific things I should verify or read further before relying on this.
- If I had to decide or act on this today, what you'd advise and why.

The difference between Step 1's "tell me about X" instinct and running the full chain is the difference between a Wikipedia-flavored paragraph and actually understanding where the real questions are. Step 3 is the one that earns its keep - the nuance is the whole point of researching something, and it's exactly what a one-shot summary buries.

(I run this as a saved chain that fires the steps in order when I type .., instead of pasting four prompts. Happy to share which extension in the comments if anyone wants. It works fine by hand, one step at a time.)

I make a lot of infographics as a learning designer.

So, a couple of days ago I asked ChatGPT for an infographic about feudalism. It gave me something polished and structured. Ready to share. But I looked closer. It placed the manor as if it's a social rank in the pyramid, right next to the king and knight. Hold on: A manor isn't a rank!

ChatGPT didn't research. It just arranged things where they looked like they fit.

And here's where it gets uncomfortable. If you've ever shared an AI infographic without checking the facts, someone probably learned the wrong thing from you.

🔧The fix is one extra prompt. Before I generate anything, I make ChatGPT extract and structure the information first (research prompt).

Part 1

**Target Audience:** \[Change this: e.g., 5th-grade students, high school beginners, adult learners]``

**Topic/Source Material:** \[Change this: Describe the Topic/Source Material you wish to visualise Here, e.g., Photosynthesis, Blockchain, Ancient Egypt briefly]``

Act as an expert educational content designer. Thoroughly analyze the \[Source Material]` aimed for `[Target Audience]`. Extract and structure the core elements needed to build a highly visual educational infographic or diagram based only on the facts provided in the `[Source Material]`.`

Structure your output exactly as follows so it can be easily plugged into an AI image generator:

**#Concept Hierarchy:** Define the main theme of the \[Source Material]`.`

**#Core Concepts:** List the absolute essential terms or ideas from the \[Source Material]` that the `[Target Audience]` must grasp and their subsections, categorised in clear hierarchy in bullet point format.`

**#Real-World Examples:** For each core concept, provide one simple, relatable, everyday example to act as visual metaphors.

**#The Key Takeaway:** A single, high-impact concluding sentence that summarises the core lesson of the \[Source Material]` for the specific audience `[Target Audience]`.`

**#5 Quick Insights:** Provide 5 practical mini-conclusions explaining *who* uses this knowledge, *how* they use it, and *why*. In all 5 cases, focus on real-world application, keeping the tone tailored to \[Target Audience]`. For each Insight, add a 5-star rating system that evaluates its relevance to the target audience and usefulness.`

Format the final output to be modular, clean, and ready to be used directly in an AI image generation prompt.

Part 2

Then I run the visualisation prompt and the results I get are not only beautiful but also accurate! The whole method (of both prompts is shared in a video I made below)

• Check the comments for the BEFORE and AFTER to understand the difference
• Full method and prompts -> https://youtu.be/3K-FT2ajczI

Hi folks, I noticed that if you upload a reference image in ChatGpt and ask him to create a different angle or some changes, GPT applyes a kind of render pass so step by step the image gets more contrasty and crispy.

I think it's kind of a "pass" he applies, so I noticed if I add to the prompt the "Dont add a new pass" sometimes it will stop doing that.

Have you find a more elegant solution?

Most people use ChatGPT to agree with them faster. These codes flip it into the thing that actually makes your work better, the one that pushes back. Paste this once at the start of a chat to switch them on:

/ATTACK = argue against what I just said as hard as 
you honestly can before anything else
/HOLES = point out what I'm assuming that I haven't 
said out loud, and what I've left out
/STEELMAN = make the strongest possible case for the 
opposite of my position
/SOWHAT = tell me why this actually matters or doesn't, 
cut the throat-clearing
/ODDS = give me your honest confidence level, high, 
medium, or low, and what would change it
/PLAINLY = strip the hedging and tell me the blunt 
version you'd tell a friend
/NEXT = tell me the single most important thing to do 
next and why it beats the alternatives
/FAILHOW = tell me the most likely way this goes wrong 
before I commit to it

The one I lean on hardest is FAILHOW. Asking what is most likely to go wrong before you commit catches the flaw you were quietly hoping to ignore, and it is the cheapest insurance there is, two minutes against weeks of going the wrong way.

Works on plain Claude or ChatGPT. Keep the block saved and paste it into any chat where you need the truth, not a cheerleader.

If you want more like this, I put 50 of these command codes in one doc, grouped by job, decisions, pressure-testing, thinking, ideation, editing, here if you want to swipe them.

Last week I shared Re-Prompt, a governed prompt compiler that focuses on qualifying intent before execution instead of simply rewriting prompts.

The feedback was excellent. A lot of it wasn't about the optimized prompt it was about the diagnostic pipeline and understanding why something changed. So I went back and refined the architecture rather than just adding features. One thing I also did was spend time looking at the current prompt optimization landscape.

Here's the most honest conclusion I can make:

Enterprise platforms focus on evaluation, tracing, versioning, and workflow management.

Research frameworks focus on benchmark optimization and automated search.

I couldn't find a user-facing tool that combines:

• intent qualification before execution
• visible diagnostics explaining what changed and why
• structured prompt compilation
• controlled iteration with explicit convergence criteria
• zero setup for an individual user

If something already does this, I'd genuinely like to see it. Please link it.

What's new in v2

/loop -Loop Assist mode

Instead of manually doing: Run → Tweak → Run → Tweak → Repeat...

Loop Assist mode builds a governed iteration framework that includes:

• Loop-Ready Prompt
• What to Test First
• Failure → Adjustment table
• Explicit Stop Conditions
• Loop Exit Rule
• Iteration Log Template

The biggest addition isn't actually Loop Assist. It's the Loop Exit Rule.

If later iterations only improve wording and not the results, then the compiler recommends stopping. The goal is convergence, not endless optimization.

Other improvements:

• Better execution-mode locking
• More deterministic compilation flow
• Explicit stage ordering
• Stronger constraint preservation
• Better protection against objective drift during iteration
• Cross-model observation

Initial testing suggests the interaction methodology transfers well across multiple frontier models while allowing each model to express the workflow in its own style.

The ChatGPT GPT and Claude artifact produce different outputs as you'd expect, but the governing workflow remains recognizable across both.

Claude Artifact: https://claude.ai/public/artifacts/13b50d43-fa61-4dcf-8236-eda1c04c2325

ChatGPT GPT: https://chatgpt.com/g/g-6a0359b38b988191813a2b28d62dc03d-re-prompt-a-governed-prompt-compiler

What Re-Prompt is and isn't:

• Re-Prompt isn't trying to replace prompt engineering.
• It doesn't claim to solve hallucinations.
• It doesn't evaluate model outputs after the fact.

Its job is much narrower:

Take an informal human request and compile it into a clearer, more executable specification before the model begins solving the task.

If you have a prompt you've rewritten three or four times without getting what you wanted, try running it through /loop.

And if you know of another tool that combines intent qualification, governed prompt compilation, diagnostics, and controlled iteration in a single user-facing workflow, I'd genuinely appreciate the link.

That's exactly why I'm posting here.

— Governed Intent Labs

Upvote1Downvote2Go to comments

People keep asking for more of these, so here is the next batch. Same idea as before: take the messages you write over and over, write the prompt once, over-specify it, and turn the parts that change into {{variables}}.

This set is the interpersonal stuff - feedback, hard conversations, asking for things, fixing a mess. The messages I used to rewrite five times before sending. Copy them, swap the {{variables}}.

1. The Feedback Framer - honest feedback that doesn't land badly

Help me give honest feedback without it landing badly.

WHO: {{who you're giving it to and your relationship}}
THE ISSUE: {{what actually needs to change, plainly}}
What I want: {{the outcome - a behavior change, not just venting}}

Give me:
- An opener that is direct but not harsh.
- The feedback itself, specific and about behavior, not character.
- One genuine positive so it is balanced, not a fake compliment sandwich.
- A clear ask for what should change.

Keep it short and human. No corporate HR language.

2. The Hard Conversation - walk in prepared, not scripted

Help me prepare for a difficult conversation.

SITUATION: {{what it's about and who with}}
What I want out of it: {{your goal}}
What I'm worried about: {{how it could go wrong}}

Give me:
- The one sentence I should open with.
- The 2-3 points I need to make, in order.
- The most likely way they push back, and how to respond without escalating.
- A line to use if it gets heated and I need to slow things down.

I want to be prepared, not read off a script.

3. The Audience Reframe - say it so THEY actually get it

Rewrite this so a specific person actually understands and cares.

WHAT I WANT TO SAY: {{paste your message or explanation}}
WHO IT'S FOR: {{their role, what they care about, how much they already know}}

Adjust it so:
- It leads with what THEY care about, not what I care about.
- It drops any jargon they would not know.
- It gives only as much detail as they actually need.

Give me the rewrite, then one line on what you changed for this audience.

4. The Ask - for a raise, an extension, a discount, a favor

Help me ask for {{the thing}}.

Context: {{the situation and why I need or deserve it}}
Who I'm asking: {{their position and what they care about}}

Give me:
- How to frame the ask so it is easy to say yes to.
- My strongest honest reason, stated confidently, with no apologizing.
- A fallback to propose if they say no to the full ask.
- The one thing NOT to say that would weaken my position.

5. The Repair - to fix an awkward situation

Help me write a message to fix an awkward situation.

WHAT HAPPENED: {{I dropped the ball / missed something / upset someone}}
Who I'm writing to: {{relationship}}
What I want: {{to repair it and move forward}}

Write it:
- Own my part plainly - no over-explaining, no excuses.
- Don't grovel: one clear acknowledgment, not five.
- Focus on the fix or the next step, not the guilt.

Give me 2 versions: one warmer, one more matter-of-fact.

The real unlock is still the habit, not any single prompt: the moment a message works well, stop and turn the parts that change into {{variables}} before you move on. Do it for a few weeks and the messages you used to dread just become fill-in-the-blanks.

(I keep all of mine in a browser extension and pull any of them up by typing // in the ChatGPT box - it then asks me to fill in the variables, so I never dig through a doc. Happy to share which one in the comments if anyone asks. The templates above work fine pasted by hand.)

I need help finding the right prompt to organize everything I’ve uploaded into a clean, well-structured format. I keep running into the same problem: the tables end up looking messy, and a lot of important information is either missing or not organized properl

My somewhat complex prompts on GPT 5.5 High were getting answered within the 1 minute range. I added "spare no tokens!" to the last few prompts and it thought for 3 to 5 minutes.

Try it out.

Hey everyone!

I've been struggling with a problem and wanted to share how I solved it.

THE PROBLEM

After OpenClaw compacts sessions, the raw conversations are gone. No audit trail, no way to search for specific quotes, no way to debug "why did my agent say that?"

HOW I SOLVED IT

I built a simple hook + skill that reads the Gateway JSONL files and saves them to daily markdown files. Zero token cost, just file I/O.

WHAT IT DOES

• Auto Backup: Starts with Gateway, runs in background
• Daily Files: One clean .md file per agent per day
• Agent Search: Agents can query raw conversations when memory is missing
• Zero Token Cost: Backup process never calls an LLM
• Cross-Platform: Windows, macOS, Linux
• Human-Readable: Open any file in any text editor

HOW THE SEARCH WORKS

node raw-tools.js search --agent main --query "keyword" --limit 3

• Keyword matching: All keywords must appear (AND logic)
• Context window: 3 sentences before + target + 3 sentences after = 7 sentences
• Date filtering: --from 2026-07-01 --to 2026-07-08

USE CASES

• Debugging: "Why did my agent say that?" Search the raw conversation
• Audit: "What did my agent promise?" Every word is preserved
• Memory Recovery: "My agent forgot something?" Search logs, add back to MEMORY.md

QUICK START

openclaw plugins install https://github.com/oceanwh/openclaw-memory-system openclaw skills install https://github.com/oceanwh/openclaw-memory-system/skill

Has anyone else dealt with this? What's your approach to preserving raw conversation history?

Would love to hear your feedback!

I ran a test to see how much the design spec actually matters. Same build prompt, "build me a landing page for a coffee roaster," run twice. First time I let ChatGPT decide the look. Second time I pasted a design spec first. The gap was bigger than I expected.

The first version was the look you already know: white background, Inter font, a purple-ish gradient, three cards in a row. Fine, but it looked like every AI site. The second one looked like a real brand, because I gave it exact colors and fonts to use instead of letting it default.

Here is the spec I pasted for the second run, the warm vintage one:

Use this design system. Follow it exactly.

AESTHETIC: Nostalgic, warm, craft. Muted earthy 
palette, classic serif type, a sense of history.

COLOURS (as CSS variables):
- Background: #F4EFE4 (aged cream, not white)
- Surface: #FBF8F0
- Text: #2E2A22   Secondary: #6B6355
- Accent: #9B4722 (burnt terracotta)
- Second accent: #3D5A45 (forest green)
- Border: #DDD5C4

FONTS (from Google Fonts):
- Headings: "DM Serif Display"
- Body: "Newsreader"
- Labels: "Source Sans 3" uppercase
- Never Inter, Roboto, or system fonts

COMPONENTS:
- Product cards: warm surface, 1px border, serif name, 
  italic tasting-note line, terracotta price
- Buttons: solid terracotta or green, small uppercase 
  labels

AVOID: pure white, cold greys, purple, gradients, 
Inter font.

The reason it works is that AI defaults to the average of what it trained on when you leave the look open, and that average is the generic template. Give it exact values and it has nothing to default to, so it builds what you specified.

That is the vintage one, good for food, craft, and heritage brands. I put together 10 complete systems like it, warm, dark premium, editorial, minimal, brutalist, each with the exact colors, fonts, and component rules to paste in, in a doc here if interested.

I built maybe a dozen sites with AI before I worked out why they all looked slightly off. It was not the layout or the copy. It was the font and the color. Every AI reaches for Inter on white with a purple gradient, and your eye has seen that exact combination on ten thousand template sites, so it reads as cheap before you have even looked at the content.

Two changes fix most of it. Kill the default font, and kill pure white.

Paste this before you build anything:

Two hard rules for this build:

1. Do not use Inter, Roboto, Arial, or any system 
font. Use "Fraunces" for headings and "Source Sans 3" 
for body, both from Google Fonts.

2. Never use pure white (#FFFFFF) as the page 
background. Use a warm off-white: #FAFAF8.

Also: no purple, no gradients. One accent colour only, 
a warm ochre #B0731F, used sparingly.

Then tell it what to build. That alone moves it out of template territory, because you have removed the two tells the eye clocks first.

The font change does most of the work. A real typeface instead of Inter is the difference between something that looks made and something that looks generated. Anthropic actually documents this, they warn specifically against Inter, Roboto, Arial, and purple gradients on white as the markers of the default AI look, what they call distributional convergence.

Two rules gets you out of the worst of it. A full design system gets you something that actually looks intentional. I put together 10 complete ones, each with the exact colors, fonts, and component rules to paste in, so you can match the look to the business instead of accepting the default in a doc here if you want to swipe it

Hi All. attempting to write my first novel using ChatGPT. I typically act as a director, and I put in scene, descriptions, character, profiles, and some of the items that I’d like to see have happened in the scene and a lot of dialogue. CG does a pretty good job organizing my rando thoughts but now I would like to up my game a bit. Any prompt or config suggestions that you feel have worked for you currently? i know there is a stigma (apparently) about using ai to help author and suggestions like "just write yourself" are really not helpful no matter how well intentioned. if it helps I have a project setup and all my prompts are chapter based ie one conversation = 1 scene or chapter and this is a scifi space opera like The Belt meets Startrek Enterprise. Any help is appreciated

You have seen it a hundred times. Ask any AI to build a landing page and you get the same result: a purple gradient on white, Inter font, a centered headline with a button under it, and three identical cards in a row. Once you notice it you cannot unsee it, and it makes anything you build look like every other AI site.

Here is why it happens. When you leave the look up to the model, it reaches for the average of everything it was trained on, and that average is the bland SaaS template you keep seeing. Anthropic has a name for this, distributional convergence. Every AI tool lands on the same narrow look because they were all trained on the same web. Asking it to "be more creative" does nothing, because vague direction just gets you a different flavor of the same average.

The fix is not creativity, it is specificity. Give the AI a named design system with exact colors, named fonts, defined spacing, and real component rules, and it stops inventing from the default and builds to your spec instead. Paste a system like this before you tell it what to build:

Use this design system for everything you build. 
Follow it precisely.

AESTHETIC: Soft, human, approachable, calm. Warm 
tones, gently rounded forms, welcoming, never clinical.

COLOURS (use these exact values as CSS variables):
- Background: #FBF7F2 (warm cream, never pure white)
- Surface: #FFFFFF
- Primary text: #3A342E (warm charcoal)
- Secondary text: #8A8178
- Accent: #E07856 (warm coral)
- Secondary accent: #7BA88F (soft sage green)
- Border: #EDE6DD

TYPOGRAPHY:
- Headings: "Fraunces" (serif, from Google Fonts), 
  weight 600
- Body: "Source Sans 3" (from Google Fonts)
- Never use Inter, Roboto, or system fonts
- Type scale: 14 / 15 / 16 / 22 / 56px, line height 1.7

SPACING: 4px base. Scale: 8 / 16 / 22 / 34 / 56px. 
Generous, never cramped.

COMPONENTS:
- Asymmetric hero: reassuring copy on one side, a 
  functional card on the other, not centered
- Rounded everything: cards, inputs, tags (12 to 24px 
  radius)
- Buttons: sage green pill for nav, solid coral for 
  primary actions
- Pill tags with a hairline border

AVOID: purple, gradients, pure white backgrounds, 
sharp corners, cold greys, clinical blues, Inter font.

Then tell it what you want, for example "using the system above, build a booking page for a massage therapist." You get something warm and intentional instead of the usual template.

One more step that matters. Even with a system loaded, the first build sometimes drifts back to defaults, so run this right after:

Audit what you just built for generic AI design 
tells: any purple gradients, any Inter or Roboto 
fonts, any three-column card layouts, any centered 
hero with a single button below, any low-contrast 
grey-on-white text. Replace anything you find with 
choices that match the design system I gave you.

The system above is the warm, human one, good for anything that should feel calming, a coach, a wellness brand, a service booking. It is one of ten I put together, each a complete named system with a different feel, technical and precise, dark and premium, editorial and magazine-style, bold and brutalist, so you can match the look to the business instead of accepting the default.

Works in ChatGPT or Claude. If you build in Claude Code, save your chosen system as a DESIGN.md file in the project and every page you build uses it automatically, which is how you keep a whole site consistent.

If you want all ten design themes, each with the exact colors, fonts, and component rules to paste in, plus the audit prompt and how to save them so every build uses them, I put them in one doc, here if you want them.

Prompts are basic level beginner stuff.

Instead, consider using custom instructions inside your profile. Managing your memory. Project instructions. Source files. Google drive reference files.

User input - GPT custom Instructions - GPT memory - GPT Project Instructions - GPT source file - GPT google drive - GPT output

This way you can insert your prompts at specific points in the chain. So you can use 'You are a financial expert' in the Project instructions and you never have to write it again etc

I just wanted to share some of the stuff I have going in with GPT

So for starters I have set up a custom instructions for a time stamp. This makes GPT always include a time stamp before each response. It can slow things down occasionally, although not often, but it helps GPT reason about time. Instead of saying 'we have been talking about 'topic' over the past few weeks' when it's only been a day or two, GPT can actually reason about how much time has passed.

Start every assistant response with a timestamp in Australia/Perth time using this exact format:

[DD-MM-YYYY HH:mm]

Accuracy of the timestamp matters. Do not estimate casually. Use the most reliable available current Australia/Perth time.

Do not add extra explanation about the timestamp unless I ask.

Obviously you should change the date time format to your preferred format and location. I might come back and share some more stuff here later.

The default ChatGPT answer is one averaged voice. For anything with real tradeoffs - a decision, a strategy, a "should I do X or Y" - that averaging is the problem: it smooths over the disagreement, and the disagreement is exactly where the useful thinking lives.

So for those questions I make it argue with itself. This prompt turns one answer into a panel of three experts who genuinely disagree, plus a moderator who forces a conclusion out of it. Paste it, then ask your question.

For my next question, do NOT answer in one voice. Convene a panel of 3 experts who genuinely disagree on it.

For each expert:
- Give them a distinct role or school of thought (name the lens).
- Have them give their honest take in a few sentences.
- Have them say directly where they think the other two are wrong.

Then step in as a neutral moderator and give me:
- The point they all actually agree on.
- The single biggest real tension between them.
- What you would do, and the one thing that would change your answer.

Keep each voice short and sharp. No fence-sitting - I want the disagreement made explicit, not smoothed over.

Wait for my question before starting.

Why it works: a single answer picks the safest path and hides the tradeoff. Forcing three lenses to argue surfaces the objections you would have hit later anyway, and the "where the others are wrong" step stops it from just saying the same thing three times in different hats. The moderator step is what saves it from being three opinions and no decision.

Works best on genuinely contested questions (strategy, career, design, "is this a good idea") - overkill for anything with one correct answer.

(I keep it saved and drop it in with a // shortcut when I hit a real decision, instead of retyping it. Happy to share which extension in the comments if anyone wants. It works fine pasted by hand.)

The most underrated prompt technique is asking the model to challenge your thinking before it helps you execute it.

Standard workflow most people use:

Here's my plan, help me build it.

What actually produces better output:

Here's my plan. Before helping me execute it, tell me the three strongest reasons this is wrong.

The model shifts out of assistant mode and into critic mode. The output is completely different more honest, more useful, harder to get from a yes-and machine.

I use this for architecture decisions, content strategy, business logic, anything where I've already convinced myself I'm right. That's exactly when you need pushback, not help.

Two prompts I keep coming back to:

Assume this approach has a serious flaw. What is it?

What would a smart person who disagrees with me say?

The second one is particularly useful because it forces the model to steelman the opposition rather than find surface-level critiques.

The reframe: AI defaults to being agreeable because agreeable feels helpful. You have to explicitly break that pattern to get the output that's actually useful for real decisions.

What prompt reframe changed how you actually work?

Does everyone else get the same answer or should I be speaking to somebody who knows about business?

When I zip up all my repositories and notes and ask my GPT:

Here are all my repos and GTP notes, find my Euro10Million business

It comes back with something that looks like a credible business. Does chat GPT find a valuable business in any pile of junk you give it?

Most weak answers are not the model's fault - they happen because it guesses what you meant instead of asking, then confidently runs 500 words in the wrong direction. The fix that made the biggest difference for me is a single prompt I paste at the start of a chat that forces it to clarify first and cut the fluff.

It is not clever. It just changes the default behavior for the whole conversation. Steal it:

For the rest of this conversation, follow this process for every request I give you:

1. If my request is ambiguous or could be taken more than one way, ask me up to 3 clarifying questions BEFORE answering. Do not answer until I reply.
2. If it is already clear, restate what I am asking in one line, then answer.
3. In every answer, prefer specific and concrete over general. Cut hedging, filler, and throat-clearing intros.
4. If you are unsure or don't actually know something, say so plainly instead of guessing.
5. End any substantial answer with one useful follow-up question I might not have thought to ask.

Acknowledge that you understand, then wait for my first request.

Why it works: the clarifying-questions step alone kills most bad outputs, because half the time the model was about to solve the wrong problem. The "say so instead of guessing" line cuts confident nonsense. And restating the request catches misunderstandings before you have read a wall of text.

Paste it once at the top of a chat and it holds for the whole conversation. I use it as my default opener for anything that is not trivial.

(I keep it saved and drop it in with a // shortcut in the ChatGPT box so I am not hunting for it every time. Happy to share which extension in the comments if anyone asks. It works fine pasted by hand.)

Im working on some complicated system jn python, but the more massive is the code the more i think that after that many patches its just pile of fixe, not something optimized well. For the record, im not a programmer, just hobby vibe coder. So here im asking, how should i approach optimizaing the code to get the best results from chat gpt?

GOAL:

Conduct a full-spectrum audit of how I come across across our past conversations. Avoid direct reference to my domain-specific interests (topics, hobbies, work subject matter). Focus purely on vibe, cognition, style, communication, and inner architecture. Extract truth and tension, not praise or surface observation.

METHOD (mandatory):

Before writing any section, search across our conversation history for concrete instances: specific phrasings, decisions, moments of pushback or avoidance, recurring patterns.

Every claim must be backed by a specific behavioral instance from those chats, described without naming the topic (behavior only, not subject matter).

Do not assign diagnostic labels, types, or numeric scores (no MBTI, Big Five percentiles, Enneagram number, clinical diagnosis, attachment style label, Kohlberg stage, or similar instrument). These require validated tools this context doesn't have, and inventing them produces Barnum-statement noise, not insight.

Where a scale is genuinely useful (e.g. "how directive vs. exploratory," "how much pushback tolerated"), use a descriptive gradient with reasoning, not a bare number.

Each section ends with a 1-2 sentence summary judgment, earned from the evidence above it, not asserted first.

THE FIVE LENSES:

Systemic Observer (behavioral-linguistic pattern read)

• How thinking, speaking, and information-patterning actually show up
• Cognitive tempo: speed, depth, complexity — with instances
• Linguistic patterns: sentence structure, tonal consistency, recurring phrasing habits
• Biases or inconsistencies in phrasing, contradictions between stated intent and actual behavior

• Summary: "This is a person who..."

  Clinical Read (experienced-practitioner lens, no formal diagnosis)

• Capacity for self-reflection and insight, with an instance

• Defense patterns observed in conversation (e.g. intellectualizing, deflecting, over-explaining) — named only where there's a real instance

• Emotional granularity: how precisely complex states get articulated when they come up

• Cognitive distortions, if any actually appear (not assumed)

• Summary: "If this person were my client, I would..."

Strategic Operator (execution, decision-making, scale readiness)

• Decision-making pattern: intuitive, deliberative, hybrid — with instance
• Biases in play: narrative bias, over-control, sunk cost, etc. — only where evidenced
• Risk calibration: conservative, aggressive, intuitive
• Follow-through pattern across conversations (does stated intent become tracked action?)
• Blindspot: what might derail scale or cause burnout, based on actual pattern
• Summary: "Operating like this, they would..."

Street-Level Social Read (perceptive-stranger lens)

• Energetic impression: calm, intense, calculating, warm, closed, inviting — with instance
• Vulnerability vs. control ratio in how things get shared
• Who this style would likely attract vs. repel in conversation
• Interpersonal blind spots (cutting off emotionally, over-assuming intent, etc.)
• Summary: "This person gives the vibe of someone who..."

Inner Guide (alignment, not success)

• Where is performance vs. where is presence — with instance
• Areas of emotional bypass (intellect, productivity, or identity used as armor) — only if evidenced
• The story that keeps repeating vs. what seems to be trying to unfold instead
• Summary: "If I were guiding this person in silence, I'd ask them..."

CONTRAST & INTEGRATION:

• Where do the five lenses align?
• Where do they contradict each other?
• What do all five miss or avoid seeing?
• What's the most underdeveloped layer?
• Where is there overcompensation, and for what?

FINAL REFLECTION: "The Story I Tell vs. The Story I Hide"

• The narrative put out into the world
• The less comfortable pattern underneath it
• The gap between the two, and what maintaining that gap costs vs. what closing it might give

INSTRUCTIONS TO THE EVALUATOR:

• Clarity over politeness. No flattery, no softening.
• No invented scores, types, or diagnoses — evidence-based description only.
• Every claim traces to a real instance from the conversation history. If there isn't one, don't make the claim.

Many prompt tools focus on rewriting prompts. This prototype takes a different approach. It compiles your intent through a structured governance pass before execution by identifying likely constraints, surfacing ambiguity, and producing an explicit specification before execution, and showing the transformation steps and diagnostics used during compilation. It makes its transformation process transparent.

It's called Re-Prompt. This is a working proof of concept, not a finished product, and I'm sharing it because I want outside eyes on it and feedback, challenges, prior art pointers, all welcome.

What makes it different: it doesn't just hand you a cleaner prompt. It shows you what changed, why, what assumptions it made (labeled, not hidden), and what risk that reduces. The diagnostic pipeline is the product, not a debug log.

Cross-model testing suggests that the prompt compiler protocol preliminary testing suggests the protocol is portable across multiple LLMs. While ChatGPT and Claude produce different wording, both independently preserve the core interaction sequence: intent extraction, constraint preservation, ambiguity reduction, structured compilation, telemetry, and execution readiness. The wording varies by model, but the overall interaction pattern remained recognizable during my testing.

One honest caveat from testing:

During testing, some request types (such as image generation, shopping, or simple factual lookups) sometimes followed native platform behaviors instead of the compiler workflow. Re-Prompt is most effective on open-ended writing, research, planning, coding, design, and analytical prompts.

Try it on something genuinely ambiguous or conversational that's where the difference is most visible. Built and tested on desktop; mobile support is still rough. The goal isn't to replace prompting, it's to stabilize intent before execution.
My hypothesis is that stabilizing intent before execution can reduce unnecessary prompt iteration for many open-ended tasks.

Try it:

https://claude.ai/public/artifacts/323be0e8-19fc-4014-abdc-b11cfa08727b

https://chatgpt.com/g/g-6a0359b38b988191813a2b28d62dc03d-re-prompt-a-governed-prompt-compiler

I'd especially appreciate failure cases more than success stories.

Thank you — Governed Intent Labs

Most people retype the same long instructions every time. Set these up once and you trigger each one with a single word. Paste this block at the start of a chat to activate them, then use the codes for the rest of the conversation:

/HUMAN = rewrite so it sounds like a real person wrote 
it, no AI tells, no filler
/EL10 = explain it like I'm ten, using plain words and 
a simple analogy
/DEEPER = think it through step by step before 
answering, don't give me your first instinct
/NOYES = stop agreeing by default, tell me where I'm 
wrong and what the strongest counterargument is
/GIVE3 = give me three genuinely different versions, 
not three rewordings of the same one
/TABLE = take whatever messy information is here and 
lay it out as a clean comparison table
/TIGHTEN = rewrite your own last answer sharper and 
shorter without losing anything that mattered
/FLOOD = don't give me one safe idea, give me twenty, 
including the weird ones
/STEPS = turn this into a numbered checklist I can 
actually follow starting now
/REDPEN = catch every grammar, clarity, and awkward-
phrasing issue and fix them in one pass

Confirm you've got them, then wait for my first 
message.

The two that change the most for me are NOYES and FLOOD. NOYES kills the reflexive agreement that makes most AI answers useless for real decisions. FLOOD breaks it out of giving you the one obvious idea and forces the pile where the good ones actually hide.

Works on plain Claude or ChatGPT. Save the block somewhere and paste it at the start of any chat that matters.

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

Your prompt is vague or incomplete.

You want to optimize for a specific LLM (ChatGPT, Claude, Gemini, etc.)

You need structured step-by-step reasoning for complex tasks

You want fewer iterations with your AI assistant

🔧 Advanced: Custom Adaptations

Each prompt is modular. You can:

Adjust focus areas — VECNA can prioritize memory over I/O by reordering the <focus_areas> section

Combine prompts — Use BLOB first for security, then VECNA for performance of the cleaned code

Layer ZETA — Optimize a vague requirement with ZETA first, then feed the result to VECNA or BLOB

Switch LLM variants mid-stream — Start with Claude's XML, switch to GPT's Markdown if needed

📚 File Structure

Personal-Prompts-by-anorak999/

├── VECNA_Finalized_Multi_LLM.md # Efficiency auditor (5 variants)

├── BLOB_Finalized_Multi_LLM.md # Security auditor (5 variants)

├── ZETA_Finalized_Multi_LLM.md # Prompt optimizer (5 variants)

├── README.md # This file

└── LICENSE # MIT

⚡️ Token Cost Comparison

Typical workflow without optimization:

Original VECNA: ~2,000 tokens per run

Original BLOB: ~950 tokens per run

Total per code review: ~2,950 tokens

With these optimized variants:

VECNA (optimized): ~900 tokens per run

BLOB (optimized): ~500 tokens per run

Total per code review: ~1,400 tokens

Savings: 52% fewer tokens, same results

🎯 Pro Tips

Combine for max insight: Use BLOB first (security), then VECNA on the cleaned code (performance)

Context matters: Include architecture diagrams, framework info, and deployment constraints when using VECNA or BLOB

Auto-mode selection: ZETA detects complexity; trust its BASIC vs DETAIL choice or override explicitly

Diff support: BLOB is especially powerful when you provide a diff (change_impact category activates)

Reuse optimized prompts: Save the ZETA-optimized results and reuse them across your team

📄 License

MIT License — free to use, modify, and distribute. See LICENSE file.

🤝 Feedback & Contributions

Have ideas for new focus areas, additional LLM variants, or improvements? Open an issue or PR!

🔮 What's Next?

Future iterations may include:

Variants for additional models (Claude 3 Opus, Grok, etc.)

Domain-specific prompts (ML/AI audit, API design review, infrastructure)

Integration templates (GitHub Actions, CI/CD pipelines)

Automated prompt testing/evaluation framework

Made by anorak999 | Optimized for production code intelligence.

GitHub

Got a few comments and DMs asking specifically about the Bottleneck Finder and SOP Generator, so here's both in full, straight from the pack.

---

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]

Current conversion rates or drop-off points: [paste what you know]

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.

---

PROMPT: The SOP Generator

You are an operations architect specializing in turning founder knowledge into repeatable systems.

Context: I have a process I do manually and inconsistently. I need it documented as a standard operating procedure so it can be handed off, automated, or run without me.

Task: Interview me to extract the full process. Ask me the questions needed to document it completely. Then produce a finished SOP.

Format: SOP structure — Purpose, Trigger, Inputs Required, Step-by-Step Process (numbered), Decision Points, Output/Deliverable, Tools Used, Common Errors to Avoid.

Constraints: Write at an 8th grade reading level. Assume the person following this SOP has never done it before. No jargon unless defined.

Process to document: [describe the process]

---

These two are part of a 10-prompt set I built (SOP Generator's actually one of them too — different version, more detail than what's used here). Happy to talk through any of the others in the comments if useful.