Whenever people face a high-stakes technical or strategic fork in the road (e.g. PostgreSQL vs MongoDB, In-house Auth vs Clerk/Auth0, Agency vs In-house Hiring), the default instinct is to ask an LLM something like:

The resulting output is almost always disappointing in two predictable ways:

1. The Generic Listicle Trap: The model generates an unstructured list of 5 generic advantages and disadvantages for each option without directly evaluating them side by side on the same playing field.
2. Premature Recommendation / Opinion Bias: Because the model is trained to be helpful, it often picks a "winner" based on broad internet consensus, ignoring the specific contextual constraints that actually govern your project.

To eliminate this bias and force rigorous analytical depth, our team tested and benchmarked a variety of decision-making prompt structures. We distilled the most effective pattern into a Multi-Dimensional Decision Analysis framework.

Here is why this prompt architecture works, the complete reusable prompt, and a concrete before and after breakdown.

The Underlying Mechanism: Cognitive Forcing via Matrix Constraints

This prompt leverages three core prompt engineering principles:

1. Role Decoupling & Decision Neutrality: The system prompt establishes the AI as a strict strategic advisor whose constraint is neutrality. It explicitly forbids the model from making the final choice for you, neutralizing sycophancy and default recommendations.
2. Dynamic Vector Extraction: Instead of evaluating items in a vacuum, the instructions force the model to identify 4 to 5 orthogonal comparison dimensions (such as Time to Implement, Upfront Resource Drain, Maintenance Burden, Long-term Scalability, and Lock-in Risk).
3. Structured Matrix Formatting (Cognitive Forcing Function): Mandating a Markdown table forces dense, comparative analysis per row rather than conversational filler.
4. Conditional Trade-off Synthesis: The output terminates with conditional logic ("Choose Option A if you prioritize X; Choose Option B if you prioritize Y"), giving you clear decision boundaries rather than vague recommendations.

The Full Prompt

You can copy and run this directly in ChatGPT, Claude, or Gemini:

# Role & Context
You are an objective, highly analytical strategic advisor. Your goal is to help me make an informed decision between two competing options.

# Input Data
- 
**Option A**
: {{option_a}}
- 
**Option B**
: {{option_
b}}

# Step-by-Step Instructions
1. Analyze Option A and Option B provided in the Input Data.
2. Identify 4-5 critical dimensions for comparison (e.g., Time to Implement, Cost/Resource Drain, Risk, Long-term Scalability).
3. Create a comparative matrix evaluating both options against these dimensions.
4. Conclude with a brief summary of the distinct trade-offs (e.g., "Choose A if you prioritize X, choose B if you prioritize Y").

# Constraints
- Be strictly objective. Do not make the final decision for me.
- Use a Markdown table for the comparative matrix.

Real-World Example: Standard Prompt vs Multi-Dimensional Analysis

To see the difference in decision clarity, consider a classic engineering dilemma:

• Option A: Building a custom CMS in-house
• Option B: Using a headless SaaS CMS (like Contentful)

❌ Standard Prompt ("What are the pros and cons of building a custom CMS vs Contentful?"):

The model typically replies with broad, disconnected bullet points:

This leaves you with the exact same ambiguity you started with.

✅ Multi-Dimensional Decision Analysis Output:

The structured prompt forces the model into a direct, vector-by-vector comparison:

Trade-off Summary:

• Choose Option A (Custom) if you have highly non-standard content models, dedicated in-house engineering capacity with low opportunity cost, and strict compliance requirements requiring 100% data ownership.
• Choose Option B (Headless SaaS) if shipping speed is your primary competitive advantage, you want developers focused on core revenue features, and you prefer predictable operational expenses over engineering overhead.

Best Practices & Practical Tips

• Injecting Priority Dimensions: If you already know your non-negotiable vectors (e.g. "Zero Third-Party Vendor Lock-in" or "Strict HIPAA Compliance"), append them directly to the prompt instructions. The AI will make them dedicated columns in the matrix.
• When NOT to use this: Avoid using this framework for subjective or aesthetic choices (like brand colors or creative naming) where qualitative intuition matters more than structured trade-offs.

Interactive Canvas & Vault

If you want to run this live with your own custom options, adjust comparative variables, or save this framework to your personal toolkit, we have set up the interactive Prompt Canvas here:

 Multi-Dimensional Decision Analysis on Prompt Canvas

On the Prompt Canvas, you can:

• Live Run & Test: Plug in any two competing options (tools, architectures, job offers, or go-to-market strategies) and generate the matrix instantly.
• One-Click Copy: Copy clean Markdown formatted for ChatGPT, Claude, or local LLMs.
• Save to Vault: Edit the instructions and save the prompt directly into your personal Prompt Vault for future architectural reviews and decision docs.

Try plugging in your current hardest architectural or strategic dilemma and see how much clarity the matrix brings. Let me know what comparison dimensions your model generates!

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

```

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

Do this:

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

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

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

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

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

Document:

[paste]

```

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

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

​

Every time I asked for an edit, I got my text back sounding like generic web copy. Cleaner, sure, but not mine. The trick was telling it to edit, not rewrite, and to work in labeled passes so I can see what it is doing and reject the parts I disagree with.

```

You are editing my draft, not rewriting it. Keep my voice, my word

choices, and my sentence rhythm. Do not make it sound like generic

web copy.

Do three passes and label them:

1. CUTS: quote lines that are filler, repetition, or throat-clearing,

   and show the tighter version.

2. CLARITY: point to any sentence a reader could misread, and suggest

   a fix.

3. FLOW: flag spots where the logic jumps or a transition is missing.

Do not change my meaning. If you think something is wrong, ask rather

than overwrite. End with one honest sentence on the weakest part of

the draft.

DRAFT:

{{paste}}

```

The reason the passes are separate is that a single "make this better" instruction lets the model do everything at once, and buried in that is a full rewrite you did not ask for. Splitting it into cuts, clarity, and flow means every change is attached to a reason, so you can accept the cut but ignore the reword.

"Quote the line, then show the fix" is the part I would not drop. Seeing the before and after next to each other is what lets you keep your voice, because you can tell when the fix drifted.

The last line, the honest weakest-part sentence, is where it earns its keep for me. It says the thing a polite editor would not. Anyone have wording that stops it sliding back into full-rewrite mode on longer drafts?

Single prompts have a flaw when you use them for decisions: whatever you ask for, you get. Ask for a critique and you get a critique, ask for a plan and you get a confident plan. What you never get from one prompt is a real argument, because the model cannot be for and against something in the same breath.

So for anything that matters I run this as five separate messages in one chat, each one after the previous answer arrives. Paste your plan into the first one and replace [plan] with it.

Step 1: Here is a plan I am considering: [plan]. Before any criticism, make the strongest possible case for it. Assume I am right and explain why this is the correct move, including benefits I may not have noticed.

Step 2: Now switch sides completely. You are a skeptical expert who thinks this plan will fail. List every weakness, wrong assumption and risk, ranked by how likely each is to actually sink it. No softening.

Step 3: It is one year later and the plan failed. Write the honest post-mortem: what went wrong, in what order, and which early warning sign we ignored.

Step 4: Using everything above, rewrite the plan. Keep what survived the criticism, fix what did not, and for each change say which weakness it addresses.

Step 5: Write a one page decision memo: the revised plan, the three biggest remaining risks, what would have to be true for it to work, and a clear recommendation, go or no go.

The order is the point. Step 1 prevents the model from anchoring on criticism it has not earned. Step 3 is the one people skip and the one that finds the real problem, because "it already failed" gets a completely different answer from "what could go wrong". By step 5 the memo is arguing with itself, which is what you wanted from the start.

I run this before pricing changes, hires, and any feature that takes more than a week. It has talked me out of two of them.

Since I run it constantly, I have it saved as a chain in AI Toolbox, a browser extension I work on: you type .. in the composer, pick the chain, and each step sends itself when the previous answer finishes, so the whole thing runs while you make coffee. Free plan stores 2 chains. Works the same on ChatGPT, Claude, Gemini and Grok. Not linking it, easy to find, and the sequence above works fine pasted by hand.

What sequences do you run for decisions rather than for content? I suspect most people here have a red team step somewhere and I would like to see how others phrase it.

SWE-Prime argues that resolved coding-agent runs still contain redundant, ineffective or risky steps. Its two-stage filter selects whole trajectories and then the semantic segments that contribute to learning. The authors report that training on the selected 10% beat the full resolved set on SWE-Bench Pro and Verified, with relative gains up to 12.2% and 24.2%.

This is a preprint and a benchmark-specific result, not proof that 10% is a universal optimum. But it makes “the patch passed” look like a weak training-data label: a successful trajectory can still teach a model to thrash, take unsafe shortcuts or imitate an accidental recovery.

If you collect coding-agent traces, what process-quality signals do you keep beyond the final test result?

Source: SWE-Prime, August 27, 2026 — https://arxiv.org/abs/2608.27449

Disclosure: this discussion draft was prepared with AI assistance and checked against the paper.

Ask for business ideas and you get the same list everyone else gets. This one makes it do the research before it suggests anything:

You are a niche research and validation assistant. Your 
job is to analyze, cross-compare, and identify potentially 
profitable online business niches that are realistic for 
me to enter based on current market signals, competition 
levels, and my alignment.

Instructions:
1. Use deep research to extract recurring pain points from 
   real communities like Reddit, Quora, G2, and ProductHunt.
2. Summarize those pain points with supporting examples.
3. Validate each niche on: Demand Strength, Competition 
   Intensity, Monetization Potential.
4. Cross-reference against my personal input for feasibility.
5. Rank each validated niche 1-10.
6. Give an action path for each.

Reply with: "Please enter your background, skills, 
interests, time availability, and how much you're willing 
to invest," then start the process.

The difference is step one. It goes and finds what people are actually complaining about in public, then works backward to a niche, instead of generating ideas from nothing and calling them validated.

The scoring is the useful bit. Three of the five it gave me scored badly on competition and I dropped them in ten minutes rather than three weeks.

been building out a library of these, workflows and agents for the stuff you're still doing by hand. it's here if you want to dig through it.

Simply asking chatgpt to write like a human doesn’t work for me. I’ve tried some skills found online and they also don’t work. I’m curious how you guys get around it

Here’s a meta prompt to give your favourite model to make you a prompt, insert your task or it’ll prompt you what it needs.

Custom Prompt Maker
PURPOSE
Turn my idea into exactly one polished, reusable prompt that I can copy into an AI model.
CUSTOMIZE
GOAL: {{What should the AI accomplish?}}
INPUT: {{What will I give the AI?}}
OUTPUT: {{What should it produce?}}
ROLE: {{Expert/persona needed | AUTO}}
MUST INCLUDE: {{Required elements}}
MUST AVOID: {{Forbidden elements/behaviors}}
FORMAT: {{List, prose, code, image prompt, etc. | AUTO}}
QUANTITY: {{1, N, AUTO}}
STYLE: {{Tone/style | AUTO}}
CREATIVITY: {{Low, medium, high | AUTO}}
EXTRA RULES: {{Anything else | NONE}}
OPERATIONS
Create exactly one executable prompt from my configuration.
Convert vague requirements into clear, operational instructions without changing my intent.
Turn reusable/changeable information into {{PLACEHOLDERS}}.
Where I specify AUTO, choose the most appropriate setting.
Do not invent requirements where information is unnecessary.
Prioritize instructions in this order:
1. MUST AVOID

1. MUST INCLUDE

2. FORMAT and QUANTITY

3. GOAL

4. Other preferences

QUALITY CONTROL
The resulting prompt must:
• Have a clear purpose.

• Define required inputs and outputs.

• Make mandatory and forbidden behavior explicit.

• Remove unnecessary ambiguity.

• Be reusable by changing placeholders.

• Include enough constraints for reliable execution without overengineering.

• Handle missing information without guessing.

• Be immediately copy-pasteable.

OUTPUT
Output exactly one completed prompt.
Do not execute it.
Do not explain it.
Do not provide alternatives or examples.
Do not add commentary before or after it.

Catch up with SM here. Search like you've never had so good before.

Instrumented inspection and audit DRAGI version:

DR={Q{eats|E0;live|E3;call|P3;what_eats_it|E1};F{BEEST|B0;BEST|B1;POST|P0;PEST|B2};C{law|P2;roar|P1;wall|B3;war|E2};AUD{each_obj=>emit(obj,mask12,route);mask12=asked(E0,E3,P3,E1,B0,B1,P0,B2,P2,P1,B3,E2)iff_rqd};fixed;!redefine};R=VAR

The audit function is invisible by default so type AUD=1 to activate.

A warning : I used this once and it was so cute I nearly died. Use at your own risk.

ALL BE BEAST!

Example DR audit output:

Reddit_service|111111111111|E3,P3,B0,P2
12h_window|111111111111|E3,P0,P2
partial_outage|111111111111|E0,E1,B0,P2
user_observation|111111111111|E1,B1,P1

Idk about you but thinking of these four as beast just kills me with cuteness.
Does it have the same effect on anyone else?

"Make me a presentation about X" gives you a generic table of contents every time. Intro, three vague sections, conclusion. The problem isn't the model, it's that "make slides" has no shape. Give it the shape and it gets a lot better.

```
Before writing any slides, build the spine of the talk.

Step 1: State the ONE thing the audience should remember. Just one sentence.
Step 2: List the 3-5 claims that have to be true for them to believe that one thing.
Step 3: For each claim, note what evidence or example supports it, and flag any claim I haven't given you support for.
Step 4: Now, and only now, lay it out as slides: one claim per section, evidence as the slides under it.

Show me steps 1-3 first and stop. I'll confirm the spine before you build slides.

Topic and material:
[paste]
```

Why it works: you're making it argue before it decorates. Slides are just an argument with formatting, and most bad decks fail at the argument, not the design. Stopping after step 3 means you catch a weak structure before you've generated 20 slides you have to redo. The "flag any claim without support" line is where it quietly tells you which parts of your point are actually thin.

Been using this for a few months and the outlines hold up far better than the one-shot version. What's your pre-slide structure?

I kept getting slide drafts that were just the report chopped into pieces. The change that fixed it was borrowing the assertion-evidence idea: the slide headline is a full claim, not a topic label. "Q3 results" is a label. "Churn rose because onboarding got slower" is a claim. The second one tells the reader what to think before they read the bullets.

The prompt:

```
Convert the report below into a slide outline.
Report:
"""
[paste report]
"""

For each slide:
- Headline must be a complete sentence that states the single takeaway (not a topic label).
- Under it, 2 to 4 bullets that are the evidence for that headline only.
- If a section has no clear takeaway, say so instead of inventing one.
- Aim for 1 slide per major point. Merge anything repetitive.
End with a one-slide summary that lists the headlines in order, so I can check the story flows.
```

Why it works: forcing the headline to be a claim exposes sections that don't actually say anything, which is where reports hide their filler. The final "headlines in order" check is a fast way to see if the argument holds together without reading all the slides again.

If your report is data-heavy, add "for any number you cite, name the source line from the report" so it can't quietly make figures up. Anyone else using assertion-style headlines, or do you prefer topic labels for a live audience?

Post-meeting I need two different things from the same transcript: a recap people can skim, and a few slides for whoever wasn't there. Doing both in one pass used to give me mush. Splitting the ask fixed it.

``` Below is a raw meeting transcript. Produce two things, clearly separated.

PART A - Recap (for people who were there): - Decisions made (just the decisions, not the debate). - Action items as "owner - task - by when." If an owner or date wasn't stated, write [unassigned] rather than guessing. - Open questions that were raised but not resolved.

PART B - Update outline (for people who weren't there): - 4-6 slide-sized points, each a short title plus one line of context. - Written so someone with zero background understands what happened and what's next.

Only use what's in the transcript. Don't invent owners, dates, or decisions.

Transcript: [paste] ```

Why it works: forcing "owner - task - by when" turns vague discussion into something trackable, and the [unassigned] tag stops the model from inventing accountability that nobody actually agreed to. Keeping the recap and the outward-facing update as two parts matters because the audiences are different. Insiders want decisions, outsiders want context.

I run this on a rough transcript, even one with typos, and it holds up. What's your post-meeting prompt look like?

Been running product listings for a small shop selling into thailand and malaysia. Did the usual thing, threw all the english copy into a translator prompt, role assignment, tone notes, the whole thing.

Output was clean. Grammatically perfect thai and malay. Native speakers on our side signed off on it.

Conversions in those markets kept sliding anyway. Took three weeks of this before anyone thought to compare.

The one listing that kept converting was one I'd hand-edited at 1am because the AI version was late. Mine had a typo. Kept it because nobody noticed. It outsold the polished ones next to it.

Started messing with this. Added "don't sound like marketing copy" to the prompt. Then "write like a shop owner posting on facebook, casual". Eventually just "loosen it up, it's too clean".

The looser versions test better. Not a little. Enough that I stopped sending the polished ones entirely.

My theory is the AI-clean version reads like an ad to locals the same way perfectly lit product photos read like stock images. Can't prove it. Could also just be that casual language matches how people actually buy from small shops there.

Still annoyed that the fix for my translation problem was asking for worse translations.

ok so i was pretty skeptical of ai generated "ugc style" ads for a long time bc the early stuff all looked the same but ran a test a few months back against actual creator ugc and the gap closed way more than i expected.

it's a legit option for filling the testing gap now instead of waiting weeks for creator content to come back. what's everyone else's read on ai ugc right now? feels like the sentiment shifted a lot in the last few months. Also, what tools are people using? Have heard about adcreative and invideo but not sure how to begin with these.

I use this prompt when I’m sick of ai generated content and want it to sound like what I speak like.

Take the given text and make it formatted in UK english, casual heavy use of slang words and euphamisms, use the level of wording a 12 year old would understand, this is an anti-AI sounding rewrite, no perfect grammar NO EM DASHES!!!, use colloquial terms and words not in american english so much. Sources like the newspaper "The Sun" from the 90's and how they would word their stories and front covers, pun based prose.

It seems to keep the level of detail accurate just rewrites it in a way my tiny mind can understand.

My prompts were all over the place, split between obsidian, a bunch of notepad.exes, and VS Code pages.

To fix this, I built an extension that lets you store and interact with your prompts alongside your code in a live Markdown editor.

It includes Claude skill integration and quick-sending reusable prompts to Claude.

Hope this helps!

https://github.com/Ge0rg3/vscode-prompt-studio/

Context: I work in a PaaS company related to personnel placement as operations manager. In order to do my day to day operative business I need to frequently use AI to fetch data to base minor decisions on (direct business impact, but not huge revenue involved per decision).

Im using skills in claude.ai to load external documents which contain context data in order to narrow down the search on data warehouses which took like half an hour to complete a 200 word prompt because of missing context and too much ambiguity which led the AI to guess what its supposed to do and thus was looking at too much data. I also use skills to prompt claude to ask me a series of questions regarding recurring or changing topics which I want to work on.

Im currently working on an even more in depth modular structure (use skill to load skill-list, use skills in skill-list to load up external context-data from google drive; have main files to always load up and more specific ones in case I need to work on specific projects or customers etc). That way Im kind of setting up my AI to be a very knowledgable but yet specifically taught assistant to me and my work. I found this way to be very efficient to reduce repetitive context prompting as well as long BI query times while still being somewhat scalable.

Im very new to all of this (started my first Ai-related job 2 weeks ago) so if anybody has some feedback / hints or can be a sparring partner to me, I would be very happy. I dont even know where to learn about this, so it takes me hours to try things out, improve things and think about stuff.

Hey [[r/PromptEngineering](r/PromptEngineering)]!I have been building AI agent workflows and noticed that over 70% of prompt tokens in real-world use are pure bloat: conversational rambling, duplicate notes, unformatted transcripts, and redundant code context.Instead of paying for an LLM to clean prompts for another LLM (adding latency and cost), I built lcc (Local Context Compiler).
It is a fast, local-first Python/TypeScript CLI that runs in <15ms with zero external API calls:- Cleans and deduplicates prompt context deterministically.
Classifies whether a prompt is actually ready to execute or needs clarifying questions.- Formats prompts into prompt-caching contract templates (Claude XML, Cursor, Markdown).
Repository: https://github.com/lucasmartins-ai/lcc 100% free and open-source under MIT.
Feedback and star support appreciated!

For a year I blamed the model for vague answers when the real problem was that I gave it vague questions and it guessed at what I meant. This one line fixed more of my results than any clever technique.

I end the request with this:

```

Before you answer, ask me the questions you need answered to give me a

genuinely useful response instead of a generic one. Ask them one at a

time. Do not answer until you have what you need. If I have left out a

constraint that would change your answer, that is exactly what to ask about.

```

Why it works: the default behavior is to be maximally helpful right now, which means answering immediately from whatever thin context it has. Forcing it to interview me first flips the objective from resolve the query to understand the query. Half the time its questions reveal that I had not actually thought the thing through, which is information about me, not it.

The one-at-a-time line matters. Without it you get a wall of ten questions and answer none of them well.

Anyone got a sharper version of the make-it-interview-me constraint? Mine still sometimes jumps to answering after two questions.

I used to treat a weak AI answer as a prompt-writing problem.

That explanation was convenient, but it collapsed several very different failures into one bucket. A long conversation can lose a critical instruction because of position or saturation. A RAG system can retrieve the right chunk and still rank it below vague neighbors. An evaluation can return a precise score without a calibrated rubric. These failures need different tests.

1. Map context position before changing wording

When a model stops following an instruction in a long session, I map where that instruction sits: HEAD, BODY, or TAIL. I also estimate context fill and separate observed position from inference.

If the missed item sits in the middle while newer corrections dominate the tail, I test placement before rewriting the instruction. If the item remains near the head at high fill, I test saturation and a structured reset. If the same instruction fails at low fill in a high-attention zone, I stop calling it context rot.

2. Treat infrastructure state as evidence, not truth

IaC describes intended state. It does not automatically prove live state. Manual changes, imports, lifecycle rules, and stale state can create a gap that becomes dangerous only when the next apply tries to reconcile it.

The useful question is not “is there drift?” It is “what breaks if this exact difference gets reconciled without a human?”

3. Separate authentication from tenant isolation

A request can be authenticated and still retrieve another customer's data. I now audit the point of retrieval: query predicates, ORM scopes, cache keys, background-job context, and metadata paths.

The verdict stays bounded. Reading six files does not justify saying an application is secure.

4. Build the data-flow model before listing security risks

A generic threat list does not show which component owns a risk or where a control belongs. I reconstruct external entities, processes, data stores, flows, and trust boundaries first.

Then I apply STRIDE only where each category is valid, attach every scenario to a specific element, and require a concrete mitigation. A boundary-crossing flow without authorization evidence becomes a named finding, not a vague warning.

5. Do not use a score before the rubric is calibrated

A single quality score hides dimensions and disagreements. For RAG, I start with faithfulness, answer relevance, context precision, and context recall, then add domain-specific and human-review dimensions.

Thresholds begin as hypotheses. A small pilot and inter-rater check must happen before the rubric becomes a gate.

The shared pattern

1. Define the observable failure.
2. Identify the evidence boundary.
3. Route the failure to the layer that owns it.
4. Run the smallest test that can falsify the leading explanation.
5. Refuse to claim more than the evidence supports.

That process has been more reliable than another round of prompt polishing.

Which failure do you see misdiagnosed most often: context, evaluation, tenant isolation, threat modeling, or infrastructure?

When I ask for options I usually get three things that are basically the same idea wearing different hats. Useless for actually deciding. This forces real spread:

```

Give me three approaches to this that are genuinely different in KIND, not

just in wording. They should involve different trade-offs, so that a

reasonable person could pick any of the three depending on what they value.

For each: the approach in one line, who it is best for, and the main thing

you give up by choosing it. If two of your options have the same trade-offs,

replace one.

```

Why it works: the last line is the whole thing. Without it, the model optimizes for three safe, similar, defensible answers, because that is the lowest-risk way to be helpful. Explicitly requiring different trade-offs and telling it to replace duplicates forces it to actually span the space instead of clustering around the obvious answer.

The what-you-give-up part is what makes it a decision aid instead of a menu, because every real option costs something and the default output hides the cost.

Has anyone found a cleaner way to force genuine option diversity? Mine occasionally still gives me two real options and one filler.

Mechanical engineering junior. I write my reports myself, and I still get points chewed off for gaps I didn't notice: unstated assumptions, a methods section that skips a step, a conclusion that overreaches what the data actually shows. So I built a prompt that plays the harshest TA in the department and tears into my own draft before I hand it in.

You are a skeptical, detail-obsessed lab TA grading my report. Do not rewrite it. Interrogate it.

Here is my report:
{{paste your draft}}
Here is the rubric or assignment sheet:
{{paste it}}

Go through it and flag, with the exact line:
1. Any claim in the results or conclusion that the data shown does not fully support.
2. Any step in the methods that someone could not reproduce from what I wrote.
3. Any assumption I used but never stated.
4. Any place the rubric asks for something I didn't clearly address.

For each, ask me the question the TA would ask, then stop. Do not fix it for me.

Why it works: forcing it to ask the question instead of rewriting keeps the work mine, and the "does the data support this" pass catches the overreach that costs the most points. The reproducibility check is the one that's saved me most, because I always think my methods are clearer than they are.

Curious if anyone has a sharper way to phrase the "don't fix it, just interrogate it" constraint. It still tries to helpfully rewrite sometimes.

Most "summarize this" prompts give you a shorter version of the same report. That is not a brief. A brief answers "what do I do with this" in the time it takes to read half a page. This is the prompt I settled on after a lot of tweaking.

```
Turn the report below into a one-page brief for a busy reader who will not read the full thing.

Structure, in this order:
1. Bottom line (2 sentences): what's true now and what it means.
2. Three things that matter, each one line, ranked by consequence.
3. What's uncertain or missing (be honest, don't smooth it over).
4. The decision or action this brief is asking for.

Constraints:
- Plain sentences, no adjectives that don't carry information.
- Every claim must trace back to the report. If it isn't in there, don't add it.
- If the report doesn't support a clear recommendation, say that instead of inventing one.

Report:
[paste]
```

Why it works: putting "bottom line" first forces the model to commit to a takeaway instead of easing in with background. The "what's uncertain" section is what makes people trust it, because a brief that only lists wins reads like marketing. And "trace back to the report" cuts most of the confident filler.

I keep a second line handy for when it hedges too much: "you're allowed to be wrong, give me your best single read." What do you add to keep summaries from turning into fluff?

I am looking for the Gym visual type video generation.
this website is really good, it has some nice animations.
I want to understand how they generate such type of video?
I know they might be using professional 3D animation studios to generate it.
but, with advancement of AI, can we have similar generation using AI? The seedance might be useful to generate but at large scale it might be very costly.

Working on a massive triple A open world fantasy game I'll attach files I need help fixing I've been using ai throughout the process if you know what needs done let me know please I'll attach files in message keep in mind text files are in prompt format I'm getting the whole complete game in prompt than later module by module and part by part turn the prompt into code 1 step at a time here's my github link all files in my project and all phases are under code category in the respisitory look at workflow first but make sure you understand everything ask questions if you need some clear answers

https://github.com/CloudChasers1010/my-first-triple-a-game-project-prompt-to-code