Vibe to Spec
Stop wishing at the model.
A short, free course on writing prompts that actually work. The mental model behind prompts the model can act on, the five parts every prompt should have, and side-by-side bad-vs-good examples for the kinds of tasks you’d ask AI for at your day job.
No signup. Finishable in a weekend.
If any of this sounds familiar
Your prompts work sometimes.
You can’t tell why.
- You typed
make this betterand watched the model confidently produce something worse. - You pasted two hundred lines of code with
why doesn’t this work?and got a generic answer that missed the real bug. - You’ve watched five “prompt engineering tips” videos and your prompts haven’t actually gotten better.
- The same prompt works one day and fails the next, with no clear reason why.
- You keep restarting conversations because the model “went off the rails,” and end up worse than where you started.
None of this is the model being dumb. It’s a mismatch between what you’re writing and what the model needs. The fix is small, plain, and you can start using it on the next prompt you send.
What you walk away with
After a weekend of reading:
Chapter 1
A working model of what prompts actually are — and aren't
Chapter 2
The five parts every prompt that works has
Throughout
A library of bad/good prompt pairs for everyday tasks
Chapter 4
A diagnostic for reading what the model gave back
Chapter 5
Names for the five failure modes that derail most prompts
Chapter 6
Templates for code, writing, and decision prompts
Chapter 6
A reusable system-prompt structure
Throughout
Confidence that the same prompt works tomorrow
This isn’t a list of magic phrases or a roundup of model-specific tricks. It’s the underlying skill — the way you spec the work you want done. Get that right and every model you ever use, current or future, gets better.
Syllabus
7 chapters · 27units · ~2 hours
Each unit is short and dense. One idea per page, one or two worked bad-vs-good prompt pairs from real software tasks, and a reflection prompt where the idea meets your actual work.
Ch 0Start herePsychological2 units· ~13 min
What this is. Why it's free. Whether to keep reading.
Ch 1Prompt is a specPsychological2 units· ~12 min
You're not asking the model. You're specifying for it. Reframe.
Ch 2The anatomy of a promptPEAK5 units· ~28 min
Five parts. Most prompts skip three of them. Add them and the output changes.
Ch 3Showing beats tellingMedium4 units· ~21 min
Examples carry more signal per word than any description ever will.
Ch 4Iteration is the skillMedium4 units· ~19 min
Nobody writes good prompts. Everyone revises them.
Ch 5Failure modes, namedMedium5 units· ~24 min
The same five mistakes, named. Watch for them in your own prompts.
Ch 6Putting it to workHigh point5 units· ~25 min
Apply the loop to code, writing, analysis, decisions. Same loop, different cuts.
The format
Principles, then prompt pairs.
Most prompt-engineering content is either listicles of “magic phrases” or model-specific tricks that age out the moment a new version ships. This is neither. It’s the underlying skill — written as durable principles, each one paired with concrete before/after examples from the kinds of tasks you do every day.
| Typical “prompt engineering” post | This course | |
|---|---|---|
| Format | Listicle of magic phrases | 27 short written units, all with worked examples |
| What it teaches | Tricks specific to one model | The underlying skill — works for any model |
| Examples | Toy tasks, abstract output | Real software work: code review, debugging, refactoring, writing |
| When it goes out of date | Next model release | Never — the principles outlast models |
| What you do with it | Bookmark, forget, scroll past | Apply one move to your next prompt |
| Voice | Hype, motivational | Diagnostic, plain language |
Every unit, three beats
- 1. The idea. One durable claim, stated plainly.
- 2. The pair. A concrete vibe-prompt vs. spec-prompt example from real software work, with a one-line note on what changed.
- 3. Try it. One small reflection or action you can apply to your own prompts today.
7 chapters · 27units · ~3–8 minutes per unit.
Open to read
No catch. No signup. No email drip.
- ✓All 7 chapters, 27 units, every worked example
- ✓No signup wall. Open the first unit and read.
- ✓No upsell, no popup, no drip.
- ✓Progress tracking and a continue-learning button, locally on your device
The only honest version of this course is a free one. Read it, ignore it, or mail it to your team — there’s nothing to buy at the end of it.
Frequent objections
Honest answers.
Why is this free?
Because gating philosophy is hypocritical when the whole argument is 'do the work yourself.' Charging for the diagnosis would just be a tax on the people most likely to try it. Read it, share it, or close the tab — whatever you want.
Will this work for the AI I use?
Yes. The course deliberately doesn't mention model names or versions. The principles — context, format, examples, iteration, diagnostic reading — apply to every chat-style model. Specific 'magic phrases' for one model are out of scope; they age out within months. The skill of writing a prompt as a spec doesn't.
I already prompt well. Is this for me?
Maybe not. Unit 0.1 shows the whole course in five before/after pairs. Read those — if you already write the second column on instinct and you can name what makes it work, close the tab. The course is for people who can see the difference but don't yet reach for the second column by default.
Do I need to be a coder?
Mostly yes. The worked examples are from software engineering tasks: code review, debugging, refactoring, writing tests, writing PR descriptions. If you don't write code, you'll still get the principles, but a lot of the concrete examples won't land the same way.
Why no 'magic phrase' lists?
Because they're either obvious (chain-of-thought, role-play prompts) or model-specific (this exact phrase works for this exact version). The skill underneath them — writing a prompt the model can verify against — is what the magic phrases are reaching for. Learn that, and you don't need the lists.
How long does this take?
About 2–3 hours of reading if you push through, or one unit a day for a month if you let it land. Each unit is short and dense — 3–8 minutes — and ends with a reflection you can do in another minute. You don't have to read it in one sitting.
What about jailbreaking / prompt injection?
Out of scope. This is a course about getting useful work out of cooperative models on legitimate software tasks. Adversarial prompting is a separate skill with separate stakes, and this course doesn't touch it.
Will this stay relevant?
Yes. The course is intentionally model-agnostic — no model names, no version numbers, no tricks that depend on a particular implementation. Models will change. The skill of specifying what you want clearly enough for a system to act on it won't. The same was true for SQL queries thirty years ago and it'll be true for whatever comes next.
Why no video?
Same reason as everything else here: video isn't searchable, isn't skimmable, and demonstrates a vague answer to 'what does a good prompt look like?' instead of letting you see and re-read the actual prompt text. The whole course is built around bad/good prompt pairs you can scan and copy. Video would be a worse vehicle for that.
The first unit is two minutes.
Read it. If it doesn’t change how you write your next prompt, close the tab and forget you came. If it does — you have a long weekend of reading ahead, and a sharper way of working on the other side.