Six ways to ask
a machine.
Direct. One sentence in.
Most people over-engineer. The model is smarter than the average prompt assumes. Direct is what you reach for when the task is obvious to a thoughtful human and the format doesn't matter much. Strip away the role-playing and the ten bullet rules, ask plainly, and accept that the floor is already pretty good.
- +Tasks the model already does well by default
- +Quick edits, rewrites, simple lookups
- +When you trust the model's defaults more than your own scaffolding
- −Anything with format requirements
- −Multi-step reasoning
- −High-stakes output you can't eyeball
Structured. Role · Task · Context · Rules.
If a senior editor handed you a brief, it would have four parts: who's writing, what they're writing, who it's for, and what not to do. Structured prompts are that brief. Boring? Slightly. Reliable? Extremely. This is the default for a reason — it's the prompt you'd want a junior to write before they touched the keyboard.
- +Most production work
- +Anything you'll run more than once
- +Output that has to land a specific way
- −Throwaway one-shot questions
- −Open-ended brainstorms where rules suppress range
Few-shot. Show, don't tell.
Rules tell the model what to do. Examples show it. Two well-chosen pairs (input → desired output) outperform a wall of guidelines almost every time, because language models are pattern matchers wearing a reasoning costume. The hard part isn't the prompt — it's curating examples that aren't subtly contradictory.
- +Output formats hard to describe in words (tone, structure, voice)
- +Classification and labeling
- +Anything where the gold standard is easier to demonstrate than define
- −When you don't have good examples yet
- −Tasks where examples would prime a single answer (creative work)
Chain-of-thought. Make the model think out loud before it commits.
When you ask a person a hard question, the good ones pause. Models can pause too — if you let them. A chain-of-thought prompt explicitly instructs the model to reason through the problem in writing before stating a conclusion. The output is longer, slower, and noticeably better on anything that requires more than recall.
- +Multi-step reasoning, math, logic
- +Decisions that need a defensible 'why'
- +Catching mistakes before they get baked into the answer
- −Latency-sensitive UX
- −Short factual lookups (you'll get a lecture)
Just-in-time. Don't stuff the context.
Stuffing every possible document into the prompt is the AI equivalent of bringing a library to a coffee meeting. Just-in-time prompts assume the model is an agent with tools, and instruct it to retrieve information when it needs it — not before. The prompt becomes a procedure, not a payload. (Inspired by Anthropic's writing on context engineering for agents.)
- +Agents with tools (search, file read, code exec)
- +Long-running tasks where the full context won't fit
- +When source-of-truth data is large and changing
- −Plain chat completions with no tool access
- −When you actually do have all the context handy
Sub-agent. One prompt to plan.
A single prompt trying to do everything is a single prompt failing at everything. The sub-agent pattern splits the work: a planner prompt decomposes the job into discrete sub-tasks, each handed off to a fresh, focused prompt with only the context it needs. The planner reassembles the results. Slower per-call, dramatically more reliable end-to-end.
- +Long, multi-step jobs (research, document generation, codebase changes)
- +Tasks that exceed a single context window
- +When you want auditable intermediate steps
- −Anything you can solve in one round-trip
- −Tight latency budgets (sub-agents add overhead)
The right approach is whichever ships.
Pick a job, pick an approach, watch Meerkat assemble the prompt in front of you. You can change your mind on the next click.