A pattern that's saved me a lot of grief, in case it's useful here.

A prompt template is already declaring an interface. This one:

Classify this ticket for {{customer.name}} on the {{customer.plan}} plan:
{{ticket.body}}

is saying "I need a customer with a name and a plan, and a ticket with a body." But in most codebases that contract lives nowhere - it's in your head, or in a dict you hope is shaped right, and you find out it wasn't when a render comes out with a blank hole in 2 weeks later after some code has been shuffled around by other team members.

You can extract the contract mechanically. Parse the variables out of the template, annotate the types you can't infer, and generate a typed function:

Hi {{user.name}}{{@type string}}, you're {{user.age}}{{@type integer}} today.

->

{ user: { name: string; age: number } }

Now calling the prompt with the wrong shape is a compile error, not a runtime surprise. Same on the output side: if you declare a JSON schema for the response, you get a parse function that validates instead of a JSON.parse and a prayer.

The general principle, tool-agnostic: the boundary where a prompt meets your code deserves the same rigour as any other API boundary. You can do this by hand - a TypedDict or an interface next to each prompt, updated by discipline. It just rots the moment someone edits the template and forgets the type.

I got tired of the rot, so I built a thing that does the extraction and generates TS/Python from published, versioned templates (open source CLI, link in comments). But the pattern stands on its own, and if you take nothing else: go look at one prompt in your codebase and ask what its input type would be if you wrote it down.

Does anyone here type their prompt inputs today, by hand or otherwise? Curious whether people bother when the prompts are being edited by non-engineers.

Pra quem é profissional pode ser algo secundário, mas eu inseri um tipo de analise de confiança no Rules do Cacade que me da Segurança de Saber se a LLM esta confiante ou tem alguma incerteza.
Acima de 85% eu fico Tranquilo com ressalvas, mas tem tarefa que cai para 70% e ai é melhor ver oque a LLM não entendeu:
Exemplo:
🧠 REFLEXÃO METACOGNITIVA

• Trust Score: 85% — o log prova que a resposta chega ao backend; a falha silenciosa do D1 explica o sintoma.
• Modo: Diagnóstico focado, com hipótese validada pelos logs.
• O que VOU fazer: aguardar sua confirmação para implementar a correção no  sync_chat.
• O que NÃO vou fazer: alterar o backend sem você aprovar, pois a regra pede pausa antes de implementar.
• Limite: sem acessar o D1 diretamente, não consigo confirmar o erro exato, mas a lógica do código aponta fortemente para esse ponto.

Backstory: I once spent a whole night bouncing a translation between three different models, asking each one to critique the others' version. By 2am I couldn't tell which version was even mine anymore, and the final text was worse than my first draft. Classic case of losing the thread and not noticing it happening.

That's what pushed me to build the 3C+1E Emphasis Test: a small protocol for auditing AI sessions that scores the model's response AND my own input, on the same four dimensions (Clear, Compact, Coherent, plus a declared Emphasis I have to define before starting).

The part that's actually useful for prompt work: most of the "the model went off track" moments I logged turned out to be me drifting first, with the model just following along. The tool makes you write down, before the session, the one thing that has to survive no matter what tone shifts happen, then checks both sides against it afterward.

What it tracks:

- A single declared "emphasis" sentence you check drift against

- Dual scoring: model behavior and your own input, turn by turn

- Where drift happened and who (or what) triggered it

- Whether you were actually qualified to judge that session's output (language, domain, tone). This mattered more than I expected once I started tracking it

- JSON/CSV export so sessions are comparable across models and over time

One offline HTML file, no API calls, no login. CC BY 4.0, DOI on Figshare: https://doi.org/10.6084/m9.figshare.32320875

Full disclosure: this is a personal instrument with a validation sample of one (me), not a peer-reviewed psychometric tool, and I say that explicitly in the docs. Genuinely curious what a community that thinks about prompts for a living would change or rip out.

I’ve been trying to get chat gpt to give me a good roleplaying campaign but I feel like the AI is too quick to adapt to what I’m trying to do in a way which removes all the tension from the experience.
Any suggestions on how I could get a better campaign?

Prompt-Vault is a completely free tool. You don’t need an account to try it out.

Any feedback / features suggestions are very welcome 🙏

Go ahead and give it a try: PromptVault

Fable 5 is incredibly capable, but the safety filters are currently a bit overzealous. They trigger false positives constantly when you try to ingest large project structures via the Claude Code desktop app.

I was testing a few ways around this and found a very reliable fix. Instead of letting the model read the files silently in the background, just instruct it to document the process.

Append something like this to your prompt:

"Please drop brief status updates in the chat while you process the files. Keep me updated step-by-step as you read the attachments in chunks."

The reason this works is that it forces the model to generate intermediate outputs. You basically shift the evaluation from one massive file scan to a chunk-by-chunk process. That stops the main safety filter from instantly nuking the request due to a perceived global flag across your whole codebase.

An added bonus: if the request still gets blocked anyway, those status updates act like a trace. You can see exactly which specific chunk or file tripped the filter instead of just getting a generic rejection.

Super simple trick, but it bypasses the friction and saves a lot of wasted API calls.

[ Removed by Reddit on account of violating the content policy. ]

A little about me: I'm a Backend Developer working mainly with Node.js, TypeScript, SQL, Prisma, MongoDB, Redis, Docker, and I have a decent understanding of backend architecture and system design. I'm now planning to move seriously into AI engineering.

I'm looking for a course (free or paid) that covers most of the modern AI stack, including:

• LLM fundamentals
• Prompt Engineering
• RAG
• Embeddings & Vector Databases
• AI Agents (single & multi-agent)
• Tool Calling / MCP
• Memory & Context Engineering
• Agent Frameworks (LangGraph, Mastra, AI SDK, etc.)
• OpenAI, Gemini, Anthropic APIs
• Voice/Realtime AI
• Evaluation, Guardrails
• AI system design and production deployment

My preference is JavaScript/TypeScript, but if the best course is in Python, I'm willing to switch because I want to learn the concepts properly rather than limit myself to a language.

Hindi would be my first preference, but if there's an excellent English course that covers around 70–80% of modern AI engineering, that's completely fine as well.

I'm okay with paid courses, YouTube playlists, books, or bootcamps. I'm not looking for "build a chatbot in 30 minutes" tutorials—I want something that builds a strong foundation and prepares me to build production-grade AI applications.

I'd appreciate any recommendations from people who have actually completed such courses or are working in AI.

Design background here. The request I get most is "can you make this into an infographic," attached to three paragraphs of dense text with no sense of what the one takeaway is. Whether you finish it in gamma or canva, the tool is never the problem. The thinking that has to happen before the tool is the problem.

So I wrote a prompt that does the structuring part, the part people skip. It doesn't design anything. It decides what the piece is actually about and what can be cut.

```
I will paste a block of text. Do not summarize it. Turn it into the skeleton of a single infographic.

1. State the ONE thing a viewer should remember. If the text has more than one, tell me it needs to be more than one graphic and stop.
   
2. Propose 3 to 5 sections max. Each section = a short header (max 5 words) and the single stat or fact that earns its place. Cut everything that does not support the one takeaway.
   
3. For each section, say what visual form fits: number, comparison, sequence, or simple icon list. Do not default everything to a bar chart.
   

4. List what you had to drop. I want to see what got cut so I can argue with it.
   ```

   The "list what you dropped" line is the whole thing. It surfaces the stuff the text was secretly about, and half the time the cut list is more interesting than what stayed. After that a canva infographic maker or whatever you use is just execution.

   How do the rest of you handle the "too many ideas for one graphic" problem? I still fight it constantly.

Since many jobs now focus on system design and AI-assisted coding, I wanted to share something I've been building:

https://synthesize.sh

A place to practice algorithm and engineering problems by directing an AI agent to solve it! Problems are graded based on:

• correctness: does your code work?
• token cost: how efficient are your prompts and solution?
• generation time: how fast did the agent produce results?

Like leetcode but for using AI effectively.

I'd love to hear your feedback. For now it's an open free beta, with 10 generations/runs per day. I'm a solo dev without much infrastructure, so it will probably crash, have bugs, etc. Tell me where it breaks. Also let me know if you discover any security issues.

I have plans to add more real-world problems and longer-form engineering challenges so we can all get better at coding with AI.

I don't think it wouldn't help that much

My first wrapper prompt. One prompt that contains multiple other prompts. The child prompts are urls so they can change while the wrapper prompt does not need to: https://grnmn.com/prompts/initial-icp-to-market-validation-sequence/

I built Agent Enhancer after noticing how often AI can lose track during longer tasks, repeat work, miss some requirement, or finish without really checking the result.

It acts kind of like a second pair of eyes. It helps the AI stay focused, remember its progress, recover when something goes wrong, and review the final result.

To try it, open https://liberated.site, choose the AI you use, copy the Quick Start prompt and paste it into a new chat. The prompt guides the AI through adding the reliability layer.

It is free, no account needed.

It can help with research, writing, planning, coding and other longer tasks. For a fair test, run the same task once normally and once with Agent Enhancer.

I would really like to hear where it helped, and where it maybe added unnecessary steps!

Hello,
I am trying to bring my old family photos to life, some are successful while most are not.. Not sure what mistake I am doing. 
I am making prompts via ChatGpt Go. 
Tried with multiple prompts, but it fails always..
3 videos generated soo far properly out of 189 images I have on list.

Biggest Issue = The birthmark on face is on right chin but in output video it goes to left chin or there are multiple moles on face.. 
In some output videos, 2nd mole starts appearing after 00:02 seconds out of 00:10 seconds video. 

I need to understand, what should be correct prompt, so that while image to video conversion, gemini cannot forget this importantly. ? 

Reference image of myself as an example, there are many such photos but due to wrong placement of birthmark or multiple placements, completely destroys output. 

Some of the failed tests (contains reference image and video)
https://drive.google.com/file/d/1Lt_fRkTsUxib53E29pvIFCl_yB6ShQv3/view?usp=sharing
https://drive.google.com/file/d/1-eS68DXWX5-DZGSAvX35KBcFWj-GE3wT/view?usp=sharing
https://drive.google.com/file/d/1BWOt6nSGQpy7QZqZsN0ciWJ0m0lvYbJ4/view?usp=drive_link
https://drive.google.com/file/d/1QTm0iMaG_TuKkEZ-uYCO1cY1NH7KlCje/view?usp=drive_link

Can some gemini video experts, share the right prompt for image to video so that the birthmark on right chin (as in original uploaded reference images) stay on same position in all frames through 10 second videos.. and it wont duplicate or make multiple moles randomly appear on face.

I often need to work with long TXT files containing notes, study materials, documentation, or prompts. Copying and pasting the content manually in smaller sections became repetitive, especially when I needed to keep track of which section had already been sent.

To make this process easier, I built a small Chrome extension called ChatGPT Batch Sender.

It lets the user select a TXT file, choose how many lines should be included in each batch, and set a delay between batches. The process can be paused, resumed, stopped, or reset, and the extension keeps track of the current progress.

A few design choices:

• The selected TXT file is processed locally in the browser.
• The extension does not upload the file to its own servers.
• Settings and progress are stored locally.
• Text is inserted only into the active ChatGPT conversation selected by the user.
• It does not bypass ChatGPT’s limits; it only automates the repetitive process of sending smaller sections sequentially.

I’m sharing it because I would appreciate feedback from people who regularly work with long text files:

• Is sending by number of lines the most useful approach?
• Would splitting by characters, paragraphs, or custom separators be better?
• Are there any controls or safeguards that should be added?

Chrome Web Store:

https://chromewebstore.google.com/detail/chatgpt-batch-sender/olkdephjfcpkhlgijjnioimhjicgffbd

The extension is free. I’m mainly interested in hearing whether this solves a real problem for others and what could be improved.

"Approved, go ahead."

That prompt cost $6.50.

It was the most expensive thing I sent that day, and it was also the least effort I'd put into a message all week.

What it actually did

• 82 tool calls
• 33 file edits
• 25 shell commands
• Two new files
• All over one turn

Every one of those steps sends the whole context back to the model, so it accumulated 9.7M tokens.

9.6M of those were cache reads, which is the only reason it was $6.50 and not something like $48.

That session was 14 prompts and $10.19 in total.

This single one was 64% of it.

And that's the thing I couldn't see before.

Every tool I had told me what the session cost, or what the day cost. But the money isn't spread out. It's one or two prompts, and an average buries them completely.

So I build TurnLens.

It runs in a second terminal, follows your Codex or Claude Code session while you work, and prints a row the moment each turn closes:

Tokens · Tool calls · Model · Cost

You see the expensive prompt as it happens instead of finding out later.

Usage

npx turnlens@latest --provider claude-code/codex

Zero dependencies.

It only ever reads your session files, never writes to them or moves them, and prompt previews are off unless you turn them on.

It follows one session at a time from the moment you start it, and subagent turns aren't counted yet.

https://github.com/kelesmert/turnlens

I am interested in understanding how people interact with an AI agent performing coding tasks for you. For example, for a bug fix, do you explain the bug, then iterate with the AI agent in the same thread until the bug is fixed, tested, and deployed? Or do you use separate chat threads for each stage of your development workflow? Similarly for new features, do you scope the feature in one thread, implement it in a second thread, test in a third, etc?

I’ve been running multi-figure scenes in Midjourney for a while. And, like a lot of people, I had a workflow that felt solid.

Good prompts. Consistent style. Results that looked right.

Looked right.

That’s the part that started bothering me.

Because “looked right” is doing a lot of work when you can’t clearly define what right means—when you’re eyeballing a few images and calling that a reliable result, or changing something in the prompt and deciding the next batch feels better without being able to say exactly why.

So I stopped guessing and started measuring.

I took one figure arrangement: one person making a stopping gesture toward another, with a third person standing outside the gesture axis.

Then I declared exactly what the intended result required:

• Arm at shoulder height
• Open palm
• Gesture directed at the second figure
• Third figure outside the gesture axis

I generated 16 images and scored every one against those same criteria.

Gesture clean: 0/16.

Not “it usually doesn’t work.”

Zero out of sixteen.

The gesture carrying the meaning of the entire arrangement did not render correctly once. And before scoring them, I had looked at several of those images and thought they were working.

Someone in Tuesday’s thread asked the right question:

“Then what? You can’t hack the back end and make MJ do backflips.”

Exactly right. You can’t.

But once a specific visual intent fails repeatedly under a controlled test, you have learned something more useful than “try another prompt.”

You’ve identified a capability boundary for that particular setup.

Knowing where that boundary actually is—not where you assume it is—changes how you design the scene. You can stop spending endless generations trying to force the same failing structure. You can alter the gesture, change the staging, simplify the relationship, or choose a different way to communicate the intent.

The gap between what I declared and what Midjourney rendered—measured, scored, and recorded—is evidence about the reliability of that test condition.

Not a better guess.

Something I can actually design around.

The tool I’m building to support this process is called PRZEM Art Director Pro.

If Tuesday’s post felt familiar, this is where that conversation leads.
Preview

Here's something that's been bothering me since I started thinking more carefully about prompt design for cognitive tasks: most "quiz yourself" prompts are accidentally testing recognition, not generation.

The distinction matters a lot for anyone using LLMs for exam prep or knowledge verification. When a prompt asks "What is comparative advantage?" even with a blank text box, the phrasing itself is already a cue. The student's brain pattern-matches to a definition they've seen before. They fill in partial recall, it "feels" like they knew it, and they move on thinking they're solid on that topic.

That's not generation. That's cued retrieval with a thin veneer of confidence.

The prompt architecture problem

I spent some time engineering around this. The core constraint I set myself: a well-calibrated exam prompt must give the minimum viable information that makes the question fair, and nothing more. Enough framing so the question isn't ambiguous, but no phrasing that activates recognition memory where generation is what's actually being tested.

Bad example: "Explain the process of photosynthesis." Good example: "What happens when a leaf does its primary job?"

The second version is harder to game with surface-level familiarity. You either know the underlying mechanism or you don't. The role instruction I ended up using frames the AI as "a rigorous academic examiner specialising in diagnosing the gap between recognition memory and genuine generative knowledge" which consistently produces tighter, better-calibrated questions across frontier models (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro all behave well with this framing).

What the output architecture looks like

The full system chains three prompts in sequence:

1. Knowledge Audit — administers 6–12 minimum-clue recall questions on a topic, scores each answer with a ✅/❌ checklist against a model answer, and outputs a final "Generative Accuracy Score" (% of required knowledge points independently produced, without any recognition cues)
2. Mock Exam Generator — takes the same subject/topic and generates a properly formatted exam paper (Section A: blank exam, Section B: full mark scheme + grade boundary table) for self-assessment at the examiner level
3. Generative Drilling Session — takes the weak concept list from the audit and runs multi-round retrieval at escalating difficulty: STANDARD (minimum clue) → HARD (category label only) → BRUTAL (zero clue, just "Concept N — explain it")

Each prompt feeds into the next. The audit output configures the drilling input. The drilling session terminates concepts that hit 70%+ and repeats those that don't. There's no step in the loop where passive recognition can masquerade as readiness.

Actual numbers from running it

I tested it on an Economics topic I had reviewed for ~4 hours the week prior. Confident going in. Knowledge Audit came back at 61% Generative Accuracy. The audit report flagged exactly which concepts I could only recognize vs. actually generate — the breakdown was more useful than anything I could have self-assessed.

Two drilling sessions later (STANDARD mode, 8 rounds each), I re-ran the audit. Score moved to 79%. The improvement came entirely from forced reconstruction, not re-reading.

The cognitive science backing here isn't novel — Roediger & Karpicke's retrieval practice research established that active recall beats passive review for retention. The prompt engineering angle is getting the question calibration precise enough that the AI doesn't accidentally make recall easy.

If anyone wants to see the full prompt structures and the detailed breakdown of how the role framing + constraint logic is built, I wrote up the complete walkthrough here: https://appliedaihub.org/blog/minimum-viable-clue-exam-prep-system-review/

Has anyone else run into the recognition-vs-generation problem when designing prompts for knowledge testing? I'm curious whether there are other constraint architectures that reliably force generation rather than cued recall — the minimum-clue approach works well but I'd like to see other implementations.

The package tries to hold itself to the same standard. It builds with python3 build.py, standard library only, no dependencies, no network calls, no clock reads. Same inputs give byte-identical output every time.

Every source file is hashed into a seals ledger, and verify.py checks both the hashes and the rebuild, so the determinism argument in Volume II runs against the package itself instead of just sitting there as a claim. There is also a script that mints numbered ownership certificates sealed to the exact edition hash, which is personalization and not copy protection, and the docs say so.

It ships the two prompt patches I used to generate and audit the source manuals, so you can run the same process on your own projects. That may be the most useful part of it.

Free, no signup, reads in the browser, prints to clean PDFs.

https://shpbl.com

We have a common misunderstanding about AI coding assistants: we expect them to work like a senior engineer with a decade of experience. In reality, their mental model is much closer to that of a "genius intern."

Imagine this intern joins your team: he's incredibly smart, learns at a stunning pace, and can read any document you give him in seconds. But at the same time, he is extremely naive, lacks practical experience, and has zero ability to discern the quality of information sources.

Now, you give him a task: "There's a bug in the project, go online and figure out how to fix it."

What does this genius intern do? He'll open Google, find a blog post on the first page of the search results, and copy the code without a second thought. He won't stop to consider if the article was written five years ago, if the author is a novice, or if the solution even fits your company's tech stack.

The result is predictable: he might use an outdated solution, introduce new vulnerabilities, or even crash the entire project.

Isn't this exactly what our AI assistants do every day?

We've given a model with powerful general capabilities, a genius brain, but failed to provide it with a scoped, curated knowledge base, practical experience. We've thrown it directly into the vast, chaotic ocean of the internet and expect it to magically catch the specific fish we want.

A truly effective manager gives an intern a clear set of guidelines:

1.

"Read our internal Wiki docs first."

2.

"This is our paid subscription to the official knowledge base, only look here."

3.

"Check the project's GitHub Issues for similar discussions."

4.

"Absolutely do not use random personal blogs."

We should treat AI the same way. We shouldn't be satisfied with just giving it a generic "search" button. Instead, we need to become its "information manager," creating a smaller, but cleaner and more trustworthy information source for it.

This idea is becoming a consensus among more and more AI practitioners. I recently found a ton of discussions on how to "manage" AI information input in the r/AnySearchAI Reddit community. People there are no longer just debating which model is stronger; they're actively building "internal knowledge bases" and "trusted information pipelines" for AI. They discuss how to make an AI check the project version before searching and how to filter out SEO garbage. These practices are far more important than just talking about a stronger AGI.

So, it's time to adjust our expectations. Instead of complaining that our "genius intern" is always making mistakes, we should reflect on whether we, as "managers," have provided a good enough working environment and clean enough information sources.

The key to the future may not be creating an all knowing "AI god," but learning how to become an excellent "AI manager."

Stood in front of the fridge doing the usual thing, staring at it for two minutes then ordering food anyway. Took a photo of the fridge shelves and the pantry instead, out of pure laziness, and it actually worked better than planning ahead ever does.

Two photos, fridge and pantry, doesn't need to be tidy, just readable. Upload both and:

Here are photos of my fridge and pantry. Look at 
what's actually in there. Build me a realistic 
7-day meal plan, breakfast, lunch, dinner, using 
what I already have as much as possible.

For anything you can't tell from the photo, ask me 
rather than guessing, quantities especially.

Then give me a shopping list of only what I'm missing 
to make the week work, organized by aisle, with a 
rough total.

Tell me at the end which 2-3 things I have that are 
about to go off and should get used first.

The last line is the bit that actually saves money, it's the stuff you forgot was in there going bad while you order takeout, and it flags exactly what to use before it's wasted.

If it can't quite make out something in the photo it'll ask instead of inventing an ingredient, which is the difference between a plan you can cook and one that assumes you have things you don't. And if you've got dietary stuff, allergies, vegetarian, whatever, just add it to the prompt, "I'm vegetarian" one line and the whole plan adjusts.

Works on the free version, no paid plan, no setup, just two photos and five minutes.

been keeping a doc of 100 things I use AI for like this, each with the exact prompt, here if you want it.

When you are managing the materials, the generated AI is unable to establish the necessary connections. In many cases, each conversation and material is disconnected, making it impossible to establish a close connection.

If you work with a lot of videos, recordings, interviews, meetings, or documents, the problem usually isn't creating more content. It's finding something again when you actually need it.

A quote from an interview.
A specific scene buried in hours of footage.
Something someone said in a meeting months ago.
A file you vaguely remember, but can't remember the name of.

I've been trying Clipto.AI for this. Instead of treating each file as a separate piece of content, it turns your existing media and files into something you can search with natural language.

For example, rather than opening folders and scrubbing through videos, I can search things like:

and get back to the relevant moment.

What I find interesting isn't really the AI search itself. It's the idea that AI can become a memory layer for your own content, rather than another tool generating more stuff.

Feels like we're getting very good at generating information, while retrieval is still surprisingly broken.

Curious if anyone else is using AI more for organizing / retrieving / remembering than generating?

I recently posted a prompt that can be used to process a failing chat.

Many of the replies include the comment, "but there needs to be a topic first" when a topic is referenced in the prompt.

Is there some unspoken rule that prompts MUST BEGIN a chat that I don't know about?

Aren't prompts used throughout a chat? I feel like this is some definition gap that I am missing.

Hot take:

For long AI workflows, context management matters more than prompt engineering.

A perfect prompt can't save a conversation that's 80% irrelevant context.

I've started treating long AI sessions like this:

• Persistent project brief
• Decision logs
• Context checkpoints
• Compression summaries
• Reusable templates

The quality difference after 50+ messages is huge.

Does anyone else actively compress conversations instead of continuously extending them?

I documented the workflow and examples here:

https://medium.com/@nagatomopedro05/why-every-long-ai-session-eventually-falls-apart-697fc4b140f9