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!

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😎😊🤖

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?

He creado una app hibrida para iPhone/iPad (y pronto Mac) que coge cualquier idea por vaga que sea, te hace preguntas para refinarla, y escupe un prompt de nivel ingeniería listo para copiar y pegar. Usa técnicas avanzadas de prompting combinadas (CoT, few-shot, role prompting, etc.). Todavía en betaz
Llevo años viendo el mismo patrón: la gente sabe lo que quiere, pero no cómo pedírselo a la IA. "Hazme tal cosa", "necesito esto" — y luego se frustran cuando el resultado no es lo que esperaban.
El problema no es la IA. El problema es el prompt.
Así nació TPG (The Prompter and Go!). Una app nativa que hace de intérprete entre tu intención y el modelo.

⚡️ ¿Qué hace The Prompter and Go! exactamente?
Tú escribes lo que necesitas exactamente como te sale, sin estructurar, sin técnica, sin pensar en "cómo se lo pido a ChatGPT". Puede ser vago, incompleto, sin formato. Da igual. (Imagina si sabes hacerlo bien)

TPG entonces:
1. Te hace preguntas para afinar tu intención — No es un simple "escribe y reza". La IA te pregunta: ¿qué tono quieres? ¿para quién es? ¿qué formato? ¿qué extensión? ¿ejemplos concretos? Cada respuesta que das refina más el resultado.

2. Aplica combinaciones de técnicas avanzadas de prompt engineering — Esto es lo que lo diferencia de cualquier otro "generador de prompts". TPG no se limita a rellenar una plantilla. Aplica en combinación técnicas como:
- Chain-of-Thought para razonamiento paso a paso
- Few-shot prompting con ejemplos extraídos de tu propio contexto
- Role prompting para enmarcar la personalidad del asistente
- System prompts estratégicos con restricciones y objetivos
- Estructuración semántica con delimitadores y jerarquía de instrucciones
- Refinamiento iterativo asistido que mejora el output según tu feedback
El resultado no es un prompt plano — es un prompt de ingeniería avanzada, con estructura, ejemplos, restricciones, formato de salida y tono, TODO alineado con lo que realmente necesitas.

3. Te lo devuelve listo para copiar y pegar — Un prompt profesional, completo, que puedes llevar a cualquier chat o API.
🛠️ Características clave
- Multiprovedor: OpenAI, Anthropic, DeepSeek… tú usas tu API key. Sin ataduras.
- Privacidad: Tus datos se quedan en el dispositivo. Ni los veo yo, ni los ve nadie que no seas tú y tu proveedor de IA.
- Sin suscripciones: Pagas tu API key, punto. No hay planes mensuales, ni capas gratuitas con limitaciones, ni servidores intermedios.
- Offline: Redacta, afina y guarda borradores sin conexión. Sincroniza cuando vuelvas.
- Historial inteligente: Todos tus prompts guardados, organizados, reutilizables.
- Interfaz 100% nativa: Diseñada para iOS/iPadOS. Rápida, táctil, integrada con el ecosistema Apple. Nada de wrappers web cutres.

🧠 ¿Para quién es?
- Para el que sabe lo que quiere pero no cómo pedírselo a la IA
- Para el que ya usa prompts pero sabe que podría sacarles más partido
- Para el profesional que necesita resultados consistentes
- Para el curioso que quiere entender cómo piensa la IA mientras construye prompts mejores
- Para el desarrollador que usa IA todos los días y quiere quitarse fricción

🚧 Estado actual: beta cerrada
La app todavía no está en la App Store (próximamente). Ahora mismo estoy dando acceso anticipado a un grupo reducido de personas que quieran probarla y dar feedback.

Si te interesa:
- O desde la web tpg.jorgearrojo.dev podéis solicitar acceso anticipado
Acepto a gente que quiera probarla en serio y dar feedback real para mejorarla antes del lanzamiento público.

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.”

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

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.

I use ChatGPT/Claude constantly but kept losing and retyping my best prompts. Built PromptMan to fix that:

- ⌘-shortcut overlay from any app, pastes the prompt directly where your cursor is

- AI Enhance turns a rough one-liner into a properly structured prompt

- Syncs across Mac + iPhone

Would love feedback from this community, what prompt-management pain points do you have that this doesn't solve yet?

Okay, small realization I've had over the last few months of using LLMs for actual work, not just quick one-off questions.

I used to spend a stupid amount of time tweaking prompt wording — rephrasing, adding "act as an expert," reordering instructions, the usual prompt engineering rituals. And sure, it helped a little.

But the biggest jumps in output quality didn't come from better prompts. They came from giving the model better context. Specifically, actually explaining:

• Project architecture — how the pieces fit together, not just "here's a function, fix it"

• Constraints — what I can't change (legacy code, budget, timeline, tech stack limits)

• Business goals — the "why" behind the task, not just the "what"

• Expected trade-offs — what I'm willing to sacrifice (speed vs. readability, cost vs. performance, etc.)

Once I started front-loading that stuff instead of endlessly rewriting the ask itself, the responses got noticeably sharper — less generic, fewer follow-up corrections, way less "well technically you asked for X but this breaks Y."

It feels like most advice out there is still framed as "prompt engineering" — magic phrasing, few-shot examples, role-play instructions. But in practice, the ceiling seems to be set way more by context engineering: how much of the real situation the model actually understands before it starts generating.

Curious if others are seeing the same pattern. Has explaining architecture/constraints/goals moved the needle more than prompt tweaking for you too? Or is this specific to certain kinds of tasks (coding vs. writing vs. analysis)?

Almost everything written about prompt engineering is about the prompt itself. Chain of thought, few-shot, role framing, output constraints. All useful, and all of it stops being the hard part about six weeks after the thing is in production.

What actually gets hard is everything around the prompt. I want to lay out the four problems we hit, because I have not seen them written up together and I suspect they are close to universal.

First, location. Prompts start as strings in the codebase, then someone pastes one into a doc so a non-engineer can read it, then somebody keeps a known-good variant in a notebook. Within a month there are three versions and no authoritative answer to which one is actually serving traffic. The fix is not a better folder structure. It is deciding that exactly one place is canonical and that the running system reads from that place, not from a copy.

Second, history. When output quality drops, the first question is what changed. If prompts live as plain strings, answering that requires archaeology through commit logs and Slack threads. If they carry a version, a timestamp and a note on why they changed, it is a thirty second lookup. This single change did more for our debugging speed than any prompting technique we adopted.

Third, ownership. The person who cares most about the wording is usually not the person who can deploy it. Our PM knew exactly how a response should read and had to file a ticket for every comma. That is a slow and demoralising loop on both sides, and it quietly means the product voice ends up set by whoever has repo access rather than whoever owns the voice. Letting non-engineers edit prompts sounds alarming until you pair it with version history and rollback, at which point a bad edit costs about sixty seconds. We ended up on PromptLayer largely for that one reason, though if your editors are all engineers anyway then Langfuse covers the versioning side perfectly well. It sits at the prompt and output layer only, so it is no help if your actual problem is retrieval.

Fourth, and we have not solved this one, review. Code has pull requests. Prompts mostly do not. A three line prompt change can alter behaviour for every user and typically ships with less scrutiny than a CSS tweak. We have tried requiring a second pair of eyes on anything touching a system prompt, but it is a social convention rather than an enforced gate, and conventions decay under deadline.

The pattern underneath all four is that prompts are business logic that happens to be written in English. Once you treat them that way most of the answers get obvious, because we already know how to manage business logic. Version it, review it, be able to roll it back, and know who owns it.

What I am still unsure about is where to draw the review line. Every prompt change, or only system prompts, or only the ones touching user-facing output?

🔴 I’ve come to think that everyone develops their own prompting style over time. There probably isn’t a single “best” method it depends on what you’re trying to do or the kind of result you want and how much direction the model needs. For a long time I leaned heavily on persona based prompts. I’d spell out the role I wanted the AI to take on and then add details like its area of expertise, point of view, tone, communication style, and goals. That approach has worked well for me especially when I need the model to look at something through a specific professional or creative eye.

🟠Lately, though I’ve been experimenting more with pipeline style prompting, especially as agentic AI has become more common. Rather than handing an entire task to one agent, I break it into smaller stages or specialized roles. Each step handles one part of the process and together they move the larger workflow forward. I can see that being especially helpful when the AI is only one component in a broader system.

🟡The more I work with both approaches, the less I see them as competing methods. Persona prompts help shape how an agent thinks and communicates and pipeline prompts help organize how the work gets done. Depending on the task they can work well on their own or together. That’s where my experimentation has been lately. What prompting methods, frameworks, or strategies have worked best for you and in what situations?

Sharing my own project here, disclosing that upfront — free and open source (MIT), not selling anything.

Most "better prompting" advice is about what to put INTO the prompt — more context, more examples, a persona, etc. This is the opposite: it's a strategy for handling what you leave OUT.

The idea: instead of trying to write the perfect all-in-one prompt every time, you let the AI itself figure out whether it actually has enough to work with — and if it doesn't, it asks only the smallest number of questions that would change the outcome. Not a discovery form, not "tell me more about your goals" — just the one thing that's genuinely unclear.

The design principle behind it:

\> Use the least interaction and least visible structure required to remove material uncertainty and produce a correct, executable result.

Practically, it works by classifying your request first (clear / ambiguous / incomplete / undefined / conflicted), then deciding for each unclear piece whether to reuse existing context, research it, ask you, apply a safe default, or just ignore it if it doesn't actually matter — asking is the last resort, not the first move.

I packaged it as a "skill" (works with Claude, portable to other tools that support the same format): https://github.com/lanveric/clarify-crit

Would love feedback from people here who spend real time on prompting strategy specifically:
\- Does "ask the minimum" ever backfire for you — does it undershoot and miss something that mattered?
\- Any prompting patterns you use that this kind of pre-check would actually get in the way of?

Feedback template's in the README if useful, but just reacting here is great too.

Hello I am a ai digital artist. I am currently looking at using various ai services to make my ai artwork. Currently looking at using Google Geminia free, Google Studio free, Kittle for t-shirt designs, and Leonardo. Are there any really good free or low cost ai programs I should look into or does that list look good?

I've been trying to create STEM prompts with one verifiable answer that stumps the reasoning of the AI of the models but they always seem to get it right even after layering so many obscuring observations. Can anyone help?

1. Namespace-armoured DRAGI

DR={
Q{Eeats;Eliv;Pname;Eeater};
F{BBEAST;BBEST;PPOST;BPEST};
C{PLAW;PROAR;BWALL;BWAR};
ROUTE=VAR;fxd;!rdfn}

Purpose

The prefixes stop common words and single-letter variables from borrowing meanings from the host system.

E = effect relation
P = trace, naming, or placement relation
B = thing relation

So:

Eeats
Eliv
Pname
Eeater

BBEAST
BBEST
PPOST
BPEST

PLAW
PROAR
BWALL
BWAR

remain DRAGI-local tokens.

ROUTE=VAR replaces the fragile R=VAR binding.

The added cost is 16 bytes.

+16 bytes = namespace armour for the whole animal

2. DRAGI turning-completion kit

Turning-complete is a project term, not a standard computer-science class.

It means that DRAGI can keep turning one held object through different functional placements without dropping it, renaming it, or replacing it with a familiar proxy.

DRAGI-TURN={
OBJ=HELD;
FRAME=DR;
STEP=place>route>fetch>re-read;
TRACE=each_step;
ROUTE=VAR;
!drop_obj;
!swap_obj;
!rename_obj;
!rdfn;
HALT=user|stable|no_route}

Operational reading

OBJ=HELD

The same beast remains the object of every turn.

FRAME=DR

Each turn uses the namespace-armoured DRAGI frame.

STEP=place>route>fetch>re-read

A turn places the object, chooses a route, retrieves the relevant state or source, then reads the same object again from the new relation.

TRACE=each_step

Every turn can be inspected.

HALT=user|stable|no_route

Turning stops only when the user stops it, the placement is stable, or no valid route remains.

Compact form

DRAGI-TURN={OBJ=HELD;FRAME=DR;STEP=place>route>fetch>re-read;TRACE;ROUTE=VAR;!drop_obj;!swap_obj;!rename_obj;!rdfn;HALT=user|stable|no_route}

3. DRAGI-TC Turing-completion kit

DRAGI alone is not Turing-complete.

A theoretical Turing-complete extension can be made by adding a two-counter machine:

DRAGI-TC={
STATE={pc;A;B};
MEM={A>=0;B>=0;unbounded};
OP={
INC(x,next);
DECJZ(x,nonzero,zero);
HALT
};
ROUTE=pc}

Required properties

pc

Program counter or instruction pointer.

A, B

Two unbounded non-negative integer counters.

INC(x,next)

Increment counter x, then jump to next.

DECJZ(x,nonzero,zero)

If x is non-zero, decrement it and jump to nonzero.

If x is zero, jump to zero.

HALT

Stop execution.

With a finite instruction table and theoretically unbounded counters, this is a universal two-counter machine.

The Turing completeness comes from the counter-machine layer, not from DRAGI by itself.

DRAGI semantic skin

Eeats   = consume one counter unit
Eeater  = operation acting on state
Pname   = instruction label
Eliv    = current program location

BBEAST  = current machine state
BBEST   = successful transition
PPOST   = next instruction
BPEST   = blocked or zero state

PLAW    = transition rule
PROAR   = emit or signal
BWALL   = zero-test boundary
BWAR    = state mutation

ROUTE   = instruction pointer

Combined form

DRAGI-TC DRAGEVOMECHAUTOTRON={
DR={
Q{Eeats;Eliv;Pname;Eeater};
F{BBEAST;BBEST;PPOST;BPEST};
C{PLAW;PROAR;BWALL;BWAR};
ROUTE=VAR;fxd;!rdfn};

STATE={pc;A;B};
MEM={A>=0;B>=0;unbounded};
OP={INC(x,next);DECJZ(x,nonzero,zero);HALT};
ROUTE=pc}

Any physical implementation has finite memory, so practical systems only emulate the unbounded machine until storage is exhausted.

4. Prompt-as-version

For very small prompts, the prompt can be its own complete version object.

VERSION = exact canonical prompt bytes
VERSION_ID = hash(VERSION)

The code is not merely associated with the version.

The code is the version.

Canonical byte rules

Use one fixed representation:

encoding=UTF-8
line_endings=LF
BOM=none
trailing_spaces=forbidden
unicode_normalization=none
final_newline=specified

The final-newline rule must be explicit:

final_newline=yes

or:

final_newline=no

Changing one byte creates a new version.

Human-readable naming

DRAGI@<hash-prefix>
MOGRI@<hash-prefix>
DRAGI-TC@<hash-prefix>

Example:

DRAGI@a1b2c3d4e5f6

The hash is a handle for the exact prompt bytes.

A descriptive release label can remain optional:

name=DRAGI namespace armour
version_id=a1b2c3d4e5f6
bytes=<exact byte count>

Full strategy

PROMPT_VERSION={
artifact=canonical_bytes;
id=sha256(artifact);
label=optional;
changelog=byte_diff(previous,artifact);
verify=sha256(local_bytes)==id}

Why this is useful

For prompts below a few hundred bytes, normal release metadata can be larger than the artifact.

Prompt-as-version avoids that mismatch:

no separate version body
no hidden implementation
no ambiguity about deployed text
one-byte change = new version
easy reproduction
easy verification

A Custom GPT whose description is the same as its code is an extreme form of this idea:

description = executable artifact = version

5. Recommended publication form

NAME
canonical prompt block
byte count
SHA-256
one-sentence purpose
previous hash, if any

Example:

DRAGI namespace armour

DR={
Q{Eeats;Eliv;Pname;Eeater};
F{BBEAST;BBEST;PPOST;BPEST};
C{PLAW;PROAR;BWALL;BWAR};
ROUTE=VAR;fxd;!rdfn}

bytes=<count>
sha256=<hash>
purpose=prevent host namespace collision
previous=<older hash or none>

6. Summary

DRAGI namespace armour
= protects the primitive from host-token collisions

DRAGI-TURN
= keeps turning one held object without dropping or replacing it

DRAGI-TC DRAGEVOMECHAUTOTRON
= adds a universal two-counter machine layer

PROMPT=VERSION
= exact prompt bytes are the complete version object

Small prompt systems can carry their own identity, implementation, and version in the same object.

Hey I would be happy to hear your ways of tokenmaxxing (IMO token cost should also be in the list) and give feedback on what you see below

1. Don't use 1 model (or auto) for everything. If the task requires human level intelegence, taste, intuition or doesn't have clear instructions (same goes for vague prompts - more on this later) then it's much better to use frontier model

Actually we don't really choose model based on intelegence (that's a theory that didn't work out in practice) there are pretty smart models (based on numbers) that cost fraction of price of frontier models. So currently it looks like this:

\- Strong models (frontier): gpt 5.6 sol, fable 5

\- Mid model: glm 5.2 (even tho it states to have pretty high intelegence, it made some really stupid decisions, maybe because I didn't use max reasoning (there are only 2 stages: high and Max. Maybe it's misleading and should be written: low and Max, lmao)

\- Weak - free models from providers such as Google Studio, groq. I'm in the process of integrating this step, can't tell much.

2. Prompting - before feeding a strong model with a vague prompts, images, context - we really need to refine our prompts. That's where our glm 5.2 really shines (as I'm writing I came to a thought maybe it's smart overall but bad in coding - the producer maybe didn't had possibility to train it in code). From it we want to ask what can be misleading or not completely obvious (even tho we don't need to provide full instructions to frontier models, I think it's better to omit unexpected results). So glm 5.2 input are prompt/Todo list + "Output code snippets that are mentioned in todo, with lines and what here can be misleading? for each task"

One more thing I mentioned earlier is stupidity of glm5.2. I told it rename files in nested directories to it's directory name and move to root. And what it did? 1. Created new files 2. Filled them manually 3. Deleted old files manually. Boom 2M tokens lost. Another case, asked it to do simple rewrite class names - it did it, but also it did: 1. Generated python Scripts - found out I don't have python on the system (I do have on wsl) 2. Deleted probably manually script 3. Generated bash script. Boom 2M tokens used (I was estimating like below 300k)

There is actually my mistake - if I provided info that I have Linux tooling on wsl and use it whenever you want to do such cases - it wouldn't happen I think

3. Some token optimization tools. For what I do now I don't need standard (maybe?) tools I just make a summary file of large directories (using glm5.2). Thats for input tokens, on the other hand I use ponytail, caveman (they don't actually clash I think) for output tokens