coding-with-ai/01-three-modes/README.md

Three Modes

Key idea

There are three distinct ways to work with AI assistants today, and they suit different problems. Knowing which is which, and which one would actually help for a given problem, is the most important judgment that we would like to develop.

Key goals

• Recognize the three modes: web chat, in-editor extension, and agentic tool
• Understand the characteristic strengths and weaknesses of each
• Develop heuristics for choosing the right mode for a given task

---

The three modes

1. Web chat

Web chat is a a browser- or app-based conversation with a model. You type, paste, or drag content in and the model responds in the same window.

Examples (early 2026): ChatGPT, Claude.ai, Gemini, Microsoft Copilot (web). Each has a free tier with usage limits, a paid plan that removes those limits, and (often) institutional access through a university or employer agreement. You can also self-host a chat interface against a local model — see section 07.

What it's good at:

• One-shot interpretation tasks: explain this error, what does this log mean, what does this regex match
• Multi-turn design discussions: "I'm choosing between approach A and B, what should I think about?"
• Non-code work: drafting documentation, writing commit messages, explaining a concept
• Working with content you do not want the AI to "live in" — a snippet from a paper, output from a server you don't own, a script from an unfamiliar repo

Weaknesses:

• It's disconnected from your project. The model is stateless and has no idea what files exist, what your codebase conventions are, or what you changed five minutes ago, unless you paste it.
• Round-trip friction: copy from terminal → paste into chat → wait → read → copy answer → paste back. Fine for one-shot, but it is painful for iterative editing.
• You have to remember to bring the relevant context with you each time.

2. In-editor extension

An AI assistant living inside your editor (VS Code, JetBrains, Neovim, etc.) with awareness of your open files and project.

Examples (early 2026): GitHub Copilot, Claude (VS Code extension), Codeium, Microsoft Copilot (in VS Code), Cursor and Windsurf (which are VS Code forks with deeper AI baked in).

What it's good at:

• Autocomplete while typing — the model suggests the next few lines as you write
• Inline edits: highlight a block, ask for a refactor or fix, review a diff (a side-by-side view of the proposed changes — what is being added, removed, or modified), accept or reject changes
• "Explain this" on a selection, function, or whole file without leaving the editor
• Quick rename, extract function, add type hints — the kind of work that ought to be in place

Weaknesses:

• Conversation UX is limited compared to web chat — fine for "do X to this code," awkward for "let's talk through the design."
• Easy to accept suggestions you did not fully read (the autocomplete habit).
• The model's context is whatever the extension chooses to feed it — usually the open file plus some recently viewed files. Larger projects can confuse it.

3. Agentic tools

An AI that takes multi-step actions on its own: read files, run commands, edit, run tests, read the output, edit again. You set the goal; the agent runs the loop.

Examples (early 2026): Claude Code (CLI), Cursor agent mode, Microsoft Copilot agent, Cline (VS Code extension), Aider.

What it's good at:

• Multi-file refactors with verification ("rename this concept everywhere and make the tests pass")
• Investigating an unfamiliar codebase ("find where X is defined and tell me how it's wired")
• Larger work units where you would otherwise be the one ferrying information between editor, terminal, and chat
• Repetitive maintenance ("update all these import paths," "add docstrings to this module")

Weaknesses:

• The agent will happily do the wrong thing efficiently. Supervision matters!
• Permissioning matters, too: agents that can run arbitrary shell commands can do real damage if pointed at the wrong directory or given the wrong instructions.
• Cost can scale faster than you expect — multi-step tasks consume many model calls.
• For small, well-scoped edits, an agent is overkill compared to a simple inline edit.

How to choose

Editor vs agentic: what's the actual difference?

The chat/editor split is usually obvious. The editor/agent split trips people up. Two questions clarify it:

• Who drives the loop? With the editor extension, you do — you make one request, see the proposed change, accept or reject, then make the next request. With an agent, the model does — it decides the steps, runs them, and reports back at the end (or at checkpoints you've configured).
• How many actions does the task need? A single targeted edit you can see in front of you is editor work. A task that needs a chain of actions, like reading several files, making changes in multiple places, or running tests, react to the output, is agent work.

In other words, if you can point at the code on screen and say "do X to this," then you want the editor. If the work is "figure out how this codebase does X and change it consistently," then you want an agent.

Starting heuristic

If the work is...	Reach for...	Why
Explain an error, parse a log, interpret some output	Web chat	One-shot interpretation; the answer is words, not code-in-place
A targeted edit you can see in front of you — refactor this function, add types here, rewrite this block	In-editor extension	One action, one diff, one accept/reject decision; you stay in the driver's seat
A task that needs multiple steps — cross-file changes, run-tests-and-fix loops, "explore the project and then change it"	Agentic	The model owns the sequence; you set the goal and review the end state
Deciding between two approaches; talking through a design	Web chat or editor side panel	Conversation UX is what matters; either works (see section 03 for venue choice)
Writing a commit message, README, or documentation	Either chat or editor	Both work — chat if standalone, editor if it should live inline

Two principles underneath the heuristic

Match the mode to the output target. If the answer should be code in a file, use a tool that can put it there (editor or agent). If the answer should be a conversation or an explanation, use chat. Mode-mismatching is what leads to painful copy-paste loops.

Match the mode to the iteration speed. Single-shot interpretation → use a chat. Tight feedback loop on a known file → use an editor. Multi-step plan you would rather not babysit step by step → use an agent.

Exercises

Exercise 1: Think of three recent times you used an AI assistant. For each, classify which mode you used and which mode this guide would suggest. Were any mismatched? If so, what did the mismatch cost you (time, friction, abandoned attempts)?

Exercise 2: Pick one tool from each mode you have access to. Use each one in the next week and keep a one-line note of what you used it for. After a week, look at your notes: are you using each mode for things it is genuinely good at?