The AI Coding Assistant Landscape
Compare the three kinds of AI coding assistant, chat, inline, and agent, and learn which to reach for and how prompting changes between them.
TL;DR
- Assistants come in three shapes: chat, inline completion, and agents that edit files and run commands.
- Chat is best for reasoning and one-off generation; inline is best for in-flow completion; agents are best for multi-file tasks.
- The more autonomy a tool has, the more your prompt must define scope and stopping conditions.
Chat Assistants
What They AreA conversation window such as ChatGPT or Claude where you paste context and read full replies.
You -> prompt (+ pasted code)
Model -> full answer you copy backBest ForPlanning, explaining, generating isolated functions, and comparing approaches.
"Compare two ways to debounce in TS
and recommend one for a React input."Prompting NoteThey only know what you paste, so include the relevant code and versions.
Paste the type, the error, the file.
No paste = the model guesses.Inline Completion
What It IsSuggestions that appear as you type, driven by the code and comments around your cursor.
// sort users by signup date, newest first
[Tab to accept the suggestion]Best ForFinishing lines, boilerplate, repetitive patterns, and tests that mirror existing ones.
const byDate = users.sort((a, b) =>
/* completion fills this in */Prompting NoteYour 'prompt' is the surrounding code: clear names and a leading comment steer it.
Good names + a precise comment
= better completions.Coding Agents
What They AreTools like Cursor composer or Claude Code that read, edit, and create files and run commands.
Goal -> agent reads repo
-> edits files -> runs testsBest ForMulti-file features, refactors across a codebase, and tasks with many steps.
"Add a /health endpoint, a test for it,
and wire it into the router."Prompting NoteDefine scope and a stopping condition, or the agent over-reaches.
"Only touch src/api. Stop when the
new test passes. Do not change config."Choosing Fast
One Line Or IdeaReach for inline completion to finish what you are already typing.
Inline -> stay in flowThink Or ExplainUse chat to plan, compare options, or understand code before you touch it.
Chat -> reason firstWhole TaskHand a scoped ticket to an agent, then review the diff it produces.
Agent -> delegate + reviewTips
- Match the tool to the task: ask chat to plan, let inline finish the line, and send agents whole tickets.
- For agents, say what 'done' looks like and which files are in scope, or they wander.
Warnings
- Inline completion acts on the surrounding code, so a misleading comment or name steers it wrong.
- Agents can edit many files and run commands; review their diffs before you accept or commit.
In Practice
The same goal, 'add input validation to a signup form', asked the right way for each kind of assistant. Notice how the amount of context you supply shrinks as the tool gains access to your files.
- In chat you paste the component, because the model cannot see your files.
- With inline completion a precise comment above the handler does the steering.
- The agent is given scope and a done condition and finds the files itself.
- In every case you still name the exact rules you want enforced.
# CHAT (paste the component, then ask)
Here is SignupForm.tsx: <paste>
Add validation: email format, password >= 8
chars. Return the updated component only.
# INLINE (type a comment, accept suggestion)
// validate: email is RFC-ish, password >= 8 chars,
// return a map of field -> error message
function validate(values) {
# AGENT (scope + stop condition)
Add client-side validation to the signup form
(email format, password >= 8). Update the form
component and its test. Only touch src/auth.
Stop when the test passes.FAQ
Inline assistants (like classic Copilot completion) suggest the next lines where your cursor is. Agents (like Cursor's composer or Claude Code) take a goal, then read, edit, and create files across the project and can run commands, so they handle larger tasks but need tighter instructions.
The core recipe, task plus context plus constraints plus format, works everywhere. What changes is how much context the tool already has: an agent may read files itself, while a chat window only knows what you paste in.
Start with a chat tool to learn how prompts shape output, since you see the full request and response. Add inline completion for speed, then move to agents once you are comfortable reviewing multi-file diffs.
Yes. Reading the repo gives them context, not intent. You still have to state the goal, the constraints, and when to stop, or the agent optimizes for its own guess of 'done'.