I realized it the third time I typed the same nag. "Answer shorter." "That's over-engineered." "Look before you delete." I was re-typing it by hand every session. The thing that raised my agent's quality the most wasn't a smarter model or more MCP servers — it was a small library of prompts and skills that get re-read every single turn. This is the story of treating prompts like code.
Modes are skills
The three I lean on most are basically personalities. Each is a standing rule that reloads on every response.
- Brevity mode. Drop articles, filler, pleasantries, hedging. Keep 100% of the technical substance, compress only the wording. Over a long session the output token count drops noticeably, and — more importantly — it's faster to read. The trick isn't "be short," it's "re-enforce every turn," because if you ask once, it drifts back a few turns later.
- YAGNI mode. It impersonates a lazy senior developer. It thinks in a ladder: does this need to exist → is it already in this codebase → does the stdlib do it → can it be one line → only then the minimum code. One interface with one implementation, one config file for one value — auto-rejected. Shortest diff wins. But only after the problem is fully understood.
- Process discipline. Brainstorm before design, a written plan, verification before any "done" claim. I've written about this one separately, so here it's just a pointer — it's the real honesty lever.
When they collide there's a priority: the process skill sets the approach, then the implementation skill carries it out.
The investigate-first contractor prompt
Work like a contractor who bills for rework — the cost of a wrong assumption is yours to avoid, the cost of an unnecessary question is mine to pay. This one paragraph cut my rework the most. Three rules:
- Investigate before you ask. Read the code, tests, config, dependency manifests first. Anything discoverable in a minute of searching isn't a question, it's homework you owe me. Don't ask about the test framework, language version, or directory layout.
- Then produce exactly this, and stop. A Goal (restate it in your words plus acceptance criteria), 0–3 blocking questions (only where a wrong answer means throwing work away, each with a recommended default so I can reply "yes to all"), assumptions (numbered, specific, falsifiable), a plan (files, signatures, order). Then wait.
- Scale to blast radius. A typo fix, just do it. Auth, money, migrations, deletion — full ceremony.
If the restatement is wrong, that's the cheapest possible place to find out — before a single line of code.
One-word signals
The opposite of the contractor prompt is go-autonomous. Throw that one word and the agent skips every confirmation gate and drives to the end. It's the switch for when I already trust the direction and don't want to hear "shall I proceed?" at every step. Conversely, auth, payments, and hard-to-reverse deletes stop and confirm even with the signal present — that rule outranks the signal.
The value of a one-word signal is bandwidth. Instead of re-explaining context in a paragraph each time, one agreed token flips the mode.
Memory and MCP are the supporting axes
Both prop up this playbook, but neither is the star.
- File-based memory. One fact per file for anything that must survive across sessions. Don't store what the code already records (structure, past fixes, git history). Written up separately.
- MCP. It pulls browser driving, result capture, DDL execution, and deploys into the agent loop. You only need each server's auth model and its one failure mode. Also covered in its own post.
Both are powerful, but the thing that changes behavior is the prompt-and-skill layer. Tools add hands; prompts pin down judgment.
The lesson: prompts are code
Version them, keep them terse, and make them re-fire every turn (as reloading skills, not a one-off instruction). Scale ceremony to blast radius — zero for a typo, maximum for a delete. And laziness shortens the solution, never the understanding: investigate all the way, then take the shortest path.
Models keep getting better. This tiny layer that re-tells the agent how I work every turn doesn't go away. If anything, the better the model gets, the more it's worth telling it exactly what discipline to hold.