An AI IDE is an editor built around an agent. It indexes the whole codebase, so you can ask about the repository rather than one file. It edits several files at once and shows you the change before it lands. It reads a rules file, kept in the repository, that carries your conventions from one session to the next. Many can also run commands, read the test output and try again, and connect to outside tools and data.
The work runs from you, to the agent, to the codebase, and back to you. You stay in the session and decide what stays, which is what separates this from handing a task over and coming back later.
What it is for
- Changes that touch several files: a new field carried from the schema to the screen, a rename, a refactor the type checker can confirm.
- Finding your way around a codebase you do not know, by asking where something happens and why.
- Applying the same convention everywhere, once that convention is written down where the agent reads it.
Who it suits
Developers on codebases that will be maintained for years, who already review each other's code and want an agent's changes held to the same standard. Teams willing to write their conventions down and keep them current, because the editor is only as consistent as what it is told.
How to tell this is your category
- The agent sees the whole repository, not only what you paste.
- You ask for changes in words and review a multi-file diff before accepting it.
- There is a rules file in the repository, or you keep wishing there were.
- If you mostly ask for single pieces of code and paste them in, that is AI-assisted traditional coding. If you mostly brief the agent from a shell, that is terminal and CLI agents. Plenty of people use all three in one day.
What it costs you later
The layer page covers the context tax, drift, and conventions held by one product. These costs are particular to the editor.
- Rules that load everywhere. A rule loaded into every request costs context on every request, whether or not it applies. A long rule about the admin area, loaded into a change to the marketing pages, crowds out the files that matter. The fix is a decision per rule: always on, or only when the task touches its area. Where a rule's scope is set in a header at the top of its file, a malformed header can quietly load a narrow rule into every conversation, and nothing warns you. Check what was actually loaded, not only what you meant to load. Writing and scoping a rules file works through the decision rule by rule, and how to make that check.
- Indexed is not understood. The editor retrieves the files that look relevant to the request. It can miss the one that matters: the module with the unusual convention, the configuration that changes behaviour, the test that pins a quirk on purpose. Too little context leaves gaps, and too much buries the signal. For any change that matters, name the files yourself.
- Accepting is cheaper than reading. A multi-file diff with an accept button invites the click, and a change approved by scrolling has not been reviewed. Keep each request small enough that you read every file it touches, and reject and ask again rather than patching a change you do not understand. Code review is the new bottleneck is the longer argument.
- Connections that act. Editors increasingly connect to outside tools: the issue tracker, a browser, a database, documentation. Each connection runs with the access you gave it, because a protocol is not a sandbox, and the content it returns can carry instructions the agent may follow. Scope every token to the least it needs, and be most careful with any connection that can both read untrusted content and change something. The security section of MCP servers worth knowing when you build with AI goes further.
Choosing one
The category is stable. The products in it change names, owners and pricing faster than codebases change. When you compare them, test the things this page says cost you later, not the demo.
- Can you see exactly which rules and files went into a request?
- Can you scope a rule to one part of the codebase?
- Does it show every file it will change, and let you take some changes and not others?
- What can it run without asking, and can you change that?
- Do your rules live in plain files in the repository, readable by another tool if you switch?