A few months ago, Anthropic's own Applied AI team stood in front of a camera and gave away, for free, forty prompting techniques it took them years to learn watching Claude run in production. No paywall. No signup. Just the people who built the model telling you exactly how they intended it to be used. OpenAI did something similar with its official Codex Prompting Guide: a plain four-part framework (goal, context, constraints, done-when) published straight from the team that ships the model. These aren't marketing gimmicks. These are the people who understand the tool best, handing you the manual for free.
And almost nobody reads it.
That's the part I keep coming back to. It's not that the knowledge doesn't exist. AI labs aren't hiding how to use their own products. If anything they're doing more of the opposite than ever. The problem is that the manual is enormous, it changes every week, and it's scattered across a dozen companies, each shipping a new model, a new API, a new prompting convention, faster than any one person, expert or beginner, can realistically track.
Where hallucination actually comes from
Every AI product I've used breaks the same way eventually. You ask for something reasonable and it gives you something confident and wrong. People call this a hallucination and blame the model. I don't think that's usually what's happening.
What's actually happening is ambiguity. You left a gap in what you asked for, and the model, because it has to answer something, fills that gap with an assumption. Sometimes the assumption is right. Often, especially with fast-moving tools, it's built on a training snapshot that's already stale. The model isn't lying to you. It's guessing, because you gave it a shape with a hole in it and it has no way to know what belongs there unless you tell it.
This is where documentation actually matters, and where most people fall off. Anthropic's docs change on a rolling basis. So do OpenAI's. So does every framework, every library, every SDK a serious builder touches in a given month. Keeping up with all of it isn't a discipline problem. It's a math problem. More documentation gets written in a day than any one person can read in a day.
The one thing that doesn't change
Here's what I think is actually permanent, no matter how fast the models get: someone still has to point them. Call it intent, call it taste, call it judgment. The model needs a human deciding what "good" looks like for this task, in this context, and saying so. That's true even as the tools get more autonomous.
Peter Steinberger, who built OpenClaw, said it in one line that ended up seen 6.5 million times on X: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." Most people read that as agents replacing prompting. I read it the other way. Intent didn't stop mattering. It moved up a level. Someone still has to design the loop. The human didn't leave the process. They moved from writing one instruction to designing the system that writes instructions. The input is still, always, a human decision. Just aimed at a different layer of the machine.
Adoption isn't the same as fluency
People assume this problem is shrinking on its own as AI adoption goes up. So let's look at the actual numbers instead of the vibe.
Generative AI reached roughly 53% of the world's population within about three years of its mass-market launch. Faster than the personal computer. Faster than the internet. There are more than a billion people using an AI tool every month. On paper the adoption problem looks solved.
It isn't. Only about 21% of people use AI daily. Most of the rest touch it every few months, at best. Even inside companies that have fully bought in, 71% of Baby Boomers say they've never used a tool like ChatGPT at all, and only about 18% of Gen X and Boomer workers use AI in their day-to-day jobs. And this isn't purely generational. I've watched engineers who ship production code every day struggle to get a clean answer out of a model, because the tool changed its recommended prompting pattern last month and nobody circulated the memo. If people who build software for a living can't keep pace with how fast this moves, the average person never had a chance.
Adoption isn't the same as fluency. The world has adopted AI. It hasn't learned how to talk to it.
The cost nobody notices
There's a smaller example of the same gap that I think about a lot. When Anthropic shipped Fable 5, it was clearly their most capable model, and also, at roughly five times Sonnet 5's per-token cost, clearly the most expensive way to burn through a budget if you used it for everything. Anthropic's own guidance, once people started asking about cost, was simple: use Fable 5 to plan, and hand execution to cheaper Sonnet 5 subagents. Done right, that pattern gets you something like 92 to 96% of Fable 5's solo quality for roughly half the cost.
That's a real, documented, verified technique. It's also buried in a blog post most Fable 5 users will never read, because they're busy trying to ship something and don't have time to hunt through changelogs for cost-saving patterns.
That pattern repeats everywhere, not just with Claude. The knowledge to use these tools efficiently already exists. It's published, it's often free, and it's almost never where the person who needs it is looking when they need it.
Where Kosmo fits
This is the exact gap I built Kosmo to close. Kosmo isn't a chatbot, and it isn't trying to replace Claude, ChatGPT, Cursor, or whichever tool you're actually going to run your task on. It sits in front of all of them. You tell it what you want in plain language, the way you'd explain it to a colleague, not the way a prompt-engineering course tells you to phrase it. Kosmo does the part almost nobody has time for: it knows what the target tool's own current documentation says it expects, and it compiles your intent into exactly that shape.
You don't need to know that Claude wants XML tags and ChatGPT wants markdown headers. You don't need to know the goal, context, constraints, done-when framework OpenAI just published for Codex. You don't need to have watched Anthropic's workshop, or read the orchestrator post about Fable 5, or track which framework's API changed this week. Kosmo already read it. You just say what you mean, and the tool you're sending it to gets exactly the input its own makers say gets the best result out of it.
Everybody wins in that exchange. The tool performs the way it was actually built to perform, instead of guessing its way through a vague ask. The company that built the tool gets a user who's actually using their documentation correctly, instead of someone complaining the model "doesn't work." And the user gets what they wanted the first time, without becoming a part-time documentation researcher for six different AI companies just to ask a good question.
There's a side effect I didn't originally design for, but it's the most honest proof this works. When a prompt is precise instead of vague, it tends to use fewer tokens too. Not because Kosmo is trying to be short, but because removing ambiguity removes the padding, the re-explaining, and the guesswork the model would otherwise burn tokens compensating for. Efficiency isn't the goal. It's what falls out of a compiled prompt versus a hand-written guess.
The part that doesn't change
None of this goes away because the models get smarter. Every architecture running today, no matter how capable, is still fundamentally a system predicting what comes next from a training snapshot that's already aging the moment it ships. That's not a criticism. It's just the shape of the technology. It means the gap between what a tool can actually do and what the average person knows to ask it for isn't a temporary problem that better models will quietly fix. It's structural. It will keep existing for as long as documentation moves faster than people can read it.
Where I want to take Kosmo next is closer to the source. Direct, real-time access to the documentation these AI labs are already publishing, so the moment something changes, Kosmo already knows, instead of catching up after the fact. Not to replace what Anthropic, OpenAI, and everyone else building these tools are already doing. They are doing the hard part: building genuinely capable systems and, increasingly, telling people how to use them well. But telling isn't the same as reaching everyone, and it never will be at the pace this moves. Someone still has to sit between the intent and the tool, and translate.
That's the job. A human will always be the one deciding what they actually want. Kosmo's job is making sure that decision reaches the machine intact, no matter how fast the machine keeps changing underneath it.