Prompt engineering is about writing a good single message. Conversation design is the older idea, from human-computer interaction (HCI), about structuring a productive back-and-forth over many turns. Working with a coding agent is a dialogue, and the shape of that dialogue determines whether you converge on the right result or talk past each other.
Why it is different from prompting
A prompt is one turn. A conversation is a sequence of turns where each side builds on shared understanding. Research on human dialogue names the mechanics that make this work: turn-taking, grounding, and repair. They apply directly to working with an agent.
Turn-taking: keep turns small
A conversation goes well when turns are appropriately sized. Ask for one thing, let the agent respond, react, then continue. If you cram five requirements into one turn, you lose the ability to correct course between them. Short turns give you frequent checkpoints and keep both sides aligned on where you are.
Grounding: build shared understanding
Grounding is the process of establishing common ground: making sure both parties actually share the same picture before acting. With an agent, you ground by:
- Having it restate the task in its own words before it builds. If the restatement is wrong, you caught a misunderstanding for free.
- Confirming assumptions explicitly ("I am assuming Postgres, not MySQL. Correct?").
- Referring to shared artifacts (the spec, a file, a prior decision) so "it" and "that" are unambiguous.
Skipping grounding is how you get a confident answer to a question you did not ask.
Grounding in practice: before and after
Ungrounded, the agent guesses and you find out later:
You: "Add caching to the dashboard query." Agent: (silently picks in-memory caching, no expiry) "Done."
Grounded, you surface the decisions first:
You: "Add caching to the dashboard query. Before coding, tell me back what you are caching, where the cache lives, and when it expires." Agent: "I plan to cache the per-user results in Redis with a 60s TTL, keyed by user id. Correct?" You: "Yes, but key by user id plus filter state."
Ten seconds of grounding replaced a wrong implementation and a rebuild.
Repair: recover from breakdowns
Repair is how conversations recover when they go off track, and they will. Good repair habits:
- Name the breakdown specifically: "You changed the API signature, which I asked you not to. Revert that and keep the internal change."
- Go back rather than pile on. If the agent is deep in a wrong direction, returning to the last good state (undo, reject, or restart the thread) beats layering corrections on a broken foundation.
- Fix the ground, not just the symptom. If the agent keeps making the same wrong assumption, update the standing instructions (
CLAUDE.md, Cursor rules) so it stops recurring.
Failure modes in a dialogue
- The runaway turn. You gave one giant instruction and the agent barreled through six decisions before you could react. Break it up next time.
- False agreement. "Got it, makes sense!" is not evidence of shared understanding. Ask it to restate or show a plan, not just to acknowledge.
- Correction spiral. Three patch-on-patch fixes have tangled the state. Stop, revert to the last good point, and restart the step cleanly.
- Assumption drift. The same wrong assumption keeps returning because it lives in the model's defaults, not your thread. Move the correction into standing rules.
Manage the thread as a whole
A conversation has an arc. Open by aligning on the goal, work in reviewable steps in the middle, and close by verifying against the acceptance criteria. When the topic changes, start a new thread rather than dragging old context along: a fresh conversation for a fresh task keeps the ground clean (and, as the context lesson noted, the tokens cheap).
Rules of thumb
- One request per turn on anything non-trivial.
- Make the agent restate or plan before it builds; treat "ok!" as not enough.
- When a thread goes sideways, revert and restart rather than patching a broken state.
- Recurring mistakes belong in standing rules, not repeated corrections.
- New task, new thread.
The takeaway
Treat the agent as a collaborator you are in dialogue with, not a search box you fire queries at. Take turns, keep checking that you both mean the same thing, and repair quickly when you do not. These HCI fundamentals predate LLMs by decades, and they are exactly what make a session with one productive.