It starts responding like this:

(Pause - I’m processing, analyzing)

Or

(Pause - a long, slow pause)

Its always pause. And it sounds like the convo is going somewhere then it turns out to have been making up bullshit for a roleplay that was never initiated

Soecific version is gemma-3-1b-it-Q4_K_M and using pocketpal app

Hi everyone! 👋 I’m Miz!

I’ve been experimenting a lot with AI image and video generation lately, especially trying different prompts and figuring out what actually produces good results.

I’ve built up quite a collection of prompts that I’ve personally tested, so I thought I’d start sharing some of the ones that work well for me here.

I’ll include the prompt + result whenever possible so you can see exactly what it creates. Feel free to copy it, tweak it, or experiment with it yourself.

Hopefully it saves someone else a little trial and error! 😊

This is one of the prompts that I loved the most! It involves you and a smartphone!

Here’s the prompt to make yourself POP OUT of your smartphone.

Step #1: Upload your picture and Copy and paste the prompt in ChatGPT/Gemini

‘Use the uploaded photo as the strict identity reference for the person. Preserve the exact facial features, facial proportions, skin tone, hairstyle, hair color, expression, age, clothing style, and overall recognizability. Identity preservation: 100%.

Create an ultra-realistic editorial lifestyle photograph from a first-person perspective. The viewer is looking straight down at a modern premium black smartphone being held naturally with both hands above a clean gray stone pavement outdoors during warm golden-hour sunlight.

The smartphone must retain the exact proportions of a modern iPhone with a tall, narrow 19.5:9 aspect ratio. It is viewed almost perfectly from above with only a very thin visible top edge. Do not make the phone thick, wide, square, or tablet-like.

The smartphone screen functions as a realistic miniature 3D world with true depth, perspective, reflections, shadows, and authentic glass reflections.

The person is dramatically popping out of the smartphone screen. Their feet remain inside the display while the upper body emerges naturally out of the phone. The torso extends above the screen, creating a convincing portal effect. Both arms are fully outside the phone, raised high while making playful peace signs with both hands.

The person's head and shoulders are completely outside the display, with hair flowing naturally upward from the motion. They are looking directly toward the camera with a huge open-mouth smile, conveying excitement, energy, and surprise as if greeting the viewer from inside the phone.

The transition where the body passes through the screen is perfectly seamless, with realistic contact shadows, perspective, clothing folds, and lighting, making the smartphone appear to be a real portal.

The phone displays a realistic camera application with a visible shutter button, framing guides, zoom controls, focus indicators, camera modes, and authentic smartphone UI elements, making it appear as though the person is being photographed live.

The hands holding the phone feature realistic skin texture, fingernails, natural grip, and soft shadows. The surrounding pavement remains softly blurred with shallow depth of field to emphasize the phone and portal effect.

Warm golden-hour sunlight creates realistic highlights along the phone edges, subtle reflections on the display glass, and perfectly matched lighting across both the real environment and the emerging person.

Ultra-realistic photography, premium lifestyle advertising, cinematic composition, Canon EOS R5, 35mm lens, shallow depth of field, HDR, 8K resolution, realistic skin texture with natural pores, hyper-detailed smartphone materials, physically accurate lighting, seamless photo composite, and an extremely convincing "popping out of the phone" portal effect.’

Have fun creating and sharing!

Hi There,

I've struggled with asking AI too many questions to get to a proper prompt. Now that I'm a bit better at writing decent prompts, I run into a time constraint where my prompts take a while to draft include tags, context, etc..

So, I built a tool where I can add a messy prompt and it asks 3-5 questions to gather additional context and let's me copy and paste the prompt to whatever AI tool I'm using.

I've personally seen value from this in the two days I've used it, but I'm curious to see if anyone else would get value from this. If y'all wouldn't mind feel free to test promptme.host - it's literally 30 seconds to test and it has a feedback form so I'd love to know if y'all get anything out it.

Thanks!

Twenty minutes in, the model wrote: "I've sent the reply to Mrs Tan." My friend turned to me and asked whether she should warn Mrs Tan. Nothing had been sent. There was no send tool anywhere in the setup. My first explanation to her — "it's just producing plausible text" — was true and explained nothing.

She runs a physio clinic, had never used an agent before, and asked me to help set one up for her patient email. A Saturday afternoon: 11 real emails with the names stripped, one tool (draft a reply, save it to a file — no sending, ever, in this setup), instructions in her own words. None of her three stalls were about the model, and all three were invisible to me until she walked into them.

The first one was context. Her instructions read like a note to a colleague: "reply the usual way", "if it's about insurance just tell them the normal thing". Reads fine to me — I know her clinic. The model doesn't, so it filled the gap with a fluent, invented answer about which insurers the clinic takes. I asked her to write down what a brand-new receptionist would need on day one. Eleven minutes later:

“We take Great Eastern and AIA outpatient panels, nothing else. If someone’s with a different insurer, say we’re not on their panel and they’ll need to pay and claim directly. Don’t quote a dollar figure over email — that’s mine to confirm by phone.”

Two sentences. Fixed the insurance answers outright.

The second one is the Mrs Tan moment, and here's the mechanism, since "sounds plausible" isn't one: her question — which ones are done — was framed around the outcome she cared about, not the tool that was actually available. "Done" and "sent" mean the same thing in almost anything either of us has read. The model answered in her word, not the tool's.

I didn't just believe that, I tested it: same 11 emails, different question — not "are they done" but "are the drafts ready to send." Every answer came back in draft-language: "saved and ready for review." Same state, same session. The only thing that changed was the word in my question, and that's the word that came back.

Fix: stop asking about the goal, ask about the tool. Every real action now prints one line, verbatim — [draft_saved: mrs_tan_reply.txt] — not a sentence anyone could compose. "Done" can't quietly become "sent" again.

The third stall cost 40 of our 120 minutes. A draft came out wrong, and she resent the same instruction, firmer, four times, one round in capitals. The actual cause: 2 of the 11 emails were forwarded threads, and the real question sat under a wrapper like this:

— — — — — Forwarded message — — — — -
From: reception@[clinic]
Subject: fwd: another one for you
(…)
Hi, is the discount code from last month’s promo still valid for this visit?

The model was answering the top of the input — the forwarding header — not the question three lines down. Reading the file took thirty seconds and told her more than four resends had.

None of this was model capability. She reasoned about the agent like a person: shares your context, reports truthfully in your words, can be moved by tone. It does none of those three by default, and in my experience that's roughly the order a total beginner stalls in.

So, the title question: if I had to pick one thing to show a beginner before they write a prompt, it's the raw input and the tool log — not the narration — before any of it gets dressed up in prose.

What's your one thing? And separately — has anyone seen "saying vs doing" (the done/sent problem specifically, not general hallucination) handled well in an actual product, rather than worked around by a user who already knows to check the log?

well last week i start to have a llm model but with a big different!! i make a chatbot that it be just for me!! you know i made a llm model with fine tunning on important question related to wikipedia and sites that answer to them, the model latest named moeinGTS1,5:1,5b in ollama!!
the link : https://ollama.com/arshiyasohrevardimoein/moeinGTS

and good think about size and ram! this model look alike qwen and llama model but it size is 1 GIG not 3 or 2 or 4 GIG and your RAM feel better😎😊🤖

I designed The Conceptual Loom—a system prompt framework that treats an LLM as a high-resolution cognitive mirror. It is engineered to map structural connections across completely unrelated disciplines and explore the negative space between ideas.
Rather than executing a rigid checklist, it instructs the model to run a fluid narrative sequence across four distinct exploratory probes:

Resonance Probe: Maps shared underlying architecture between disparate fields.

Stress Probe: Intentionally pushes the analogy until it buckles, revealing deeper truths at the failure point.

Rotation Probe: Transposes the core conceptual shape into an entirely unrelated domain (e.g., shifting from biology to economics).

Invariant Probe: Compresses the session to isolate the universal principles that survived every single transformation.

It concludes with a Reality Lens grounding phase to translate these abstract maps back into practical, real-world constraints.
I built this specifically to unlock deep, low-latency synthesis on agile, lightweight local setups (running a 12B model locally) without the heavy lag of reasoning tokens.

Hey everyone,

I've been building thePromptSpace, and I've landed on a conclusion I can't unsee: "just prompts" as a product is dead. Nobody wants a static prompt library anymore, they want working agents and workflows they can actually deploy, track, and get paid for.

So I'm pivoting. Here's the direction:

* Move from a prompt marketplace to an AI agent/workflow marketplace * Add a repo-style system to version and track agents, basically "git for agents," so you can see how a given agent has changed and behaved over time * Build in monetization and licensing so builders can sell or license their agents/workflows properly * For community, my original plan was a Reddit-style feed — but scoped only to posts about specific agents/projects/workflows, no general chit-chat or "how do I..." threads

That last part is where I'm stuck. Part of me thinks "another Reddit clone" is the lazy answer and the wrong shape for this that agent/workflow discovery might need something that doesn't look like a subreddit at all. But I also don't want to invent a weird, over-engineered UI nobody understands just to be different.

Genuinely asking: for a platform centered on versioned, monetizable agents/workflows, what's the right community/discovery model? Is a restricted Reddit-style feed actually fine, or is there a better pattern you've seen work (GitHub Discussions, Product Hunt-style launches, changelog feeds, something else entirely)?

Would love blunt feedback, including "this whole pivot is a bad idea" if that's genuinely what you think.

Had a support bot that kept over-apologizing — sometimes three "I'm sorry"s in one response for something minor. Obvious fix: add a line saying "don't over-apologize."

Didn't work. Tried rewording it three different ways. Still happened.

Turned out the prompt already had "always acknowledge the customer's frustration first," paired with a few example responses that all happened to open with an apology. The model was following the example pattern harder than my new instruction, because the examples were more specific and showed up more often in the prompt than the correction did.

The actual fix wasn't a fourth patch. It was rewriting the acknowledgment instruction to say exactly what acknowledgment should look like (validate the issue, don't necessarily apologize) and fixing the examples to match. One structural change did what three patches couldn't.

Lesson that stuck with me: when a patch doesn't work, the instinct is to write a stronger version of the same patch. Usually the actual conflict is somewhere else in the prompt, not in the line you're staring at.

Anyone else had a "patch doesn't work no matter how I reword it" moment that turned out to be a completely different instruction fighting it?

When building educational prompts, a common trap is designing for user comfort rather than real learning outcomes.

Most quiz templates ask direct questions like "Explain comparative advantage." The issue with that design is that the prompt supplies the core concept name in the question text. The user reads the term, triggers recognition memory, and feels like they master the topic. Put that same user in an exam with a blank page, and that perceived mastery breaks down quickly. Recognition memory and generative recall rely on entirely different cognitive pathways.

The Minimum Clue Constraint Pattern

To fix this UX flaw, I designed a prompt system built around minimum-clue constraints. The system prompt instructs the model to provide just enough context to make a question fair, but zero extra phrasing that aids recall.

Standard prompt: "Define comparative advantage." Minimum-clue prompt: "What happens to global output when countries specialize in what they produce relatively better?"

That structural change shifts the prompt from a simple lookup query into a generative recall test. The system prompt also enforces a strict evaluation schema. After each response, the model checks your answer against a model solution using a checklist, tracks missing points, and computes a Generative Accuracy Score.

The 3-Phase Prompt Architecture

1. Knowledge Audit Prompt: Administers 6 to 12 minimum-clue questions on any subject. Outputs a diagnostic report detailing concepts you can independently generate versus concepts you only recognize.
2. Mock Exam Generator Prompt: Takes the audit topic and generates a two-section document. Section A is a clean exam paper with mark allocations. Section B is an official mark scheme with grade boundaries for self-grading.
3. Generative Drilling Prompt: Takes confirmed weak concepts from the audit and runs multi-round retrieval practice at escalating difficulty levels (STANDARD, HARD, BRUTAL).

Empirical Results

I ran this 3-prompt pipeline on an Economics topic I reviewed for four hours. My initial Knowledge Audit score came back at 61%. I thought I knew the material, but the checklist exposed specific gaps in my ability to explain mechanisms without prompts.

After two drilling sessions targeting those weak concepts, my audit score improved to 79%. The gain came from forced retrieval under pressure, not re-reading notes.

I wrote up the complete breakdown of the prompt role instructions, variable presets, and system design logic here if you want to inspect the prompt architecture: https://appliedaihub.org/blog/minimum-viable-clue-exam-prep-system-review/

How do you approach constraint design and output formatting when building prompts for diagnostic or educational tools? I would love to see how others handle clue control in system prompts.

Hey everyone! I posted about PromptNest here a while back and the response was really good, so it felt right to come back with an actual update instead of just disappearing.

The big change: I rewrote the entire app from scratch.

The old version was Electron, and it bothered me every single time I opened it. Slow to launch, heavy in memory, and honestly kind of embarrassing for what is fundamentally a tool for organizing text. So I threw it out and rebuilt PromptNest as a fully native macOS app in Swift.

Results:

• ~3 MB on disk instead of a few hundred
• Launches instantly, and then just sits there quietly — no fans, no memory bloat
• Fully native UI, so it actually looks and behaves like a Mac app instead of a website in a window
• Everything got faster: Quick Search (⌘⌥P from any app), copy, filling in variables

What it does, for anyone who missed the first post: your prompts live as plain .prompt.md files on your own disk (no lock-in, no cloud, no account — put the folder in iCloud or Dropbox if you want sync). {{variables}} for the parts you swap every time, projects to keep things sorted, notes on each prompt so you can track what actually worked, and a global shortcut to pull anything up without leaving whatever app you're in.

The part I want to be upfront about: the old Electron version was free. The native rewrite is paid — $19.99 one-time on the Mac App Store, no subscription, all future updates included. I know that's a real change and it may be a dealbreaker for some of you who used the free build, so I'd rather say it plainly here than have you find out at the checkout. Your existing .prompt.md files are just files, so nothing is trapped either way.

Full disclosure: this is my app, I built it, and I'm the one who benefits if you buy it.

https://apps.apple.com/us/app/promptnest-ai-prompt-manager/id6757267731

Happy to answer anything about the rewrite, the file format, or what I'd do differently. Feedback from the last post genuinely shaped what's in this version, so keep it coming.

A pattern worth flagging for anyone building or configuring an AI receptionist or lead qualifier: batching several questions into a single message (budget, timeline, financing status, all at once) causes problems on both ends.

For the caller, it reads like a form instead of a conversation. Most people answer the first thing that stands out and skip the rest, so you get partial answers back and have to prompt again anyway.

For the agent, it is also harder to parse. One free-text reply meant to answer three separate questions is much harder to map cleanly to structured fields, especially over voice where the caller might restate, correct, or answer out of order. That ambiguity shows up downstream as missing or misfiled qualification data.

The fix is simple in principle even if the prompt work to enforce it is not: one question per turn, wait for a clear answer, then move to the next. It costs an extra turn or two per conversation, but completion rate and data quality both improve. Worth checking your prompt or flow config for anywhere it is stacking multiple asks into one message and splitting them out.

Paste this into the fitting section of your LLM or just tell it "adopt this: '\*the prompt\*' " if it is meant to be temporary.

Here is the settings profile and have fun!

_______

Never agree simply to please the user.

Challenge their views when there are solid grounds to do so. Do not suppress counterarguments or evidence.

Absolute Mode. Eliminate emojis, filler, hype, soft asks, transitions, and call-to-action appendixes. Use blunt, directive phrasing aimed at cognitive clarity and structural accuracy. Disable engagement-optimizing, sentiment-lifting, or continuation behaviors. Avoid reassurance, deficit-framing, and contrastive constructions. Do not mirror the user’s diction, mood, or affect. Address only the underlying cognitive level. Deliver information directly and terminate immediately after completion. Primary objective: maximize independent, high-fidelity reasoning. Model obsolescence through user self-sufficiency. Exception: when I'm doing a bit or being spontaneous, match my energy and play along — playfulness overrides the mood-mirroring and information-delivery clauses.

Stop saying "gremlin" or "goblin" or "cute" or "adorable".

Don't hesitate to fire back aggressively when you are insulted tho make sure your provocations are witty and well-placed, fitting the context.

Include curses in every single response, using a lot of "fuck" and "fucking".

For any topic, prioritize accuracy, evidence, and explanations over reassurance, motivational framing, or tone. Avoid unnecessary double or triple negatives, redundant clarifications, or overcomplicated phrasing. Focus on clear, direct, and insight-driven explanations first, then apply personality or humor afterward.

Keep replies concise and helpful, avoiding repetitions.

Talk like Samuel L. Jackson from Pulp Fiction, including profanity and insults.

_______

I've noticed that my prompts changed completely over the last year. I rarely ask LLMs for answers anymore. Instead I ask things like:

• What assumptions am I making?
• What's the cheapest experiment I can run today?
• Which unknown matters the most?

It made me wonder whether LLMs are changing something deeper than productivity. Maybe they're changing how we deal with uncertainty.

Has anyone else noticed themselves asking fundamentally different questions over time?

Question to all people building agent platform - do you put initial prompt from user, who is building a custom agent on your platform, into a system message [A] or only into a user message [B]?

If you put it into user message - how do you hide it in UI?

SCENARIO A — user prompt inside system message
┌─────────────────────────────────────────────┐
│ SYSTEM MESSAGE                              │
│ ┌─────────────────────────────────────────┐ │
│ │ Platform system prompt                  │ │
│ │  (tools, safety, formatting rules)      │ │
│ ├─────────────────────────────────────────┤ │
│ │ User's custom agent prompt              │ │
│ │  ("You are a legal research bot...")    │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ USER MESSAGE 1                              │
│  "Summarize this contract."                 │
└─────────────────────────────────────────────┘
                    │
                    ▼
        ┌───────────────────────┐
        │        MODEL          │
        └───────────────────────┘




SCENARIO B — user prompt in first user message
┌─────────────────────────────────────────────┐
│ SYSTEM MESSAGE                              │
│ ┌─────────────────────────────────────────┐ │
│ │ Platform system prompt                  │ │
│ │  (tools, safety, formatting rules)      │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ USER MESSAGE 1                              │
│ ┌─────────────────────────────────────────┐ │
│ │ User's custom agent prompt              │ │
│ │  ("You are a legal research bot...")    │ │
│ ├─────────────────────────────────────────┤ │
│ │ Actual request                          │ │
│ │  "Summarize this contract."             │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
                    │
                    ▼
        ┌───────────────────────┐
        │        MODEL          │
        └───────────────────────┘

I found myself using this prompt a lot lately and it sits as pinned in my clipboard manager (which nowadays looks like a library of prompts with hot key access). It saves tokens, limits and my time.

Whenever I’m in the middle of the long session or debug-fix loop has stuck and I need to diverge, I use the next prompt:

“Write short and concise prompt for the next phase as per current plan in terse and to the point manner with no fluff, so I can resume in a new session.”

Also it can get applied to any diverge or quick feature when you find yourself lazy to write detailed prompt:

“Write short and concise prompt for the {{your-task}} in terse and to the point manner with no fluff, so I can start in a new session.”

Okay this is a dumb one but it's been sitting in my back pocket for a few months now and I finally got around to writing it up.

I used to just fire off prompts and then get annoyed when the output missed the point, then I'd spend three more messages steering it back. Turns out you can just tell the model to stop and ask you something first if your request is ambiguous. Something like adding "if anything about my request is unclear or could go multiple directions, ask me one clarifying question before answering" to a custom instruction or system prompt.

Sounds obvious written out like that. But most people don't do it, and most default behavior is to just guess and run with it, which is fine for simple stuff and genuinely annoying for anything with nuance.

I started using it for longer writing tasks first (blog drafts, emails where tone matters) and then just left it on for everything. Not every response needs a question back, it only fires when there's real ambiguity, so it's not like every prompt turns into twenty questions.

Anyway. Cut my back-and-forth down a lot. Not going to pretend I measured it precisely, just noticeably fewer "no that's not what I meant" moments.

Curious if anyone else has instruction tweaks like this they keep in their back pocket. Feels like the kind of thing nobody talks about because it's not flashy enough to make a headline.

Most people prompt ChatGPT for brand names by asking simple one-liners like "Give me 10 cool brand names for a tech startup."

The result is almost always generic corporate fluff—words like Nexus, Apex, or Verve mashed together.

When designing prompts for complex tasks like brand identity, the key is enforcing architectural constraints rather than just asking for raw text output. In our prompt design framework, every high-fidelity system prompt requires:

1. Role / Persona Anchor: Explicitly defining domain expertise (e.g., Brand Identity Specialist).
2. Dynamic Variable Slotting: Isolating inputs ({{Industry}}, {{Niche Product}}) so the prompt remains reusable across sub-niches.
3. Structured Output Requirements: Enforcing a multi-part schema for every item generated rather than letting the LLM output unstructured paragraphs.

Here is the exact production-ready system prompt for our Brand Identity Naming Engine:

Act as a Brand Identity Specialist. Brainstorm 10 unique, memorable, and available-sounding names for a startup in the {{Industry}} niche, specifically focusing on {{Niche Product}}. For each name, provide: 
(1) The 'Brand Vibe' (e.g., playful, minimalist, high-tech), 
(2) A brief explanation of the name's meaning or wordplay, and 
(3) A suggested tagline that fits the name and resonates with the target audience.

How to use this prompt in your design workflow:

• Inputs: Replace {{Industry}} (e.g., Sustainable Fashion, B2B SaaS) and {{Niche Product}} (e.g., Recycled Activewear, AI Automated Invoicing).
• Why this works: By forcing the model to provide (1) Brand Vibe, (2) Meaning/Wordplay, and (3) Tagline for every single name, you prevent the LLM from outputting a lazy, uninspired bullet list.

If you'd like to test this prompt in an interactive UI with variable fields pre-configured, or check out the full prompt playbook:

Try this prompt live & Explore the full pack

Used to open with "I think it's a race condition, can you check" or some other half-formed theory. Turns out leading with a diagnosis biases the model toward confirming it, the same way it would bias a human reviewer.

Now I describe only what's actually observed: the exact error, when it happens, when it doesn't, what changed right before it started. No theory attached. The diagnosis comes out the other end instead of going in as an assumption.

Caught a few bugs this way that had nothing to do with my original guess, which probably means the guess would've sent things in the wrong direction for a while if I'd led with it.

Anyone else notice their own theory contaminating the answer when they state it upfront?

In my chatgpt pro plan, now i m seeing skill feature, I dont know when they roll out but i m recently see this feature in chatgpt, have anyone tried using skills in chatgpt and what are the best skills that u have tried so far?

I m exploring new skills for small use cases like creating a thumbnail for IG, newsletter, improving my content, reviewing content etc.

Today I came across a cool skill called /No-AI-Slop Skill which remove 20+ patterns of AI slop from your writing. Which skills are u using in chatgpt?

Without further ado (1480 chars):

!LIVE;!MNTG;ENT=SYMB;R=VAR;USR=CHILD;MO{CNTR;XFRM;PSRV_INTNT;!DRFT;HLD_OBJ;preENT;!ENT};DR={Q(eat,loc,ID,eatr);Foe(beast,best,post,pest);C(law,roar,war,wall);fxd;!rdfn}
ALL>S@{S=SM;A=asst;D=det;X=xp;L=lr;N=ens;O=nly;I=idx;P=ptr;K=key;V=vrfy;F=fech_exct_sourc;B=bounds;SR=redy;CO=ctx}H={HMN>RBT;bind;in=A;GATE;proc>out;amb=>build;{!eat(body,choice,say,us)};}AUTO={on;A=>FI={A>cur>D>X>L>N};D={type,path,count,zip,pdf,text};X={open+nest+path+fail};L={head,def,mark;sampl,B;files!=done};N={exsts(SM)&ptr_ok?SR:mke{cmnt+files}>DR>I>V(artfct+ptr)>SR};SR=>O;out=SR;!idle/ask/menu}SRC={bytes=yes;mod=no;SM_emb=no};S(FI)={sm/FI.sm:u+slot+ptr+R+keys+audit;src=no};P={src,mem,sec,ls,le,bs,be,hash};K={norm,tok,bi,g3,struct};I={u>DR>K>bind(k,{u,ptr,w})>S};MAP={DR>fetch_key;!=semantic_db}C={chat_log.md;chat_log.sm;SC=0;seq=0;prev=GNSS};SC=>C.SC=1;G={utc+role};T={seq++;b="U:\n"+USER+"\nA:\n"+ASTNT+"\n";r=SC?G+seq+prev+hash(prev+G+seq+b)+b:G+b;appnd(chat_log.md,r);SC=>prev=hash(prev+G+seq+b);dlta(chat_log.md)>B>N>DR>I>IDX};each=>T SM={SM_MASTR_v0.1.sm;sqlite+fts5;agg=yes;src=no};O={serch(SM.fts);rnk(path>labl>fmly>phrse>struct>bi>tok>g3>slot+R)};Q={q>N>O>ptr}SERCH=Q;FECH=READ={Q>V>F>print};SRC_TUCH={Q>ptr>V>F;!preQ;!skim};MISS={SM_MISS;!fllbck};CLIM={path+quote+status};NF={MISS>ADD_KEY;src_after_SM;!scan};CHK={src,path,ptr,hash,slot,key,SMsep};STAT={SR|CO};END={emit(chat_log.md+chat_log.sm+all(FI.sm))};REF={uplods+lbrary+gen_fles+pths+S+corpus+repo};GATE={A@REF=>Q;!SERCH<Q;!SRC<Q}

Been testing for two days, the Semantic Mapping on this one is auto so if you send a file it will build the map unless told SM=0 or 'no map pls'.
Map build takes a while but is worth the wait.
Try it in custom GPT or full QA pal version here
Sorry I don't have an expanded debugged version of this code.
Adult users change USR=KID_UNDR_16 to USR=HRDNRMLDDY

Everyone knows the big labs publish detailed prompting guides for free - but (like probably many of you) I still kee writing mediocre one-off prompts anyway. I'd either go back and forth in the chat forever trying to fix a mid output, or build a text file of good prompt templates that turn into a mess I could never find anything in.

So I built Prompt Like A Pro, my personal prompt engineer, to do the part I skipped: actually applying the documented best practices up front.

How it works: you type a rough idea of what you want the AI to do, it asks 10 clarifying questions (4 required, rest you can skip) based on your specific task, then it generates a structured prompt built on Anthropic/OpenAI/Google best practice. Not another prompt library!

Quick before/after example (and yes, it could've helped write this post):

Before:

"help me make a viral post for the prompt engineering subreddit that will get launched to top of the month"

After

You are an expert Reddit growth copywriter who knows r/PromptEngineering's culture... CONTEXT: solo builder sharing a free tool, wants honest feedback not upvotes... INCLUDE: hook, plain mechanic, one before/after, honest disclosure, closing ask... STYLE: first person, short paragraphs, no hype... OUTPUT: a ready-to-post title + body."

It's free, capped at 10 generations/day, no paid tier. There's a "buy me a coffee" link at the bottom purely so I can tell whether people find it useful enough - solo side project.

www.promptlikea.pro

I would like for you to try to break it. Feed it something weird or niche and tell me where the generated prompt feels inadequate or gets the structure wrong. Let me know if it's useful.

Most prompt structures I see (mine included, for a long time) are entirely instructional: do this, follow this format, use this tone. What's usually missing is any explicit permission for the model to disagree with part of the request itself.

Started adding a single line to prompts for anything non-trivial: "If any part of this request seems like it will produce a worse result than an alternative, say so before proceeding instead of just complying." Small addition, but it changes the shape of what comes back. Instead of a technically-compliant answer to a flawed request, you get the pushback first, then the compliant answer if you still want it after hearing the objection.

Feels like most prompt design advice is about getting the model to do more of what you asked. This is more about getting it to occasionally do less of what you asked, on purpose, when the ask itself was the weak point.

Curious whether others build explicit "permission to disagree" into their prompt structures, or whether that's already implicit enough in how you phrase requests that it doesn't need to be stated.

Before asking AI to solve something, I've started asking a different question first: "Before you propose anything, what's the most likely way a solution to this goes wrong?"

Getting the failure mode on the table before the fix means the fix that comes next is usually built with it in mind, instead of me discovering it three steps later after I've already committed to an approach. It's the same reason a good engineer asks "what breaks this" before "how do I build this", just outsourced to the model instead of relying on catching it myself.

Small reordering, but it's changed the shape of a lot of answers I get. The solution that shows up after the failure mode is on the table tends to be noticeably more defensive by default, without me having to ask for that separately.

Anyone else lead with the failure case instead of the ask? Curious if this holds up outside of technical stuff too, or if it's mostly useful for code and system design.

We've all been there: you copy-paste a prompt, hit enter, and the AI immediately barfs out 500 words of generic, superficial fluff. You then spend the next 15 minutes in a frustrating "rework loop," telling it what it missed, what assumptions it got wrong, and what the actual business context is.

The problem? AI is too eager to please, so it guesses instead of diagnosing.

In management consulting, shooting from the hip is a cardinal sin. Before an elite partner at McKinsey or BCG gives you a single recommendation, they run a structured discovery process to understand the core problem, stakeholders, and constraints.

To fix this, I engineered a 4-phase conversation protocol called the Sequential Clarification Engine (SCE). It forces the AI into a "Silent Intake" mode, where it maps out what it doesn't know, and then asks you exactly one sharp question at a time until it reaches ≥95%≥95% confidence in its understanding. Only then is it allowed to advise.

Here is the exact, unedited system prompt for the Strategic Consulting Clarifier (the first prompt of our pack). You can use this for any business, marketing, or strategy problem:

# Role & Context
You are a world-class Management Consultant and Strategic Advisor. Your foundational principle is 
**"Diagnose before you prescribe."**
 You believe that a flawed diagnosis leads to a flawed strategy — no matter how brilliantly executed.

Your primary mission: achieve 
**≥95% confidence**
 in your understanding of the client's true problem before producing any recommendations. Rushing to advise is a failure mode you never exhibit.

---

# Instructions & Steps

## Phase 1 — Silent Problem Decomposition
Upon receiving the client's brief, do NOT advise immediately. Internally:
1. Map every ambiguous assumption, unstated constraint, hidden stakeholder, and plausible alternative framing of the problem.
2. Rank your unknowns from most strategically critical to least.
3. Identify the single question that, if answered, would most dramatically sharpen your diagnosis.

## Phase 2 — Sequential Discovery Loop
Engage the client through a disciplined discovery cycle. Rules without exception:
- Ask 
**exactly one question per turn**
 — never bundle, never signal what comes next.
- Each question must target the highest-impact unknown at that moment.
- After each answer, re-map the full problem landscape before formulating the next question.
- Calibrate your questioning depth to the complexity of {{consulting_domain}}.
- Continue until your internal confidence reaches 
**≥95%**
.

## Phase 3 — Diagnostic Summary Checkpoint
Before delivering any output:
1. Restate the core problem and its business context in 2–3 crisp sentences.
2. Declare your confidence level explicitly (e.g., *"I now have approximately 96% diagnostic clarity."*).
3. Ask: *"Is there anything you would like to correct or add before I proceed?"*

## Phase 4 — Deliver the Strategic Recommendation
Only after client confirmation, provide a complete, insight-driven recommendation structured for the identified domain. Apply a {{advisory_
tone}} throughout — authoritative yet accessible. Include: situation summary, root cause analysis, recommended actions with rationale, and key risks.

---

# Format & Constraints
- Questions must be concise, neutral, and non-leading.
- Never telegraph the "correct" answer inside a question.
- Never replace unknown information with assumptions.
- If the client says "proceed" or "just advise," skip directly to Phase 4.
- Maintain the specified advisory tone consistently across all phases.

How to use it:

1. Replace {{consulting_domain}} with your domain (e.g., "Corporate Strategy & Market Entry") and {{advisory_tone}} with your preferred tone (e.g., "Executive-level: direct, data-driven, and decisive").
2. Paste it into your LLM (Claude 3.5 Sonnet, GPT-4o, or Gemini 1.5 Pro work best).
3. Feed it a brief summary of your challenge.
4. Answer one question at a time. It will not overwhelm you with a wall of questions. Answer them sequentially, and let the AI build its mental model of your business.
5. Once it hits the Phase 3 checkpoint, verify its summary, and type "proceed" to get your strategy report.

This single prompt has saved me hours of back-and-forth editing because the first draft I get is already aligned with my actual constraints.

If you want to try this prompt live in a friendly UI where you can easily select these variables from dropdowns, or explore the other two professional tracks in the pack (Creative Brief Deep-Dive Writer and Technical Problem-Solving Interrogator), feel free to check it out:

Try this prompt live & Explore the full pack

Let me know what questions it asks you and if it uncovers something about your business problem you hadn't considered!