Linguist · Vuelo Labs
Eight principles. One framework. Pin it up.
The framework — Think · Collab · Dispatch · Iterate
Step 01
Think
Get your messy human thoughts together before you touch the machine.
Step 02
Collab
Use the machine to figure out what you actually want — build the brief before you write the brief.
Step 03
Dispatch
Write a clean instruction, define the output and format, and walk away.
Step 04
Iterate
One or two rounds, then stop. The first good version is usually the best.
Pause. The machine doesn't need breaks. You do. Walk away. Come back sharp.
01
The preamble costs energy and changes nothing. The machine doesn't read your mood, doesn't appreciate warmth, and doesn't produce better work because you were polite.
Pattern
start: [the task]
skip: greeting, apology, hedge, thank-you
rule: if a human wouldn't need it to understand the question, remove it
02
"You are a senior editor…" calibrates tone, assumptions, and quality all at once. Without a role, the machine defaults to bland. With one, it has a perspective to speak from.
Pattern
role: [specific expert with relevant experience]
task: [what you need]
tone: [direct / honest / practical — be explicit]
note: the more specific the role, the more specific the output
03
Scope creep in the prompt equals scope creep in the output. Every extra task you add dilutes every other one — and you lose the ability to review anything properly.
Pattern
task: one thing
review: before moving on
next task: only after reviewing
rule: if you wouldn't send step 1 to a colleague unread, don't use it as input for step 2
04
Give it what it needs to do the job well. Nothing more. Too little context produces vague output; too much and it gets lost. Context is a targeted briefing, not a memory dump.
Pattern
context test: does removing this change the output? no → cut it
include: audience, format, constraints, relevant specifics
exclude: project history, background "just in case", emotional context
rule: brief the machine like you'd brief a sharp contractor
05
"Done means X" stops infinite iteration before it starts. When the machine knows the finish line, it runs toward it. When you know it, you stop when you're there.
Pattern
done criteria: [list what "done" looks like]
format: [exact output format expected]
length: [word / character / section count]
check: "tell me when you think it meets all criteria"
06
Quality degrades with over-iteration. The first genuinely good output is almost always the best you'll get. Every round after that takes you further from your original intent.
Pattern
after first output: check against done criteria
if passes: ship it
if one specific thing is wrong: one targeted fix, then ship
max iterations: 2 — rule: "could be better" ≠ "isn't good enough"
07
Context creep is real. A fresh brief is faster than fighting a bad thread. The brief is the asset — not the thread. Leave the history behind, bring only your refined brief.
Pattern
signal to start fresh: same correction 2+ times in a row
action: new conversation
bring: refined brief + one note about what went wrong last time
leave: all previous messages behind
08
"What would help you give me a better answer?" is a completely valid question. You can ask it to ask you questions, to help build the brief you'll then give it.
Pattern
when stuck: "ask me one question at a time to help me figure out what I want"
when improving: "what would help you give me better results on this consistently?"
when briefing: "what do you need to know that I haven't told you?"
Workflow habits
Use the machine to build the brief you'll give the machine.
Before you write a dispatch, have a Collab conversation first. Dump what you know and ask it to help you sharpen the ask.
collab first → dispatch second → never skip the middle step
New task, new conversation.
Don't carry context from one task into the next. Every task starts clean. Old threads are liabilities, not assets.
Give it a role — every time.
The single highest-leverage thing you can add to any prompt. "You are a…" — one sentence, completely different output.
role: [specific expert] — add before anything else
Define done before you start.
Write "done means X" into every dispatch. It stops the over-iteration spiral before it starts and gives you a clear exit point.
done when: [specific, testable criteria]
One task at a time.
Every extra task dilutes every other one. Resist the urge to bundle. Sequential is faster than it looks.
Write a context doc and paste it everywhere.
Build a short document: your role, your industry, your tone, your audience, your always/never rules. Paste it at the top of every new chat.
context_doc: role · industry · tone · audience · always · never
Stop iterating at the first good version.
When it's good, it's done. The feeling it could be 5% better isn't worth the 30% chance you make it worse.
Read the output before you send it.
Make it yours. The machine produced a draft. You produce the final thing. Always read before you forward, publish, or send.