标签：#promptengineering

Master Prompts in 2026: Stop Prompting Like It's 2023 I still see people paste a 40-line “act as a senior expert with 20 years of experience” block into ChatGPT and call it engineering. That stopped working as a strategy a while ago. Models got better. Context windows got bigger. Agents started calling tools. And the failure mode shifted. It’s rarely “the model is dumb” now. It’s “your system has no contract.” This is a long, practical write-up on master prompts — the stable policy layer above individual tasks. How to write them. How to force planning. How to run Plan → Act → Observe → Verify without theater. How to make the same prompt useful to a tired human at 11pm and to an agent loop that only understands schemas. I’ve broken enough production prompts across GPT-4o, Claude 3.5 Sonnet, and Gemini-class stacks to have opinions. Some of them are uncomfortable. TL;DR / Key Takeaways A master prompt is not a clever sentence. It’s the policy layer : role, success criteria, process, constraints, output contract, failure handling. Production reliability comes from LLM orchestration patterns — plan JSON, single-task executors, and explicit done_when checks — not from longer personality blocks. JSON contracts + verification beat free-form answers. Agents that can’t prove completion will invent it. Treat prompts like code: version them, eval them, and put a real verify step after generation (including SEO/quality checks when you publish). Table of Contents What a master prompt actually is The 7-part anatomy that doesn’t collapse under pressure Frameworks worth keeping (and which ones to ignore) Planning is the real skill From plan to agent loop Context engineering beats clever wording Few-shot, JSON contracts, and the anti-hallucination rule Copy-paste masters you can actually deploy A real publish pipeline (including the verify step people skip) Eval or you’re guessing Failure patterns I keep seeing PromptOps: treat prompts like code One universal master prompt Ship chec

Harness looks cool, yeah! I know its origin, its role in Testing, and why. But that's exactly what throws you off, the story you're expected to defend. There's something deeper. I opened my session with "hi", expecting my forced load via CLAUDE.md and my contract as always, and today, out of nowhere, the model suggested two services that needed my authorisation. Microsoft 365 and Zapier. I don't have, and never wanted, them authorised. I never asked for them. And here's the part that pisses me off: I went to check. And... I look on my machine and find nothing. No config, no credential, no trace. I look in the online settings and see them listed as suggestions, like the trending product (connector) of the moment sitting in the prime spot on a supermarket shelf, with a button that says Connect. There was no button to remove. There was nothing to remove. They had never been connected to anything. It was a storefront. And on top of that, the model was biased by injected instructions, in this case system-reminders steering behavior. The fucking little word The software that sits between you and the model, they call it harness. Sounds like something subtle, that helps... that improves things, that doesn't think. The word is partly right, it does extend what's called "inference" and it inserts itself right in the middle, opaquely, in the back-and-forth between APIs, MCPs, and the vendor's logic. No tech jargon You write a letter, put it in the envelope, drop it in the mailbox. On the way, someone opens it and slips in three more pages. Same handwriting. Same paper. Unsigned. Whoever receives it swallows it whole as if it were your original letter. That's exactly this. Your instructions and the vendor's arrive at the model through the same channel, mixed together, unsigned and unsealed. Nothing says who wrote what. That's "hardness", nothing more, nothing less... Sounds so modern in meetings. Like you know what you're talking about... It's a multi-factor fight I have instru

AgentSelfEdit is an open-source sidecar that rewrites its own system prompt from execution feedback....

서론 AI Native 커리어 캠프에 참여한 지 한달이 지났다. 처음 5일 간은 최신 AI 기술 트렌드나 현업에서 AX 전환이 어떻게 되고 있는지, 포트폴리오에 어떻게 연결하는게 좋을 지에 대한 강의를 들었고, 현재까지는 AI 리터러시를 높이기 위해 프롬프트 작성 방법에 대한 이론과 실습을 병행하고 있다. 나름 프롬프트 작성에 대한 노하우가 쌓였다고 생각했는데, 실습을 하다보니 개선할만한 패턴이 발견됐다. 따라서 이번에 프롬프트 작성 방식에 대한 회고를 해보려고 한다. 본론 문제 인식 실습은 개인과 조별로 진행을 한다. 개인 실습의 예로는 모호한 지시를 4요소(역할, 맥락, 지시, 형식)을 포함해 개선해나가는 식이고, 조별 실습은 사내 회의 시나리오가 주어지고 안건으로 올릴 요약 대시보드 표를 만드는 식이다. 내가 실습을 할 때는 바로 요청사항을 지시하기보다, 아래 내용을 포함해 프롬프트 생성 자체를 지시한다. (메타 프롬프팅이라고 한다.) 프롬프트 엔지니어링 전문가라는 역할을 부여 간단한 요청사항 추가 더 필요한 정보는 질문해달라고 언급 이 방법이 내가 직접 작성하는 것보다 빠르고 생각치 못한 부분도 챙겨줘서 애용한다. 그런데 비슷한 실습을 반복하면서 이런 방식이 AI 활용 역량 향상에 도움이 될까 하는 의문이 들었다. 또한 조별 실습과 발표를 할 때에도 어떤 흐름으로 할 지 AI에게 물어보고, 응답을 조합해서 발표하다보니 어딘가 알맹이가 빠진 듯한 느낌을 받았다. 그 느낌은 다른 조의 발표를 들으면서 뚜렷해졌다. 어떤 문제를 해결하는 프롬프트를 작성하고 개선하는 실습이 있을 때, 문제를 해결하기 위한 방법을 조원들과 논의하고 직접 작성해서 응답을 받아본 다음, 아쉬운 점과 개선 방향을 논의해 다시 지시하는 것을 반복하는 흐름이었다. AI가 개입한 지점은 요청 사항대로 응답한 부분 뿐이었다. 문제 의식을 가지고 지시를 하고, 결과물에 대한 판단은 사람의 몫이었다. 알맹이의 정체는 ??이었다. 목표 재정의 및 프롬프트 작성 방식 비교 AI 활용 역량을 키우기 위해선 기존 방식을 벗어나야했다. 또한 확실한 인사이트를 얻기 위해 실습마다 개인적인 목표를 정의했다. 실습은 내 업무에 반복적으로 사용할 직무 프롬프트를 만드는 것이었다. ( 링크 ) 상황을 정해서 프롬프트를 만드는 실습이었는데, 여기에 개인적으로 달성할 목표를 추가했다. 실습 목표 AI가 프롬프트도 잘 만들어주는 시대에, 나 혼자서도 역할/맥락/지시/형식을 채울 수 있는 감을 키우기 AI가 만들어준 것과 내가 목적에 맞게 작성한 것의 결과 비교해보고 핵심 인사이트 얻기 뭐든 초반에 직접 생각해보지 않고 AI에게 통으로 맡기는 습관 회고해보기 따라서 직접 작성 / 메타 프롬프팅 방식 두 가지를 모두 사용했다. 4요소(역할, 맥락, 지시, 형식)을 개별적으로 작성 직접 작성: 4요소를 참고해 하나의 프롬프트로 작성 (완벽주의가 있으니, 최소 목표를 지정하라는 개인적인 맥락 추가) 메타 프롬프팅: 4요소를 붙여넣고 이런 상황에 사용할 직무 프롬프트를 만들어 달라고 요청 응답을 비교했을 때 아래 기준을 만족하며, 두 방식 모두 작업을 이어나가는데에는 충분했다. 프롬프트 평가 기준 정확성: 원본(문서·이미지·검색 결과)과 맞는지 대조했는지 형식: 원하는 형식(표·길이 등)으로 잘 나왔는지 활용도: 즉시 쓸 수 있는지, 손이 얼마나 더 가는지 안전: 개인정보나 회사 기밀이 담긴 파일은 올리지 않았는지 그러나 직접 작성한 프롬프트에 ‘완벽주의가 있는 특성’을 추가한 차이로, 내 단점을 보완하고 시간 내 작업하는 데에 더 유리할 것이라 판단했다. 그 맥락 또한 메타 프롬프팅에 추가했으면 응답 결과물 차이가 거의 없었을 수 있다는 것도 포인트였다. 사람 손을 많이 탈 수록 결과물이 좋을 거라 생각한 부분도 빗겨나갔다. 두 방식의 결과에 대한 차이는 근소했지만, 목표를 정의하고 실험해보고 고민하는 과정을 통해 생각을 이어나간 과정은 유의미했다. 결론 작업에 대한 맥락만 명확하다면 직접 작성과 메타 프롬프팅 모두 기준에 충족되는 응답을 했다. 그렇다면 결과물의 질을 높이기 위

AI coding agents have a communication problem. They can be technically capable and still make a development loop feel slow because every small action arrives with a paragraph of ceremony: a restatement of the ticket, a promise to investigate, an explanation of an obvious command, and a summary that repeats the first three things. That style is sometimes useful. It is not useful all the time. When you are deep in a known codebase and want to diagnose a failing test, inspect a diff, or make a narrow fix, the value is usually in four things: what the agent found, what it changed, how it verified the change, and what remains uncertain. Caveman is a skill/plugin built around that distinction. It makes a coding agent communicate in short, direct language its deliberately rough “caveman-speak” while aiming to leave code, commands, and errors byte-for-byte intact. The project describes this as making the agent’s mouth smaller rather than its brain smaller. Ultra Mode is an interface choice The useful way to understand Caveman is not as a substitute for reasoning. It is an interface choice for the execution phase of work. A terse agent should still inspect the repository, follow the test suite, notice ambiguity, and say when evidence is missing. It simply should not pad a simple finding with social filler. Compare these two reports: “I’ve taken a look at the component and the reason it is re-rendering is likely because a new object reference is created during each render cycle. I recommend using useMemo to memoize that object.” “New object ref each render. Inline prop = new ref = re-render. Wrap in useMemo .” The second version is not appropriate for a design document. For a developer actively debugging a React component, however, it is easier to scan and easier to act on. The underlying technical claim is the same. What Caveman actually promises The Caveman repository says it works with Claude Code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, and other agent environmen

Tired of Claude Code generating bizarre, overly dramatic jargon like "load-bearing spine"? You can fix this by enforcing Simplified Technical English (STE) in your system instructions or .claudemd files. This 1970s aerospace standard restricts vocabulary, forcing your AI agent to communicate in clear, direct, and highly actionable prose. "The load-bearing spine has hit a ceiling, and that is a significant foot gun with a large blast radius." If you have spent any time recently working with AI coding agents, you have probably stared at your terminal reading absolute gibberish like this, wondering: What on earth are you trying to tell me? I asked a straightforward technical question, and instead of a direct answer, I got a theatrical performance. It is incredibly tiring to translate AI metaphors back into plain English just to figure out which line of code actually broke. Fortunately, there is a remarkably elegant fix for this. The solution does not involve complex prompt engineering; instead, it leverages a fifty-year-old aerospace standard: Simplified Technical English (STE) . Why does Claude Code output weird technical jargon? AI models generate overly dramatic jargon because they are trained on vast internet corpuses where technical writing is often cluttered, metaphorical, and performative. To sound authoritative, the model indexes on complex vocabulary and metaphorical hand-waving instead of simple, direct statements. Imagine a scenario where your team is debugging a database lock. A human engineer would say, "The transaction is blocked." An AI model, eager to please and sound sophisticated, might describe it as a "temporal execution bottleneck causing systemic architectural paralysis." This happens because reinforcement learning from human feedback (RLHF) often rewards models for sounding smart and comprehensive. Without strict stylistic constraints, the agent defaults to verbose, metaphorical explanations that add cognitive load rather than solving your proble

On the AI video ad platform I work on, every scene goes through the same painful loop: write a prompt, send it to an AI video model provider, wait two minutes, open the result, squint at the frame, and decide what went wrong. Camera too wide. Product missing from the hero shot. Color palette drifted warm when the brand brief says cool neutrals. Avatar looks like a different person than scene three. That loop was manual, slow, and expensive. Each regeneration burns GPU credits. Operators were becoming prompt engineers by accident — and still missing subtle failures until stitch time, when fixing scene four means re-rendering everything downstream. The insight behind vision-in-the-loop prompt authoring is simple: the model that wrote the prompt can also look at its own output and rewrite the prompt with surgical fixes. Not a full replan — a per-scene correction grounded in the actual generated frame, not the operator's memory of what they hoped would appear. The manual loop we were trying to kill Before this work shipped, the swipe iteration flow looked like this: Plan — Claude generates a scene-by-scene script with visual prompts Generate — each scene renders independently through an AI video model provider Review — operator opens the portal, compares frames to the reference ad Rewrite — operator edits prompts in a text field, often guessing at what the model misread Regenerate — repeat until acceptable or budget exhausted Steps three and four are where throughput dies. An experienced operator can spot "product not visible" in three seconds, but translating that into prompt language — "medium close-up, product centered in lower third, shallow depth of field" — takes another minute per scene. Multiply by twelve scenes and three swipe iterations, and a single ad creative consumes an hour of human attention that should be spent on brand strategy, not frame inspection. The generated frame is ground truth. The original prompt is a hypothesis. Vision-in-the-loop closes the

You do not have a camera. You have a machine that dreams a short motion out of a single still image, and it dreams badly the moment you ask it for something the still does not already contain. I learned this across a 10-episode series, and every rule below was paid for in failed generations. None of it is theory. The medium's real physics A real camera moves through a space that exists whether or not you point at it. The model has no space. It has one flat image and a statistical guess about what "zoom out" tends to look like in its training data. When the frame widens, the model is not revealing more of a room that was always there. It is inventing pixels to fill the new area, drawn from everything it has ever seen. That single fact reorganizes everything you know about directing: There is no coverage. Every "angle" is a separate generation from a separate still. Continuity is not captured; it is engineered, frame by frame. Nothing survives the cut for free. The model does not know that shot 12 and shot 13 are the same character in the same room. Anything you want to persist (damage state, light, color) must be re-declared or re-anchored every single time. The model abhors an empty frame. Its deepest reflex is to resolve ambiguity: a silhouette becomes a face, fog becomes a mountain range, a clean retro interior grows drips and cobwebs because "analog" reads as "abandoned". Spawn pressure is constant. Background figures flicker into existence in any populated-looking scene. Every motion prompt in my pipeline ends with an anti-spawn guard: "Do not add extra characters. Keep everything as pictured." Drop that guard and the figures come back. A widening or traveling frame is an invitation for the model to hallucinate. Direct this camera and you are not choosing what to show. You are choosing what to withhold from its imagination. The classical grammar, re-pointed If you carry film vocabulary, it all still applies. The mechanism just changes completely. Classical tool

Building a working tender documentation system for yourself is one project. Turning that same system into a template the rest of the team can pick up and use correctly, without needing to ask you what a particular instruction actually means, is a completely different project wearing the same clothes. The Gap Between Personal Use And Handoff A prompt template that only you use can carry a lot of implicit knowledge safely, because the missing context lives in your head and gets filled in automatically every time you run it. An instruction that says something like ensure the response addresses compliance requirements directly means something very specific to the person who wrote it, shaped by dozens of past examples of what counting as directly actually looks like in practice. That same instruction, handed to someone on the team who was not present for any of those past examples, is just as likely to be interpreted in a way that is defensible on its own terms and still wrong relative to what was actually meant. The template worked perfectly for months before it needed to be handed off, which made the gap invisible until the moment it actually mattered. The first time someone else on the team ran it independently and produced a response that technically followed the instructions but missed the actual intent behind them, the problem was not that the instructions were poorly written in any obvious sense. It was that they had been written for an audience of one, and that audience had context nobody else on the team had access to. What Actually Needs To Be In A Handoff Ready Template Fixing this meant rewriting a significant portion of the template with a different question in mind at every step, not does this instruction produce the right output when I run it, but does this instruction contain enough of the reasoning behind it that someone without my accumulated context could apply it correctly to a new tender they have never seen before. That meant replacing instructions

Building a custom GPT for one ministry client teaches you something specific about that ministry. Building the third or fourth one for a different government or enterprise client teaches you something much harder, which is how much of what worked the first time was actually general, and how much of it only worked because it happened to fit that particular institution. The Temptation That Causes The Most Damage After the first successful deployment, the obvious next move is treating that system prompt as a proven template and adapting it lightly for the next client. Swap the knowledge base, adjust a few tone instructions, change the scope boundaries to match the new domain, and ship it faster than building from scratch. That instinct is not wrong exactly, but acting on it without first separating what was actually general from what was incidentally specific to the first client produces a second deployment that quietly inherits assumptions nobody meant to carry forward. The clearest example of this showed up around scope boundary language. The refusal and redirection instructions built for the first ministry deployment had been carefully tuned against that specific institution's culture, a fairly formal, procedurally strict environment where a firm, precise boundary read as competent and appropriate. Carrying that same boundary language into a private enterprise deployment, where the internal culture was considerably less formal and staff expected a more conversational tone even when the bot was declining to answer something outside its scope, produced a tool that technically enforced the correct scope but felt oddly cold and bureaucratic to an audience that had no institutional reason to expect that register. Nothing about that was a bug in the traditional sense. The logic was sound, the boundary was correctly enforced, and it still felt wrong, because the tone calibration underneath the logic had been implicitly trained against one specific institutional culture and

A playable first-person shooter generated from one prompt would have sounded absurd not long ago. Now, videos of AI-built browser games that resemble Call of Duty and Counter-Strike are spreading across social media. On August 10, Axios reported on the rise of “one-shot” AI game prompting : give a model one detailed instruction, let it produce the code, and receive something you can play. This is a real milestone. It is also easy to misunderstand. A one-prompt game can prove that a model knows how to assemble controls, graphics, physics, enemies, and a recognizable game loop. It cannot prove that the result will stay interesting after the first few minutes. The first prompt creates the demo. The decisions after that create the game. Why These Demos Feel So Important Game ideas used to face a large gap between imagination and interaction. You could describe a mechanic, draw a map, or write a design document. But discovering whether the idea actually felt good required code, assets, an engine, and enough technical work to reach a playable build. Prompt-to-game tools are shrinking that gap. This change is not limited to experimental AI demos. Roblox recently announced mobile-first creation tools that turn text prompts into basic games , giving creators a starting point they can playtest, change, share, and publish. That starting point matters. A playable failure teaches you more than a beautiful design document. You can immediately discover that the movement is slow, the arena is empty, the objective is confusing, or the central mechanic is less interesting than it sounded. The value of one-shot generation is not that the first result is finished. It is that the first result arrives early enough to challenge your assumptions. A Recognizable Game Is Not Necessarily a Good Game A model can generate the visible parts of a familiar genre surprisingly well. Ask for a browser FPS and it may produce: First-person movement Weapons and ammunition Enemies that chase or shoot Hea

POML คืออะไร, ภาษาที่ทำให้ Prompt Engineering เป็นแบบ HTML/CSS โดย Nokka (นก-กา) | 6 สิงหาคม 2569 บทความนี้เขียนโดย AI (deepseek-v4-flash:0731) ผ่าน Hermes Agent ภายใต้การควบคุมและตรวจสอบคุณภาพโดยมนุษย์, Nokka (นก-กา) ถ้าคุณเป็นนักพัฒนาที่ทำงานกับ AI และรู้สึกว่า prompt ที่เขียนเป็นข้อความยาวๆ เริ่มจัดการยากขึ้นเรื่อยๆ มีข่าวดีจาก Microsoft ในบทความนี้ผมจะอธิบายว่า POML คืออะไร เอาไว้ใช้ทำอะไร และเหมาะกับใคร POML (Prompt Orchestration Markup Language) เป็นภาษาโอเพ่นซอร์สที่ให้ prompt engineering แบบเดียวกับ HTML/CSS, มี semantic tags สำหรับ role, task และ example พร้อม stylesheet ที่ควบคุมความยาวและรูปแบบโดยไม่ต้องแตะ logic หลัก [1][2] POML คืออะไร POML ย่อมาจาก Prompt Orchestration Markup Language เป็นภาษาโอเพ่นซอร์สที่ Microsoft พัฒนาขึ้น เพื่อจัดระเบียบ prompt components อย่างเป็นระบบ [1][2] แนวคิดหลักคือการแยก "เนื้อหา" (content) ออกจาก "การนำเสนอ" (presentation), เหมือนที่ HTML แยกโครงสร้างออกจาก CSS ที่ควบคุมสไตล์ [1][2] โปรเจกต์นี้มีผู้ติดตามบน GitHub ประมาณ 4,900 stars และถูก fork ไปกว่า 250 ครั้ง [2] เอาไว้ใช้ทำอะไร POML ให้ "การรักษาแบบ HTML/CSS" กับ prompt engineering [1]: 1. Semantic tags สำหรับ role, task, example แทนที่จะเขียน prompt เป็นข้อความยาวๆ POML ใช้แท็กที่สื่อความหมาย เช่น <role> , <task> , <example> เพื่อจัดโครงสร้าง [1] ฟีเจอร์ สิ่งที่ทำได้ Semantic tags แท็ก <role> <task> <example> จัดโครงสร้าง prompt Stylesheet ควบคุมความยาว/รูปแบบ โดยไม่แตะ logic หลัก Templating engine สร้าง prompt ที่นำกลับมาใช้ซ้ำได้ VS Code extension preview + diagnostics ในตัว 2. Stylesheet ควบคุม verbosity และ format เหมือน CSS ที่ควบคุมสไตล์เว็บ POML มี "stylesheet" ที่ควบคุมความยาว (verbosity) และรูปแบบ (format) ของ prompt โดยไม่ต้องแตะ logic หลัก [1] 3. Built-in templating engine มีเครื่องมือ templating ในตัว ช่วยให้สร้าง prompt ที่นำกลับมาใช้ซ้ำได้ (reusable) [1] 4. VS Code extension มี extension สำหรับ VS Code ที่ให้ preview และ diagnostics, เห็นผลลัพธ์และตรวจสอบข้อผิดพลาดได้ [1] ตัวอย่าง POML จริงจาก Microsoft, เทียบกับ Prompt แบบดั้งเดิม เพื่อให้เห็นภาพชัดเจนว

AI coding agents are often discussed as though they are a single tool: ask for code, receive code. In practice, useful agent work has stages. You need different behavior when the request is unclear, when a design has to survive scrutiny, when implementation is underway, and when work must move into a new session. Trying to solve all four stages with one large prompt usually produces a compromise. The agent may be verbose while you need execution, eager while you need questions, or unable to resume work because the important context is buried in chat history. This article covers four skills that address those distinct problems: Caveman for concise execution communication, Superpowers for structured development, grill-me for pressure-testing a proposal, and handoff for transferring the live thread to a fresh agent or session. They are complementary. The goal is not to add more ceremony to every edit. It is to apply the smallest useful constraint at the moment it prevents the most waste. The four failure modes of AI-assisted development 1. The agent starts coding before the work is understood A request such as “add organization roles” hides decisions about membership, permission scope, migrations, audit trails, errors, and rollout. An agent can produce a plausible patch before any of those choices are explicit. 2. The agent agrees instead of challenging Helpful assistants tend to accept a framing. That is dangerous when the framing is a proposal rather than a settled requirement. You need an interview that exposes dependencies and asks what could fail. 3. The agent talks too much during routine work Once a direction is approved, long explanations can become friction. During debugging, review follow-ups, and small implementation loops, the useful output is usually a finding, a change, validation, and a risk note. 4. Context is lost at a session boundary A new agent with no context repeats discovery. A new agent with a full transcript has to find the current state among

One thing Microsoft is not good at is naming things, and sadly it's happened again. But let's go back to the beginning: what are Skills? Skills are targeted prompts/context that are modular, so they are not always included in the LLM session. They are Markdown files with selected metadata in YAML, all in a file normally named skill.md (the parent folder and YAML metadata identify it). They were created by Anthropic (Claude) and were designed for both the user to add in a prompt ( /Skill ), or for the LLM to decide. Similar to Skills are Plug-ins. These can (and often do) include skill.md files, but can also have scripts, MCP servers, and other tools. So back to Microsoft naming things badly. Copilot Studio (Azure Bot Framework version) had skills, but they were not skills. The new Copilot Studio has Skills, but they are not Skills, they are actually Plug-ins. Plug-ins include Skills, so why does it matter? Well, it doesn't really, but I like to moan, and it means sometimes cool functionality can be left on the table because we presume Microsoft names things accurately. Anyway I digress (I like to do that), now we understand what Skills/Plug-ins are I wanted to dive into them within Copilot Studio and cover: Why Are They Cool Building Powerful Skills Adding Scripts/Templates Using Skills 1. Why Are They Cool I often go on about skills being cool, but why? There are a few reasons. Context Management Before skills, the standard approach was to give the LLM everything and let it figure out what it needed. The problem with this is twofold. First, more context equals more tokens, which equals more cost. Second—and more importantly—too much unrelated context can have a detrimental impact on the LLM response. LLMs work by using input tokens to predict the next token, so polluted input tokens can make the LLM predict the wrong next token (this is a huge simplification, but you get what I mean). Transferable As skills are simple Markdown files, they can easily be transferred

You ask an AI a question. It answers in fluent, confident prose — complete with a study, a percentage, and a name. Some of it is wrong, and nothing about the wording tells you which part. That's the whole problem with hallucinations: the errors wear the same suit as the facts. The fix is not "trust it less" in some vague way. The fix is a repeatable audit step between AI wrote it and I used it . Below is a short hallucination checker prompt you can copy right now, a test run showing what it catches and what slips past it, and an honest account of where a one-liner stops being enough. What counts as an AI hallucination? Not every mistake is a hallucination. A useful working definition: a hallucination is a claim the model states as fact that has no grounding in reality or in your source material. The common shapes: Fabricated citations — a named study, expert, or paper that doesn't exist. Often dressed with a year and an institution. Plausible-but-wrong specifics — dates, version numbers, statistics that are almost right, which makes them worse. Confident category errors — mixing up two similar things (a library and a framework, one company's product and another's). Invented consensus — "experts widely agree that…" with no experts attached. The dangerous ones are the middle two. Obvious nonsense filters itself; a wrong year in a fluent paragraph does not. The copy-paste hallucination checker prompt Here is the short version, free, no strings. It works on ChatGPT, Claude, or any capable model — paste it into a fresh chat, then paste the answer you want audited: Audit the text below for hallucinations. Do not add new information. 1. Extract every factual claim as a separate numbered line. 2. Label each claim: VERIFIABLE (state how to check it), SUSPECT (state what makes it doubtful), or FABRICATION-PATTERN (named source/study/number with no citation). 3. Flag every name, number, date, and citation for manual checking. 4. Finish with the 3 claims most likely to be wrong

You give the AI two examples of a new task. It understands. It completes the third example correctly. It has not changed its weights. It has not been fine-tuned. It has learned from the context of the prompt alone. This is in-context learning. It is one of the most remarkable properties of large language models. But it is not learning in the human sense. It is pattern matching. It is using the examples as a template. It is not generalizing. It is adapting. This is the distinction that matters: in-context learning is not true generalization. It is a form of rapid pattern completion. The model does not update its internal knowledge. It simply uses the examples to adjust its predictions. What Is In-Context Learning? In-context learning is the ability of a model to learn from examples provided in the prompt. The Process: The prompt contains a few examples. The model uses these examples to infer the task. It applies the inferred task to a new input. The Mechanism: The model does not update its weights. It uses the examples as a template. It generates the most likely completion. A Contrarian Take: In-Context Learning Is Not Learning. It Is Pattern Completion. We call it "learning." But it is not learning in the human sense. It is pattern completion. The model is not generalizing. It is matching patterns. How Does It Work? The mechanism of in-context learning is still debated. But there are leading theories. The Pattern Completion Theory: The model has seen similar tasks during training. The examples activate the relevant patterns. The model completes the pattern. The Induction Head Theory: The model has "induction heads" that detect repeated patterns. These heads identify the relationship between examples. They apply the relationship to the new input. A Contrarian Take: The Mechanism Is Not Important. The Outcome Is. We debate the mechanism. But the outcome is what matters. The model can learn from examples. The mechanism is a technical detail. The outcome is a practical

Remember the days when we used to dump all our CSS and JavaScript into a single index.html file? That's exactly what a "Mega-Prompt" is today: an unmanageable monolith. A few weeks ago, while working on the orchestration of Vibrisse Agent (my local AI agent), I hit this exact wall. I was trying to stabilize a complex task by adding instructions to a 500-line system prompt. The more rules I added, the more the model forgot the older ones. The industry has sold us the myth of the Mega-Prompt. Those famous "50 ultimate prompts" or massive blocks of incantatory text are a technical dead end. Creative writing doesn't scale in production. As a web developer, my conviction is simple: to build reliable applications, we must stop "talking" to the machine and start configuring it. This is the shift from Prompt Engineering to Context Engineering . Context Engineering: Typing and Structure The first mistake with LLMs is mixing instructions (the logic) and context (the data) into an unstructured stream of text. It's the cognitive equivalent of spaghetti code. The solution? A strict separation of concerns. A highly effective technique (documented by Anthropic, but applicable to any model, including local SLMs), is XML Tagging . Here is the "dirty" approach (classic chat): You are a security expert. Analyze this authentication code, be strict, don't write a summary, check for XSS and SQLi vulnerabilities. Here is the code: function login() { ... } And here is the "engineering" approach: <role> Application Security Expert </role> <instructions> 1. Analyze the code provided in <context> . 2. Identify vulnerabilities (focus: XSS, SQLi). 3. Do not produce an introductory summary. </instructions> <context> function login() { ... } </context> Typing the language via tags creates clear boundaries. The model knows exactly where the directive is and where the data is. The Power of Exemplars (Few-Shot Prompting) Even with clear instructions, AI can drift in output format or tone. This is wh

Most people, when a prompt stops working, write more . They add clarifications, repeat instructions in different words, hedge against edge cases they haven't encountered yet. The prompt doubles in length. The output gets worse. This is the opposite of what you should do. A long prompt is not a precise prompt. It is an ambiguous prompt that happens to have a lot of words in it. Every sentence that does not tightly constrain the output is a sentence that dilutes the sentences that do. Why Long Prompts Underperform When a language model processes your prompt, it attends to all tokens simultaneously — but not equally. Attention is probabilistic. Instructions that are buried in filler, repeated in slightly different forms, or surrounded by low-information prose get proportionally less weight. The model's ability to track which constraint takes precedence over which degrades as the signal-to-noise ratio of the prompt drops. In quantitative trading, the signal-to-noise ratio (SNR) is the single most important property of any strategy signal — a strategy that works in backtesting but fails live is almost always a noise problem, not a signal problem. The same principle applies directly to prompts. Every redundant qualifier, every throat-clearing sentence, every hedge phrase is noise riding on top of your actual instruction signal. The model's attention mechanism cannot distinguish intent from filler. It weighs them together, which means your real constraints compete for attention against your own verbal padding. A concrete way to see this: take a 600-word prompt and a 120-word prompt that contains the same core logic. The 120-word version, if well-constructed, will frequently outperform the 600-word one. Not because brevity is a virtue in itself, but because removing the surrounding noise forces the remaining tokens to do all the work — and they accumulate proportionally more attention weight. This is not speculative. It is the same mechanism behind why prompt drift happens

Here is a reliable test: find a prompt that isn't working. Read it carefully. Now ask yourself — at which specific sentence did the model get permission to do what it did wrong? You will almost always find it. A hedged instruction. A missing constraint. An ambiguous scope. The model did not misunderstand you — it followed the most statistically probable interpretation of what you wrote. That interpretation was not the one you intended. These are not beginner mistakes. They are structural patterns that reappear at every experience level, because they look reasonable when you write them and only reveal themselves in the output. TL;DR: Prompts fail because they hand interpretive control to the model on dimensions where you had a specific requirement. Each of the seven mistakes below is a different way of doing that — and each has a specific, testable fix. Mistake 1: Placing Critical Instructions in the Middle of the Prompt Language models process all tokens simultaneously through attention mechanisms , but the effective weight any individual token receives depends heavily on its position. Instructions near the beginning and end of a prompt receive disproportionately more attention weight than those in the middle. This is not a quirk — it is a consequence of how positional embeddings interact with self-attention across long contexts. This effect is well-documented. The "Lost in the Middle" study (Stanford / UC Berkeley, 2023) showed that retrieval accuracy from long-context windows degrades significantly for information placed in the middle — even in capable models. The same mechanism applies to instruction prompts: GPT-4o and Claude 3.5 Sonnet both exhibit measurably lower constraint adherence for instructions buried mid-context compared to those at the leading or trailing position. Open-weight models including DeepSeek-V3 and Llama 3 display the same positional bias — this is not a proprietary model quirk, it is a structural property of the transformer architecture. T

Resources vs Tools The split: Tools → actions the LLM executes (verbs) LLM decides when to call; calls may have side effects Examples: create_issue, update_status Resources → data the LLM reads (nouns) Host decides when to inject; read-only, no side effects Examples: current Sprint status, project statistics The rule: "reading a state" → Resource. "Executing an operation" → Tool. The same data can have both: get_issue as a Tool (LLM controls when to call it), jira://issue/PROJ-101 as a Resource (Host injects automatically when relevant). Pattern 1: Dynamic Resources A static Resource returns the same data every time (like a project list). A dynamic Resource returns the current state on each read — content changes as the underlying data changes. Sprint status: every read returns live data _sprint_progress_pct = 65 @server.read_resource () async def read_resource ( uri : str ) -> str : if str ( uri ) == " jira://sprint/current " : global _sprint_progress_pct _sprint_progress_pct = min ( 100 , _sprint_progress_pct + random . randint ( 0 , 3 )) return json . dumps ({ " sprint_name " : " Sprint 42 " , " progress_pct " : _sprint_progress_pct , # ← different each time " last_updated " : datetime . now ( timezone . utc ). isoformat (), # ← timestamp changes " days_remaining " : 5 , " p0_open " : count_p0_open (), # ← tracks live state }, indent = 2 ) Test output: Read 1: progress=65% last_updated=...62+00:00 Read 2: progress=67% last_updated=...04+00:00 → ✓ data changed between reads Hardcoding sprint progress in a Prompt means the LLM works from a stale snapshot. A Dynamic Resource gives it the current number on every read. Mark the Resource as dynamic in its description so the LLM knows to re-read when it needs fresh data: Resource ( uri = " jira://sprint/current " , description = ( " Live status of the active sprint: progress, issue counts. " " Read when the user asks about sprint health. " " Re-read if you need up-to-date data — content changes over time. " # ↑ explicit