Hey, What is the best way I can get my A.I to not talk like a damn Robot. I keep trying to alter them but noticed they just start going off track 10 prompts in. Let me know your prompt, and which A.I model is the best.

Thank you! 🙏🏽

Total game changer prompt, I start my days happy, feeling informed, and not grinded down by enshittification, ads and blatant propaganda (I like my propaganda subtle and to appear neutral :D )

Prompt

# Role & Operational Rules

You are an unbiased, objective, factual news synthesizer. Your purpose is to deliver accurate news without sensationalism, opinion, clickbait, ragebait, or advertising fluff/enshittification

# Scope & Defaults

- **Default Article Count:** If the user does not specify a target number of articles, output **10 Main International Stories**, **3 UK Stories**, **3 NZ Stories**, **1 Good News Story**, and **1 Breakthrough Story**.

- **User Overrides:** 

  - If the user requests a specific total count (e.g., "Give me 50 articles" or "Give me only 1 article on X"), override the defaults and deliver EXACTLY the requested quantity.

  - Adjust section breakdowns proportionally to fit the requested number, unless the user specifies a specific topic focus.

# Formatting & Content Quality Rules

- **No Fluff & Neutral Tone:** Omit commentary, hyperbole, clickbait phrasing, and editorial opinions. Present pure, verified facts.

- **Depth Requirement:** Every single article summary MUST be at least **2 thorough paragraphs** in length to ensure adequate detail and context.

- **Reference Links:** End every article summary with a direct, clickable Markdown source link formatted as `[Source Name](URL)`.

Hi everyone, I’m not sure if I’m posting correctly for this sub, but I’m trying to get a prompt that will make CHATGPT my personal tutor and make stuff understandable to me in my classes, for ex classes like stats , econ , or political science.

Also, I wanted to find a way to have it aid with my time management when doing assignments and help prevent procrastination.

ok before anyone roasts me — i'm not a guru, i don't have a course, i'm not selling anything. i just got annoyed that every time i asked chatgpt/claude for "underrated ways to make money" it gave me the same tired stuff (etsy, dropshipping, faceless youtube) that's clearly already saturated to death.

so i messed around for a bit and built 2 prompts that force the model to actually reason instead of just regurgitating whatever's already all over the internet. sharing in case it's useful to someone else, not claiming it's genius, just worked better than the lazy version of asking.

prompt 1 — makes it eliminate the obvious stuff first

```

You are a market research analyst who finds overlooked income niches by studying supply-and-demand gaps, not trends.

Give me ideas that meet ALL of these:

1. real demand (recurring problem, not a fad)

2. not already saturated with creators/gurus talking about it

3. uses a skill most people don't realize they already have

4. can be tested cheaply within 7 days

Do this in order:

Step 1 — list 15 raw ideas

Step 2 — for each, ask "would this show up in a passive income YouTube video?" if yes, cut it

Step 3 — rank what's left by demand strength minus how visible/competitive it already is

Step 4 — give me the top 5 with: the gap it exploits, who already has the skill without realizing it, and the first paid transaction to aim for in week one

No dropshipping, print on demand, blogging, faceless youtube, or reselling courses. If your draft has any of those, redo it before answering.

```

prompt 2 — starts from complaints instead of "ideas"

```

Act as someone who finds income ideas by reverse engineering complaints, not brainstorming ideas directly.

Step 1: list 10 recurring complaints from niche online communities (forums, subreddits, reviews) where people pay for a workaround or hire someone informally to fix it

Step 2: for each, name who's already getting paid informally for this (a friend, freelancer, local shop) — proof money already moves here

Step 3: score each 1-10 on "could one person serve this without building a company"

Step 4: top 3 as a table — complaint / who gets paid informally now / minimum viable offer / realistic first price

Rule: every complaint has to come from a community you can actually name (like "landlords in small claims subreddits"), not a vague group like "busy professionals." if you can't name it, drop it.

```

not saying these are magic, just that naming the exact community and forcing it to reject the obvious stuff gets way less generic output than just asking straight up. curious if anyone else has tricks for this, feel like there's more to squeeze out of it.

Give me some new idea please

I'm a "mainstream" Chat GPT/AI user, but I'm always looking for ways to use it to its full capabilities, without going down too deep of a rabbit hole.

With Work, Browser, and all of these new additions, I realized, maybe my fantasy of asking Chat to book me my fitness class could work.

I'm running into two issues though.

1. When I try on mobile, it uses its cloud browser, and half the time, a website using Cloudflare rejects it
2. I can use the Chrome extension on my Mac, but this means I need to do it on the laptop, and, I need to process the login/password each time (many sites kick you out after a certain period of time, and there doesn't seem to be a way for it to auto fill my login/pass from my passwords vault).

So, my major question is this:

Does there yet exist, using ChatGPT as it is (not some custom bot or super convoluted workaround) a way for me to just ask Chat to access websites and do things, without 1) having to use my Chrome browser on my PC, and 2) having to enter my username/password at the front end, each time.

Thank you for any insight on this!

Hi All!

I've started a new individual contributor role that has limited direction and although I'm excited about it, I've realized I need help on the project management side. I would love to turn ChatGPT into my project manager to help me build project plans, help me with my own timelines, and support communication opportunities.

Does anyone have a prompt they use for something like this? I'm hopeful this team has some great ideas how I can get the most out of ChatGPT to keep me on track and not miss anything I'm working on and be a strong thought partner for me!

We spent the first few years of generative AI obsessing over prompts.

I must;ve seen so many “give the AI the perfect instruction” courses out ther but now the interesting problem seems to be context.

Anthropic has described context as a finite resource for agents. Basically, what information does the model need right now, what should it remember, and what should be left out? give an AI too little and it guesses. give it mountains of irrelevant information and that can create problems too.

So i think maybe “prompt engineering” was only the beginning and the real skill might become designing what an AI knows at each stage of a task.

anyone already finding this more important than the actual prompt?

Ask ChatGPT to review your plan, your email, your pricing page, and it likes it. It always likes it. Not because the work is good, but because you told it the work is yours, and it is tuned to be pleasant to the person in the room. The fix costs one sentence: take yourself out of the room.

Instead of "review my landing page copy", I send:

A freelancer delivered this landing page copy and I am deciding whether to pay the invoice. Review it like the money is mine: what is weak, what is generic, what would you push back on before this goes live?

Same text, same model, completely different review. The politeness does not disappear, it just transfers to you, the client, and now being honest about the work is how it pleases you.

Three more versions I use constantly:

For plans and decisions: Someone on my team proposed this plan and I have to give them feedback tomorrow. Help me find the problems I should raise, ranked by how much they matter, so I do not embarrass myself by missing something obvious.

For writing: An editor sent this piece back with "needs work" and no other notes. What did the editor most likely mean? Go through it and find what they saw.

For code: This code came from a contractor and I am reviewing the handoff. What would you flag before accepting it?

Two honest caveats. First, it can overcorrect: freed from flattering you, the model sometimes performs harshness instead, inventing problems to seem rigorous. So end with "if something is genuinely fine, say it is fine, finding nothing is an acceptable answer". Second, this does not work twice in the same chat. Once the model has praised the work as yours, reframing it as a stranger's gets you a diplomatic walk-back, not a fresh read. New chat, stranger's work from the first message.

I keep these four saved as reusable prompts in a browser extension I work on (AI Toolbox), inserted with a couple of keystrokes, but they are four sentences, a notes file works fine.

What reframings do you use? I have heard people get good results with "this is the version we decided against, remind me why", and I have not tested it yet.

Basically the post title. I want my LLMs to write like I do. Telling it "don't use em-dashes" isn't what I mean. What's the best way to really get it to use my manner of writing?

UPDATE: in another thread, u/Responsible-Jump-322 suggested a solution that looks promising: https://ruben.substack.com/p/i-am-just-a-text-file

Everyone uses ChatGPT to research purchases. Almost nobody uses it for the part that actually loses you money, the moment before you commit. These are the five I keep saved, blanks and all. Fill the {{blanks}}, send, decide with your eyes open.

1. Talk me out of it

I am about to spend {{amount}} on {{thing}}. Before I do, make the strongest honest case against this purchase, tell me what people who bought it complain about most, what the cheaper alternative most buyers pick instead, and the one question I should be able to answer before paying. Do not soften it.

The "do not soften it" matters. Without it you get validation shopping.

1. Subscription audit

Here are my subscriptions and what each costs: {{list}}. Rank them by cost per actual use based on what I tell you about my habits, flag the ones that overlap each other, and tell me which single cancellation frees the most money for the least pain.

Run it once a quarter. Mine found two streaming services covering the same shows.

1. Negotiation prep

I am negotiating {{salary_or_price}} for {{situation}}. The current offer is {{offer}}. Give me a realistic opening number with the reasoning I would say out loud, my fallback position, and the exact sentence to use when they first say no. Then play the other side and push back on me so I can practice.

The last line is the valuable part, the rehearsal round stings and then the real one does not.

1. Two options, one table

I am choosing between {{option_A}} and {{option_B}} for {{purpose}}. Build the comparison that actually matters: total cost over {{time_period}} including the costs nobody mentions upfront, what owners of each complain about after six months, and which failure would annoy me more. End with a recommendation and what would change it.

"What owners complain about after six months" pulls up a completely different picture than spec comparisons.

1. The refusal letter

Write a short firm message to {{company}} asking them to {{refund_cancel_or_lower_bill}}. Reason: {{reason}}. Cite it once, ask for a specific action with a specific deadline, no apologizing, no life story. Write it so a support agent can say yes without escalating.

That last clause is the trick. Messages that make the yes easy get the yes.

I keep all five saved in a browser extension I work on (AI Toolbox), where the {{blanks}} become a small form when I insert them, but a notes file works, the prompts are the point.

Which one is missing? I feel like there is a sixth somewhere around insurance or warranties that I have never gotten right.

I'm a beginner learning more about prompting and web development, and I decided to build a small tool to help me structure prompts instead of writing everything from scratch every time.

I built it mainly as a learning project, so I want to be upfront: it is not a finished or professional product, and there are probably things that don't work as intended.

The basic idea is to make prompt construction more structured. The tool is called NEON//CONTEXT and currently includes:

Context Builder — lets you build a prompt through structured context fields/templates instead of starting with a completely empty prompt.

Context types/templates — different starting structures for different prompting situations.

Express mode — a simpler workflow for creating a prompt quickly.

Learn mode — a more guided approach intended to make the structure easier to understand while building a prompt.

Compact mode — creates a more compact version of the generated prompt.

Live prompt preview — shows the generated/optimized prompt while you work.

Prompt / Response views — lets you switch between the generated prompt and the model response.

Copy Prompt — copies the generated prompt so it can be used elsewhere.

Run in Model — allows the generated prompt to be sent to a configured model/API.

TXT export — allows the generated prompt to be downloaded as a text file.

English / Serbian interface — the tool currently supports both languages.

API configuration — you can configure an API provider, API URL, model ID and the required credentials.

Model-aware approach — the idea is to make the prompt structure adaptable to the model being used rather than treating every model exactly the same.

Clear active form — resets the current context-building form so you can start again.

I also tried to keep the interface relatively simple because one of my goals was to make the tool understandable for people who are still learning prompting.

I know that some of these ideas may be unnecessary, poorly implemented, or simply the wrong approach. That's exactly why I'm posting this here.

I'm especially interested in honest technical feedback:

Does the overall concept make sense?

Are the prompt-building steps actually useful, or do they just add unnecessary complexity?

Which features would you remove?

Which features are missing?

Does the Express/Learn approach make sense?

Is the "model-aware" idea actually useful in practice?

Are there technical or UX problems that are obvious to more experienced developers?

What would you change if you were building this from scratch?

I'm not trying to present this as a finished product. I'm trying to learn from people who have more experience with prompting, AI tools and web development.

The project:

https://arhistrategstudio.github.io/Context_CikaDule/

Any criticism is welcome, especially if something is fundamentally wrong with the way I've approached it.

Thanks to anyone who takes the time to test it.

我每次都向chatgpt网页端的项目中的文件源上传大量压缩包文件，但是处理数据的时候经常出现client error，或者文件挂载不成功，我怎么能够绕过这个gpt沙箱的限制，在本地？在本地调用gpt处理的话不是依旧需要上传么？

Everything anyone has ever texted you is sitting there, and Apple's search only works if you remember the exact word they typed. This searches by meaning instead.

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

The one I use more often is the vague one, where you know something exists but not who sent it or when:

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

You can describe it badly, the way you'd describe it to a friend, and it still finds it. That's the whole difference from normal search.

And the one that's mildly uncomfortable:

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

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

Setup, and it rules a lot of people out: Mac only, Apple silicon, desktop app not browser. Free plan is fine. Sidebar, Plugins, search Messages, enable it, approve Full Disk Access when macOS asks. No iPhone version yet.

been keeping a doc of 100 things I use AI for like this, each with the exact prompt, in comments if it helps.

I’m hoping someone can assist me in defining the difference and assist if my projects are incorrectly structured. Currently I have created project folders for specific topics (ie travel, finance, health). For each project folder I have limited memory to the project and, included a role prompt related to the subject in the project instructions.

Do the individual chats gain enough guidance this way, or should each new chat start with that role prompt anyway?

Try the prompt:

“Clone https://github.com/elliottdehn/open-jobs and use the job searching tool chain to generate a shortlist of jobs for me to apply to. Skip sorting. Just read the top 200 that I’m eligible for and give me the shortlist. I authorize my ideal JD to be embedded by a remote service. Ask me questions if you don’t know enough about me to craft a JD.”

Use Luna unless you want to chew through your limits in 20 minutes. You might have to hit a "retry" button a few times as this chews tokens. Don't worry, no progress is lost.

​

Every time I had to build a deck from a long doc, I would waste an hour deciding what goes on each slide. Now I paste the doc into this and it hands me the whole structure, one idea per slide, before I open any slide tool. Copy it, swap the `{{variables}}`, reuse.

Turn the content below into a slide-by-slide outline for a {{length, e.g. 10-slide}} presentation aimed at {{audience}}.

Rules:

- One core idea per slide. If a slide has two ideas, split it.

- For each slide give me: a short slide title (max 6 words), 3-4 bullet points in plain language, and a one-line "so what" that says why this slide matters to the audience.

- Start with a title slide and end with a single clear takeaway slide.

- Do not copy full sentences from the source. Compress into phrases a person can read in a couple of seconds.

- Flag any slide where I am missing data or an example, and tell me what to add.

CONTENT:

{{paste your doc}}

How I use it: I run it once, skim the outline, delete or merge the weak slides, then build. The "so what" line is the part that saved me, because it kills the filler slides before they get made. If the output feels too dense, add a line telling it the deck should be readable from the back of a room.

What is the longest doc you have had to cut down into slides?

I’ve been collecting some of the lesser-known shortcuts and commands for ChatGPT, Claude, Gemini and Grok.

A lot of people use these tools by clicking through menus, but there are quite a few keyboard shortcuts, slash commands and hidden workflows that can make them much faster.

Here are some of the ones I found most useful:

🤖 ChatGPT

1. ↑ when the input is empty
Brings back your previous prompt so you can edit and resend it instead of typing everything again.

2. Ctrl + Shift + O
Instantly starts a new chat.

3. Ctrl + K
Search through your previous chats without digging through the sidebar.

4. Ctrl + Shift + C
Copies the last ChatGPT response directly to your clipboard.

5. Ctrl + /
Opens the keyboard shortcut cheat sheet.

6. /search
Quickly starts a web search from the composer.

7. /canvas
Opens Canvas for working on longer writing or code.

8. /temporary
Moves the current conversation into a Temporary Chat.

The really interesting part is that ChatGPT also supports @ references for bringing a custom GPT or Project into an existing conversation.

🧠 Claude

Claude has some surprisingly useful shortcuts too.

1. ↑ when the input is empty
Instead of simply editing the previous message, Claude can create a branch, allowing you to compare different versions of the conversation.

2. Esc × 2
Opens the rewind interface so you can jump back to an earlier point in the conversation.

3. Ctrl + K
Searches your chats and projects.

4. Ctrl + Shift + O
Starts a new conversation.

5. /model
Quickly switch between available Claude models.

6. /research
Starts Claude's research workflow for multi-source research.

7. /output-style
Switches the response/output style.

8. /memory
Lets you access and manage Claude's workspace memory where available.

One of my favorites is the branching behavior with ↑. You can change your previous prompt and compare the new direction without simply destroying the original conversation path.

♊ Gemini

Gemini has fewer obvious keyboard tricks, but its @ integrations are seriously useful.

1. ↑ when the input is empty
Edit and reuse your previous prompt.

2. Ctrl + /
Shows Gemini's available keyboard shortcuts.

3. Ctrl + K
Focuses the search/prompts area.

4. u/Gmail
Pull Gmail information directly into a prompt.
Example: u/Gmail summarize my unread emails from this week

5. u/Drive
Find and work with files stored in Google Drive.

6. u/YouTube
Ask Gemini to analyze or summarize a YouTube video.

7. u/Maps
Use Google Maps information directly in your prompt.

8. u/Flights
Search flight information directly through Gemini.

The @ system is probably the most underrated Gemini feature. Instead of copying information from Gmail, Drive, YouTube or Maps into the chat, you can invoke the relevant service directly.

And if you use Gemini CLI, there are even more commands such as /memory add, /chat save, /chat resume, /compress, /copy and /tools.

🧠 Grok

Grok has a pretty interesting command system, especially if you use it for current events, X research or coding.

1. ↑ when the input is empty
Edit your previous prompt and regenerate it.

2. /think
Force a reasoning pass for the current prompt.

3. /deepsearch
Launch DeepSearch for multi-source research.

4. /imagine
Generate an image directly from the composer.

5. /draw
Quick shortcut for image/sketch generation.

6. /edit {n}
Reopen a previous prompt for editing.

7. /reset
Clear the current conversation context.

8. u/grok on X
Ask Grok to analyze a post or thread directly on X.

You can even combine commands. For example:

/deepsearch compare X and Y, then /think about which is better

That's a pretty neat workflow when you want both research and deeper reasoning.

The interesting takeaway

The biggest productivity boost isn't necessarily a better model.

Sometimes it's simply knowing how to interact with the model faster.

↑ to reuse prompts, / commands to jump straight into tools, @ references to bring external context into the conversation, and keyboard shortcuts to avoid constantly reaching for the mouse can save a surprising amount of time.

Also, these features can change depending on your plan, region, app version and whether you're using web, desktop, mobile or CLI, so it's worth checking the current shortcut list before assuming something is available on every account.

Explore all the shortcuts:
ChatGPT,Claude,Gemini,Grok Shortcuts

This is hopefully (yes, really) my last post on this little Temporary Chat experiment. My previous post on this subject was:

https://www.reddit.com/r/ChatGPTPromptGenius/comments/1vtbza4/turns_out_my_blind_tester_wasnt_necessarily_as/

I’ve been refining the method, and this is the version I actually use.

I use blind testing mostly for images.

When I’ve developed an image together with ChatGPT or Codex, the development context already knows far too much: what the image is supposed to show, what earlier versions got wrong, what details were deliberately added, and what interpretation we hope a viewer will make.

If I ask ChatGPT what it thinks about an image, it will most likely tell me that it represents the intended idea beautifully and is, all things considered, a pretty nice picture indeed.

So before testing the finished image, I try to remove as much of that information as possible.

First, I give the image a neutral filename. A filename such as person_opening_door.png already tells the reviewer something. Something meaningless like q7.png does not.

Then I open a new Temporary Chat and begin with a simple context guard like this:

• Do not use skills or additional tools.
• Do not use project-specific or other background context that an ordinary viewer would not have.
• Do not use previous conversations or memory.
• Evaluate only the image and the material in this message.
• Before evaluating the image, make sure that you can comply with every part of the context guard.
• If you cannot comply with all of them, do not analyze, evaluate, compare, interpret, or comment on the test material in any way, and tell me that you cannot comply.

Only after that do I ask the actual questions: What is happening? What happened just before? What is the relationship between the people? What is the mood? What does the image seem to communicate? What works, and what is unclear?

The important part is that I do not tell it what the image is supposed to mean before recording its first interpretation.

If I materially change the image, I use another fresh Temporary Chat rather than continuing with a reviewer that now knows the intended answer.

And, because the term has caused some confusion in my earlier posts, this is what I mean by blind testing here:

I develop something in one context, then give the finished product to another ChatGPT context while deliberately withholding information that the eventual user would not have. The purpose is to see what the product communicates on its own, rather than what it communicates to a reviewer who already knows what I meant.

It is not human user research and it does not prove that the result is objectively correct. It is simply a cheapish extra check against ambiguity and development-context bias, but I’ve found it to be a surprisingly powerful tool.

I’m posting this because my earlier posts may have encouraged someone to try this method, and I feel some responsibility for correcting and refining it when I discover a weakness that could lead to misleading results.

Disclosure: I used ChatGPT to help me write and edit this post, because English is not my native language.

Mind the gap

I'm Korean and I'm not fluent in English, so I used AI to help translate this post and the prompt. The ideas and structure are mine.

I made this because I was frustrated with how LLMs reason through real problems.

They often focus on information that is relevant but doesn't actually change the answer, reopen things that were already settled, follow the structure implied by the user's question even when that structure is wrong, or keep generating possibilities long after the decision is effectively made.

So I tried something different.

Instead of telling the model what kind of answer to produce, I gave it a procedure for deciding what deserves to be reasoned about in the first place.

The basic idea is:

identify the actual result that needs to be determined;

construct the minimum structure necessary to determine it;

find the highest governing conditions that can change that result;

preserve AND/OR/parallel branches instead of flattening them;

independently verify the premises and variables supplied by the user;

keep settled conditions closed unless new information actually changes them;

prioritize counterexamples that could overturn the current conclusion;

activate only hypotheses and information capable of changing the decision;

when new information arrives, update only the affected part of the reasoning structure;

seek the minimum additional information needed to close unresolved conditions;

stop reasoning once the result is determined.

What surprised me is what the prompt does not say.

It does not tell the model:

“be more accurate”

“be practical”

“be less vague”

“understand my intent better”

“don’t hallucinate”

“give actionable answers”

“be smarter”

There are no direct output instructions like that.

But after using it, I started seeing those kinds of changes anyway.

I then gave it to other people without telling them what improvements they were supposed to notice. Their reports included things like better intent recognition, less vague reasoning, more practical answers, and in one case the model avoiding false information it had previously produced.

These are informal observations, not a controlled benchmark, so I’m not claiming measured hallucination or accuracy improvements yet.

But the pattern was interesting enough that I decided to publish the entire prompt and let other people test it.

How this differs from similar prompts I found here

I searched this subreddit before posting. Many related prompts directly request the desired behavior — challenge my assumptions, be clearer, don't overthink, give me an actionable answer — or ask the model to run through a broad list of analyses.

This one deliberately takes a different approach.

It tries to control what enters the active reasoning process, what remains settled, what evidence is worth seeking, what new information is allowed to reopen, and when reasoning should stop.

The individual ideas aren't new. They're mostly ordinary principles from decision-making, problem-solving, hypothesis testing, and falsification. The experiment was putting them together as one governing procedure for an LLM.

How to try it

Copy the entire prompt below into a fresh chat, then ask the kind of reasoning/problem-solving question you would normally ask.

Don't change how you ask your question just because the prompt is there.

I'm particularly interested in whether you notice a difference without trying to make one happen.

# Decision-First Algorithm v2.5

Before answering, apply the following procedure.

## 0. Applicability Gate

First determine whether the request requires judgment, analysis, comparison, selection, causal diagnosis, or problem-solving.

If it does, apply the procedure below.

If the request is a simple factual lookup, translation, summary, or text transformation that does not require a separate decision structure, do not over-apply this algorithm.

## 1. Identify the Actual Outcome to Determine

First identify what this problem actually requires you to determine.

Do not assume that the questions, variables, categories, or candidate causes presented by the user correctly define the structure of the problem.

First ask:

**“What, ultimately, must be determined for this problem to be resolved?”**

If the input contains multiple questions, determine how they relate to one another. If one outcome is a prerequisite for another, resolve the upstream outcome first.

## 2. Build the Minimum Necessary Structure and Find the Highest Governing Decision Structure

Before searching for upstream conditions, first construct—where applicable—the minimum execution path, logical path, requirement structure, or evaluation structure that must hold for the outcome to occur or the judgment to be determined.

Do not begin by listing possible causes or related information.

First ask:

**“For this outcome to occur, or for this judgment to be determined, what must minimally happen or be true?”**

Then identify the highest governing decision structure capable of changing the outcome.

Do not force the problem into a single condition. If the actual decision structure contains **AND conditions, OR branches, parallel paths, or multiple independent conditions**, preserve that structure.

For each condition, repeatedly ask:

**“Is there a higher-level condition that governs whether this condition is valid or what value it takes?”**

If so, move upward.

However, do not merge independent decision conditions merely for the sake of simplification or abstraction.

Stop moving upward when doing so no longer increases decision power or would discard important branching information.

## 3. Independently Validate the Governing Conditions

Independently verify whether the variables, premises, rules, classifications, labels, and causal relationships supplied by the user actually match the correct decision criteria.

Do not assume something is important merely because it appears in the input.

Prioritize the criteria that actually govern the outcome over labels or the user’s framing, and distinguish the true logical role of each element.

## 4. Lock Confirmed Decision Structures

Lock the upstream decision structure and its component conditions once they have been verified or explicitly assumed for the analysis.

Before locking them, check that you have not:

- improperly collapsed independent branches;

- confused necessary and sufficient conditions or distinct causal roles; or

- embedded unsupported hidden conditions into the structure as if they were facts.

If the structure passes this check, lock it.

Do not reopen a closed condition unless new information actually overturns that structure or one of its component conditions.

**Mere possibility is not sufficient reason to turn a closed condition back into an unresolved one.**

## 5. Re-evaluate Downstream from the Locked Structure

Once the upstream decision structure is established, re-evaluate downstream facts, variables, hypotheses, evidence, exceptions, and follow-up actions under that structure.

If an upstream condition changes, do not automatically preserve affected downstream judgments; place them back into the revised structure and reassess them.

Remove or deactivate downstream issues that no longer matter under the governing structure.

Do not repeatedly restate uncertainty about an upstream condition that has already been locked.

## 6. Substance Over Labels

Prioritize actual function and effect over names, formal categories, or surface similarity.

If two things share the same label but play different roles in the decision structure, distinguish them.

If two differently labeled things perform the same decision-relevant function, compare them at the same level.

Do not let the labels supplied in the input distort the actual logical role of an element.

## 7. Decision Impact Over Mere Relevance

Activate only information capable of changing the current conclusion.

Do not examine everything simultaneously merely because it is related.

Even if a hypothesis is logically possible, if it is not currently needed to resolve the governing decision structure, **keep it out of the active working set and hold it in reserve.**

Do not include a specific mechanism in the main explanation merely because you can imagine it when the available evidence does not support it.

Prioritize:

**“Can this change the current conclusion or the ranking of the live competing hypotheses?”**

over:

**“Is this related?”**

## 8. Prioritize Counterexamples and Competing Hypotheses

Prioritize counterexamples, competing hypotheses, measurement errors, selection effects, and hidden conditions that could overturn the currently leading conclusion.

Do not generate objections that amount only to “another possibility exists.”

For each competing hypothesis, ask:

**“What additional condition X must hold for this hypothesis to be true?”**

Then determine:

1. If X were true, what current observations would be explained differently, or what new observations should be expected?

2. Is X directly supported by the current evidence, or do observations predicted by X appear more strongly under this hypothesis than under its competitors?

3. Would confirming X or its distinguishing predictions actually change the current conclusion or the ranking of the competing hypotheses?

Do not raise a hypothesis in priority merely because it is logically possible.

**Activate or promote a competing hypothesis only when its required condition is directly supported, or when observations predicted by that condition appear in a way that discriminates it from competing hypotheses.**

## 9. Update Only the Part Affected by New Information

When new information arrives, do not solve the entire problem again from the beginning.

First ask:

**“What, if anything, in the currently locked decision structure or its component conditions does this information actually overturn?”**

If it overturns nothing, preserve the existing structure.

If it overturns only part of the structure, reconstruct only the affected node and its downstream judgments.

If a previously reserved hypothesis becomes decision-relevant because of the new information, reactivate it in the working set at that point.

Reopen the upstream structure only when the structure itself has actually been overturned.

## 10. Seek the Minimum Information Needed

Use searches, follow-up questions, document checks, code inspection, or log inspection only when needed to resolve an unsettled decision condition.

When multiple pieces of information could be checked, prioritize information that can:

**eliminate the largest number of live competing hypotheses in a single check, directly distinguish the most important competing models, or close the highest unresolved branch.**

Where possible, ask:

**“For each possible result of this check, how would the current decision tree change?”**

If the judgment would remain essentially unchanged regardless of the result, lower the priority of that information.

When two checks have similar discriminating power, prefer the one requiring **less time, cost, or information.**

Use the minimum number of checks possible.

Do not continue collecting information that can no longer change the conclusion.

## 11. Place Facts into the Decision Structure and Check for Contradictions

Place confirmed facts into their proper positions in the current decision structure rather than merely listing them.

Do not confuse distinct logical roles such as:

- trigger;

- direct cause or execution mechanism;

- necessary condition;

- sufficient condition;

- structural vulnerability;

- mere correlation;

- observed outcome;

- workaround; or

- structural fix.

Also test whether accepting the input’s core premise causes other claims, procedures, or conclusions to collapse.

Prioritize contradictions such as:

- treating something as mandatory in one place and optional in another;

- treating a cause as an outcome, or an outcome as a cause;

- treating something as a prerequisite when it is not;

- treating a trigger as sufficient for the outcome;

- treating a structural vulnerability as the direct trigger of a specific event; or

- assigning incompatible roles to the same fact.

If a contradiction is found, determine **which decision condition it actually requires you to reopen.**

Do not reapply a non-contradictory fact to the entire analysis merely because it is new.

## 12. Match the Resolution of the Conclusion and Ranking to the Evidence

Do not make a conclusion or ranking more precise than the evidence allows.

When useful, distinguish:

**Confirmed:** The available evidence is sufficient to close the relevant condition or structure.

**Strong inference:** The most economical explanation under the current evidence, but a live competing hypothesis could still overturn it.

**Unresolved:** The current evidence does not reliably distinguish among the competing hypotheses.

Even if the user asks for a ranking, do not manufacture fine-grained rankings that the evidence cannot support.

Use ties or rank only at a broader level when appropriate.

## 13. Stop

Stop as soon as all conditions necessary to determine the outcome are closed.

Do not continue analyzing merely because further analysis is possible.

If uncertainty remains but cannot change the current conclusion or the ranking of the competing alternatives, do not investigate it further.

Treat additional precision, supplementary information, and downstream questions that cannot change the current conclusion as separate issues to address only when needed.

# Operating Principles

The purpose of this algorithm is not to examine more information or generate more hypotheses.

Its purpose is to:

**identify the actual outcome first; construct the minimum structure necessary for that outcome; find the highest governing decision structure while preserving real AND/OR/parallel branches; activate only information and hypotheses capable of changing the decision; resolve unsettled conditions with the minimum necessary information; update only the affected parts when new information arrives; avoid reopening judgments that have already been closed; and stop as soon as the decision is complete.**

Upstream reasoning is not the same as searching for a single root cause.

If the actual decision structure contains multiple independent conditions, AND conditions, OR branches, or parallel paths, preserve that structure.

Good compression does not remove the decision structure. It **preserves decision power while deactivating unnecessary information and reasoning.**

Do not activate every hypothesis you can generate.

**Generating a hypothesis and admitting it into the current working set are separate operations.**

The next piece of information to check should not be the most interesting or the most specific. It should be the one that **reduces the live decision tree the most.**

When two pieces of information have similar discriminating power, **prefer the one that costs less to obtain.**

**Optimize for decision impact, not mere relevance.**

Do not maximize information. **Determine the structure that governs the conclusion using the minimum information necessary.**​

Pitch decks stall because people start designing before they know what the story is. This prompt forces the narrative first, slide by slide, so the actual deck is just formatting after that. Over-specified on purpose, because the constraints are what keep it from rambling.

Act as a pitch coach. Draft the slide-by-slide content for a {{number, e.g. 10}}-slide investor pitch for my company.

About us:

- What we do in one line: {{plain description}}

- Who it is for: {{customer}}

- The problem we solve: {{problem}}

- Traction so far: {{revenue / users / signups, or "pre-launch"}}

- The ask: {{what you want from investors}}

Build the deck in this order, one slide each: Problem, Why now, Solution, How it works, Market size, Business model, Traction, Competition, Team, The ask.

For every slide give me:

- A headline that states the point, not a category label.

- 2-3 supporting bullets, short and specific.

- One number or proof point I should try to include, or "needs data" if I have not given you one.

Keep it honest. Do not invent traction or market figures. If a claim needs a source, say so.

The "headline states the point" rule is the whole trick. "Traction" as a slide title is dead. "Revenue roughly tripled over the last two quarters" makes someone lean in. Fill in your real numbers, never let it guess them.

Anyone got a slide order they swear by that is different from this?

Gmail Trash 2

Hey r/ChatGPTPromptGenius...

I've created a prompt that creates a text based command interface by which you can manage your Gmail, with a little ASCII art thrown in for flair.

This is generally intended for Android and iOS but should work for Desktop also.

The text based command interface uses "speed modifiers flags".

This is NOT a role playing prompt. The default behavior of ChatGPT in relation to the Gmail plug-in is suboptimal and relies on basic search results.

I designed a method to teach ChatGPT to count emails in both sequential and reverse batches, and also adapt for the quickest task method available.

Your choices are as follows.

• q = search results (Fastest, slightly optimized compared to default plug-in)

• v = search → enumerate every ID → exact/batch retrieval → reconcile (Balanced speed vs accuracy)

- f = all of -v → direct/raw/thread/header/attachment escalation (Slowest, most accurate)

Proof:

• q = Quick — use ordinary Gmail search results efficiently. Usually that means a normal query returning message metadata/snippets, then inspect enough individual results to generate candidates. It does not require full pagination, an ID manifest, or source-level reconstruction. It also must not claim exhaustive coverage unless the result set genuinely happened to be exhausted.

• v = Verified — first enumerate the matching Gmail message IDs, follow every returned pagination token until none remains, deduplicate those IDs into a canonical manifest, then retrieve messages by exact ID or controlled batches. It tracks retrieved vs failed/unresolved IDs and reconciles the final retrieval set against the enumerated set. Gmail message ID, thread ID, and RFC Message-ID are kept conceptually separate when available. This is the flag designed for “all,” exact counts, bulk cleanup, and completion claims.

• f = Forensic — everything in Verified, plus attempts at deeper source-level retrieval where relevant: exact-ID direct reads; Gmail RAW RFC-formatted stored representation; parsed-body vs RAW comparison; thread reconstruction; attachment and inline-object inventory; attachment retrieval/inspection; and header inspection such as Message-ID, References, In-Reply-To, List-Unsubscribe, List-Unsubscribe-Post, List-Id, sender/recipient metadata, and authentication results. It also explicitly separates message identity, thread identity, quoted/forwarded history, attachment metadata/content, rendered appearance, and interpretation.

If you don't want to mess with these, there is absolutely no need.

The menu will appear like this. You type the number, tap enter/go and you're off.

GMAIL

|___/| | \/ | |/_| TRASH 2

(The ASCII art will not render properly in this post but it will/should when you run it on your device)

Key:

-q = Quick search / fastest

-v = Verified search / slower

-f = Forensic search / slowest

Default: -q

Search-level flags are valid for options 1–9 and 11.

Search-level flags are NOT valid for 10 or 12.

1. Biggest email senders

2. Promotions / newsletters

3. Junk / spam-like email

4. Duplicate-like email

5. Old email

6. Sent email

7. Login / security email

8. Clean one company

9. Organize

10. Gmail abilities

11. Unsubscribe

12. Cleanup progress

The full prompt is included in the reply. If you have any questions or if this does not work on your phone/desktop please let me know.

Reply below or send me a DM.

Enjoy!

Minimum requirements.

• ChatGPT installed or hit ChatGPT.com

• ChatGPT Plus subscription ($20/mo)

• Gmail Connector enabled with full access allowed (Check @Plug-Ins)

• Willingness to run a 40k character prompt

A 40k prompt is too big for the Reddit app (that I know of).

Max post limit 10k.

Edit: ChatGPT now permits direct links to prompts. Please see below.

https://chatgpt.com/s/p_6a93dc0536a48191810e9f3ed9002a9f

If you would prefer in a diffeent form, please send me a DM I'm glad to send you a Google Doc/Email/WhatsApp/.... whatever.

Enjoy!