I used to write long prompts with step by step instructions, examples, constraints, and then cap it off with "if you're not sure, just ask me" because I thought that was the safe approach, and the result was always the same, 30 minutes in it would time out, loop its reasoning, forget the original request, fix a couple of bugs, and declare itself done.
I switched models and got the same thing. Split the task into smaller pieces and got the same thing. Thought my machine was too weak so I upgraded the hardware and nothing changed.
Then one day I was exhausted and just typed out a short blunt prompt with no explanations, no examples, just the job, the authority, and a couple of constraints.
I'm working on Halis, a self-hosting systems programming language where the compiler is written in itself. The codebase is around 224,000 lines and has been through 30 stages of development.
I handed the AI the repo link with a token, told it to scan everything for bugs and keep fixing until scanning found nothing left, no asking, and to commit under my name.
It ran for 5 hours, found 14 real bugs, fixed them all, never timed out, never looped, never forgot a thing.
I sat there staring at the screen for a while before a few things clicked.
The more authority you give, the more stable it becomes
That line about "if you're not sure, ask me" sounds responsible but it actually kills everything because every question chops up the context, and by the twentieth question the AI is exhausted while the original task drifted out of its head long ago.
I banned it from asking. It stopped seeking permission. It started making its own calls, and reasoning flowed where it was actually needed instead of being spread thin across trivia.
The shorter the prompt, the cleaner the context
A 2000 word prompt eats 3000 tokens before I've typed a single character. Add in the system prompt and a pile of tool descriptions and I've burned 15,000 tokens before the work even starts.
A million token context sounds like a lot but attention is not infinite. The more junk tokens you pile in, the more distracted it gets from the code.
A short prompt hands almost all of the context back to the code. It focuses, and the quality jumps.
The stopping condition has to be dynamic
"Fix the bugs" means it fixes a few, declares victory, and stops.
But "keep fixing until scanning finds nothing left" means it can't declare victory early. It has to scan, fix, scan again, repeat, and it becomes its own critic.
That's why my sessions ran through 25 scan passes, and each one dug up bugs the previous pass had missed.
This isn't me making things up
- Stanford ran 100,000 prompts and found that long prompts hurt performance in 73% of cases
- Another study across 144 microservices showed that with the same agent, a minimal prompt hit 75.9% test pass while a detailed prompt only managed 50.3%
- Just this past September, OpenAI themselves admitted in a post that all the accumulated instructions from older model generations were wrecking the performance of the new one
A long prompt is a sign you don't trust the model
When you write 2000 words explaining how to fix one bug, you're telling it it's dumb. It hears that, and it turns into a command follower.
But when you write 110 words and say I trust you to handle it, it becomes an engineer, and it comes up with things you never would have thought of.
What it actually did in that 5 hour session
- Wrote its own scanner because the standard linters weren't good enough
- Ran 18 layers of checks in parallel
- Found a segfault that had been sitting there for over a year
- Found a security hole in the ZIP parser of the archive library
- Caught 65 places with the same broken pattern in the SIMD emitter
- Rewrote the test harness because the test itself was broken
- Fixed an LTO regression that a previous stage had quietly introduced
- Verified everything again
- Committed each fix individually
- Pushed it all with my username instead of the sandbox's default identity
I didn't ask for any of that. It did it all on its own.
Strong models need freedom
If I handed that same workload to Claude Fable 5.1, the strongest model in the world right now, along with a long detailed prompt, the result would actually be worse.
Not because it's weak. It's not. It's strong. But a long prompt chains down any model no matter how powerful.
Fable 5.1 with a short prompt would be terrifying. Fable 5.1 with a long prompt is just on par with a mid-tier model given a short one, maybe even worse.
I've tested it.
Strong models need freedom. Freedom means clean context. Clean context means good results. That's it.
Final thought
If you're still writing long prompts and wondering why your agent keeps timing out or looping or forgetting what it was doing, try cutting it by 90%.
You might be surprised.
#AI #PromptEngineering #LLM #Developer #Coding #Productivity
Top comments (0)