←
How to talk to coding agents
Chapter 02of07

The equation

The simplest frame is an equation. Whatever a coding agent gives you falls out of two things multiplied together: the agent itself, and what you hand it.

AGENTINPUTOUTPUT
()()OUTPUT

That gives you four levers. The point of view this frame nudges you toward is that there exist inputs that produce great outputs — the job is finding them. So how do you actually pull each lever?

TOOLUse a tool that was built for this.

Most people are still defaulting to whatever editor they had before agents were a thing, and bolting AI on. That's leaving the biggest, easiest win on the table.

The frontier here isn't subtle: Cursor, Claude Code, and Codex are meaningfully better at this than VSCode (with stock Copilot) or Antigravity. They're built for the shape of agent work: they slice files into context smarter, manage long-running tasks, persist conversation state, and inject project-aware system prompts. Same model, different tool, different ceiling.

You don't have to commit to one forever. Try an agent-native tool for a week. If your day-to-day doesn't get noticeably easier, go back. It probably will.

MODELPick the smartest model the work warrants.

Calibrate to the stakes of the task, not your defaults. A rough guide:

Fast and cost-friendlySonnet 4.7 · Composer 2
Taste — writing, docs, PRs, UI/UX, animationsOpus 4.8
Problem solving, backend, gnarly debuggingGPT-5.5
Anything tricky, ambiguous, or multi-step+ Thinking on

Models also have distinct styles — how they structure code, what explanations they reach for, where they cut corners under ambiguity. If you're newer to AI coding, you'll attune faster by staying with one model for a while and learning its tics. Hopping between models before you have a feel for any of them mostly trains you to blame the model when half the issue is unfamiliarity.

The biggest trap is "Auto" mode. Tools love offering it because it sounds helpful. In practice, "Auto" is usually optimized for the platform's margin, not your output — it quietly picks a cheaper model when it thinks it can get away with it. Override it whenever the work matters.

Thinking effort is the cheap dial — and it's becoming one of the more important ones to manage. Most tools expose four rungs: low, medium, high, xhigh. They're budget for how long the model gets to deliberate before answering, not quality settings.

LowTrivial edits, format fixes, one-line changes
MediumWell-specced work where the model is mostly executing
HighUnderspecced problems — planning through constraints, tradeoffs, real decisions
xHighThe genuinely hard stuff: novel design, gnarly bugs, long-horizon plans

More isn't always better. Crank xhigh on a simple task and the model will overthink — second-guess obvious choices, invent edge cases, ship something baroque. Leave medium on a gnarly one and it'll underthink — miss a constraint, settle for the first plausible plan. Calibrate to how much thinking you'd need to solve it, and match.

PROMPTBe specific. Show the model what good looks like.

The prompt is the smallest of the four levers, but it's the one people obsess over. The patterns that consistently help are unsexy:

  • Concrete over abstract. "Make this faster" gives the model nothing. "First paint is 2.4s, target under 1s, profile and start with the biggest wins" gives it a job.
  • Anchor on examples. "Match the style of components/PostCard.tsx" beats "make it look nice." Models are great at imitation, mediocre at taste.
  • Say what good looks like. Constraints, success criteria, what to avoid. The agent will gravitate toward whatever you tell it to.

What consistently doesn't:

  • "Be careful." It's not careful. Constraints work; vibes don't.
  • "Think step by step." The model already does, and modern thinking modes do it better than any prompt incantation.
  • Politeness padding. Doesn't hurt, doesn't help. Save the keystrokes.

If you find yourself rewriting the same prompt for the fifth time, stop. The lever you actually need is the next one.

CONTEXTThe biggest lever. Load what the agent needs to see.

Most "the model is dumb today" moments are actually "the model can't see the thing it needs." The prompt is the verb; context is the noun. Get the noun right and the verb almost takes care of itself.

Things to load:

  • Skills and project rules. A CLAUDE.md or .cursorrules that captures your project's patterns, conventions, and the things you're tired of correcting.
  • Reference material. The design doc, the API spec, the related PR. Drop them into the chat. Don't make the agent guess at what's already written down.
  • Screenshots. For UI work, an image of the current state plus a sketch of the target is worth ten paragraphs.
  • MCPs. Wire the agent into your actual systems — repo, dashboards, design tokens, internal docs. Same as giving a junior engineer access to the stack instead of describing it from memory.

Loading the right context is the strongest pull available on any of the four levers. It's also the most boring one, which is why it's underused.

Putting it all together

Treat the output as something you partially authored. Whatever came back, you were part of why it came back that way. When something feels off, walk through the levers and find the one you didn't pull.

Rewrite with concrete details. Paste the error. Name the file. Say what good looks like and what to avoid. If you've rewritten the same prompt five times, the lever you actually need is context.
Load the relevant files, screenshots, design docs, and project rules. The model can't reason about what it can't read. 'The model is dumb today' is almost always 'the model can't see the thing it needs.'
Upgrade to a more capable model for tricky work. If the tool offered "Auto," override it — that mode optimizes for cost, not for you.
For ambiguous, multi-step, or stuck moments, turn thinking up. The cheap dial pays the most often. Drop it back when the work is mechanical.

Prompting and context management are real skills, with as much depth as anything else in the craft — closer to chess than to magic words.