AI in the editor, not in another tab
The copy-paste loop between a chat window and your code throws away the context that matters. What changes when the assistant reads the repo and proposes a diff.
The way most developers use AI today is a loop: describe the problem in a chat window, paste in a function, read the answer, copy the parts that look right, paste them back, fix what does not compile. It works, and it is faster than not doing it. It also throws away the most valuable thing in the exchange — everything the assistant could have known but was never shown.
The chat window does not know the rest of your repository. It has not seen the helper that already does what it just reimplemented, your naming conventions, the two other call sites of the function it is rewriting, or the test that is about to fail. You are acting as a lossy pipe between a model and a codebase, and doing it hundreds of times a day.
Context is the whole difference
An assistant that lives inside the editor starts from a different position. It can read the file you have open, the files it imports, the project's conventions and the structure of the codebase around the change. The same model, given that context, stops producing plausible generic code and starts producing code that fits the project it is in.
This is why "which model is best" is usually the less interesting question. The gap between a model working blind and the same model working with your repository in view is larger than the gap between two models.
Every change should arrive as a diff
The failure mode of agentic tools is the wall of applied changes: it did fourteen things across nine files, most of them right, and now you are archaeology-ing your own project to find the two that were not.
The discipline that makes this workable is that the model proposes and you review — every edit landing as an inline diff at the exact site of the change, with keep-or-undo per hunk rather than per session. That single design decision is what keeps a developer in the reviewer's seat instead of the passenger seat. It is also the difference between a tool you can use on production code and a toy you use on side projects.
We built Pearl around exactly that rule: agent edits appear as inline diffs with change markers across the file tree, and you keep or undo them one at a time.
Three modes, because three different jobs
"AI assistance" bundles work that has nothing in common. Reading unfamiliar code, planning a refactor and executing a change are different activities with different risk profiles, and giving all three the same interface is why agents feel unpredictable.
Pearl splits them deliberately:
- Ask — read-only questions grounded in your codebase. It never writes and never runs commands, which makes it the right tool for understanding code you did not write.
- Plan — a phased execution plan as an interactive checklist, so you can see and correct the approach before a single line changes.
- Agent — full autonomy: reads, edits, runs tests, delegates to sub-agents. Appropriate when the task is well-bounded and you intend to review the diff.
Choosing the mode is choosing how much authority to delegate. That should be an explicit decision, not something inferred from how you phrased a sentence.
Model choice belongs to you, not to your editor
Tying your workflow to a single vendor's model is a bet that their roadmap will keep matching your needs. It usually stops being true at some point, and by then the workflow is muscle memory.
Pearl keeps four assistants behind one picker — Pearl Scout natively, plus Codex, Claude Code and GitHub Copilot — with Anthropic, OpenAI, Google and DeepSeek reachable through Scout. You switch providers in one click without leaving the chat, and your API keys stay in your operating system's keychain rather than in a vendor's cloud. When a better model ships next quarter, that is a dropdown, not a migration.
What it does not fix
Worth saying plainly, because the marketing in this category rarely does:
- It does not know your business rules. It will write technically correct code that implements the wrong policy, confidently.
- It does not remove the need for tests. Generated code needs the same proof as written code — arguably more, because it was produced faster than it was thought about.
- It raises review load. More changes, produced faster, means the merge gate matters more than it did before. If your team has no required reviewers and no status checks, AI makes that gap wider rather than filling it — the argument we made in where your code lives.
- It cannot be trusted with what you have not read. The rule that keeps teams out of trouble is simple: never merge a diff you did not review. Speed is not the same as unattended.
Where it earns its place
The tasks where an in-editor assistant pays for itself immediately are the boring ones:
- Understanding a codebase you inherited — Ask mode across a repository beats reading files in order.
- Mechanical refactors across many files, where the change is obvious and the tedium is the whole cost.
- Writing the tests you would have written if there had been time.
- Migrations that follow a pattern — the twentieth instance is identical to the first.
- The first draft of code you already know how to write, so your attention goes to reviewing rather than typing.
Practical notes for teams
Pearl runs as a signed desktop app and in the browser, with settings, keybindings, extensions and project memory synced through one account — and full VS Code extension compatibility, so a team's existing setup moves across rather than being rebuilt. For organisations there is per-seat licensing, shared workspace indexing, an admin console and SSO, plus a zero-retention privacy mode for code that must not be retained anywhere.
It is in early access, which is the honest description: it does real work every day on our own products, and it is still moving fast.
The broader point stands regardless of which editor you choose. The value is not in having a model available — everyone has that. It is in whether the model can see your code, and whether you can see exactly what it changed.