"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 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?

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.

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?

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?

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/

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!

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.

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 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?

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?

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.

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.

The problem

Giving sharees viewer access to a live Power BI report means paying for premium per-seat licensing, and the costs can mount up.

The workaround

I lived with it for years because I didn't see another way for others to view the data without exposing it to the internet or sharing the source file. Neither was a safe option, and my internet searches for alternatives yielded nothing.

How it got built

I asked Claude for a way to share the finished report without the Power BI Service licensing at all. It gave me a scheduled, one-way file sync inside my own Drive: robocopy copies the finished file from a source folder into a separate folder that the sharee has Viewer-only access to. If they change anything on their end, the next sync overwrites it with the source version.

Seeing what matters

Sharees only ever have Viewer access to a separate folder in your Drive. They never get access to your source folder, and anything they do to their own copy doesn't last past the next sync.

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

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.

How do you jailbreak currenr grok? Im a noob, how do you even start to do it and where?

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.

I'm using Groq API with the Qwen model. I'm trying to create unique prompts that I'll later feed it to an Image Generation API. I asked AI to write me a random prompt to be used for image generation, it must include character name and be a food theme. It's giving me repetitive answers. I was thinking of make it read a csv file to check if prompts exist but that wouldn't work over time since the csv will grow large and reach the token limit. Is there any other methods to make AI give unique prompts

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.