Coder docs
How Coder's tools work: read, write, edit, bash and connectors so far, with more on the way.
Read
Read opens a file in your project and shows it to Coder with line numbers, the way you'd see it in an editor. It never changes anything.
Text files
- A whole file comes at once when it fits: up to about 100,000 characters.
- A bigger file comes in parts. The first part ends with a note, such as
[PARTIAL view: lines 1-1111 of 1561 (about 90 KB of 127 KB). Read more with offset 1112 and limit 450. …], and Coder reads on before it answers. - A file over 256 KB isn't read whole in one go: Coder reads the part it needs, or searches it first.
- Lines are never cut. A single line too long for one read is read on its own.
- Files in UTF-8 and UTF-16 are read as text. A file saved in an old text format (such as Windows-1252) shows the letters it can't decode as
�, with a note telling Coder to change it only in a way that keeps its format, so the real letters are never lost.
Pictures
- PNG, JPEG, GIF and WebP, up to 128 MB. Coder sees the picture, and a small copy shows under the step in your chat. BMP and TIFF files are not opened as pictures (as in Claude Code): Coder converts them with a command first.
- A big picture is shown at up to 2,000 pixels. Coder is told its real size, how to map a spot back onto it, and how to crop a part for fine detail.
- Pictures you paste or attach are saved in your project's
.coder-picturesfolder (never saved to your branch), so Coder can open them again later in the chat.
PDFs
- Up to 10 pages are read whole. A longer PDF is read by page ranges, at most 20 pages at a time.
- Coder sees every page as a picture as well as its text, so charts and layouts aren't missed. The first pages show small under the step.
- A password-protected or broken PDF says so, and Coder counts a PDF's real pages, even when the file says otherwise.
Notebooks
- Jupyter notebooks (
.ipynb) come as their cells, with each cell's output, charts included. The charts show small under the step.
What read won't open
- A folder: read says it's a folder, and Coder lists what's in it instead.
- Binary files such as
.zipor.xlsx: Coder is told a way to read each kind. - Pipes and devices, and anything outside your project, including a link that points out of it.
Files you mention with @
- Type
@and a file's name in your message, and the file goes into the message, so Coder has it right away. Files whose name matches come first in the list. - A folder comes as its list of files, and a picture is shown. A file too big for one read is named, and Coder reads the part it needs.
What Coder is told on its own
- A missing file comes with the folder Coder is in, so a wrong folder is easy to spot.
- If one of Coder's commands changes a file it has read (a command that shows a file, such as
cat, counts as reading it), Coder is told, with the lines that changed. - After a long chat is summarized to make room, Coder reads again up to five files it was working on, newest first.
Write
Write makes a new file, or replaces a whole file with new content. For a change to part of a file, Coder uses edit.
What you see
- Under each write, what it wrote: a new file's lines, or what changed in a replaced file (lines taken out in red, lines added in green), with the counts on the step, such as
+12or+3 −2. The first lines show; tap for the rest. - For JavaScript, TypeScript and Python files, a language server checks the file after the write. New mistakes show as
Found 1 new diagnostic issue in 1 file(tap to see them), and Coder is told about them at its next step, so it can fix them. - Up to about 90,000 characters at a time. A longer file is written in parts: the start first, then the rest added with edit.
When Coder reads first
- A file it has seen only part of, or a notebook it hasn't read.
- A file that changed since Coder read it, whether one of its own commands or something running in the background changed it. Coder looks at the change before writing over it.
- A big instruction file (
CODER.md,AGENTS.mdor a rules file) it was shown only the start of: Coder reads all of it, or changes part of it with edit.
Files Coder asks you about
- Files that can make code run on your computer when you pull the branch, or change how the project is built, such as
.husky,.vscode,.devcontainer,.envrc,.npmrc,.pre-commit-config.yamland.mcp.json. Coder shows a card with what it would write, and Allow or Don't allow. In a job started from GitHub, it doesn't change them.
When write says no
- A file in an old text format (such as Windows-1252): writing would lose its real letters, so Coder changes it with a command that keeps its format, or asks you about converting it.
- A shortcut (link) to another file: write names the real file instead. A link that leads nowhere, or links that go round in a loop, are refused too.
- A folder's name, or a name with a hidden character in it: write says so.
What stays as it was
- A file in UTF-16 stays UTF-16, and a UTF-8 file's hidden marker at its start (a byte-order mark) stays.
- A script stays runnable, and line endings are written as given.
Edit
Edit changes part of a file: it finds a piece of text that's in the file once, and puts new text in its place. For a new file, or one replaced whole, Coder uses write.
What you see
- Under each edit, what changed: lines taken out in red, lines added in green, with the counts on the step, such as
+3 −2. The first lines show; tap for the rest. - For JavaScript, TypeScript and Python files, a language server checks the file after the edit, as after a write. New mistakes show as
Found 1 new diagnostic issue in 1 file, and Coder is told about them at its next step, so it can fix them. - After an edit in a folder with its own
CODER.md(orAGENTS.md), Coder is shown that file, so it follows that folder's instructions.
How edit finds the text
- The text has to match the file exactly, spaces and indentation included, and be in it once. If it's in the file more than once, edit says how many times, and Coder adds more of the text around it, or changes every place at once.
- Line endings don't get in the way: text with ordinary line endings finds the same text in a file with Windows ones.
- Straight quotes find curly ones (“ ” ‘ ’), and the new text gets curly quotes too.
- With no old text, edit makes a new file, and the folders it goes in. On a file that already has text in it, it says the file already exists.
When the file changed
- If the file changed since Coder read it, and the text being changed is still in it once, the edit goes ahead, and Coder is told the file has other changes it hasn't seen. If the text isn't in it once any more, Coder reads the file again first.
Files Coder asks you about
- The same files as write. The card shows the lines edit would take out and put in, and Allow or Don't allow. A very long line is cut short, with
…at its end. In a job started from GitHub, Coder doesn't change them.
When edit says no
- A file in an old text format, a shortcut (link) to another file, a folder's name, or a name with a hidden character in it: the same as write.
- A file that isn't text, such as a picture: Coder uses a command or a script made for that kind of file.
- A notebook (
.ipynb): a change to its text can break its cells, so Coder replaces it whole with write, or changes a cell with a short script. - A file over 256 MB: Coder works on parts of it with commands.
What stays as it was
- The file's line endings (in a file with mixed ones, every line gets the kind most of its lines have), a UTF-16 file's format, and a byte-order mark.
- A script stays runnable, and a read-only file stays read-only.
Bash
Bash runs a command on your chat's own computer, in your project's folder: installs, tests, builds, scripts and git. It's how Coder does what the file tools can't.
What you see
- Each command shows as a step in plain words, such as
Run the test suite, with what it printed under it. - A
cdcarries over to Coder's next commands, in later messages too, as long as it stays inside your project. - A command that finds nothing isn't a failure: exit code 1 from
grep,find,diff,testorgit diffcounts as an answer. - Output over 30,000 characters is saved to a file. Coder sees the first 2,000 characters and reads or searches the file for the rest.
How long a command may run
- 2 minutes by default. Coder can give a command up to 10 minutes.
- A command still running then isn't lost: it moves to the background and keeps going, and Coder is told where its output is. (A command that starts with
sleepis stopped instead.) - Coder doesn't wait by sleeping: a
sleepof 25 seconds or more is refused, and Coder waits with a monitor instead.
Background commands
- A dev server, a watcher or a long build runs in the background. It keeps running after Coder answers, and Coder is told when it ends, even after its answer, so it can tell you how it went.
- One may run 30 minutes, or up to 2 hours when Coder asks for longer. Settings can raise that.
- One that sits waiting for a typed answer, such as
(y/n), is noticed after 45 quiet seconds, and Coder is told. - One whose output passes 5 GB is stopped.
Your own commands with !
- Start a message with
!to run a command yourself, such as! npm test. It runs right away, as you typed it, with no question first. What it printed shows in the chat, and Coder answers it. - While Coder is working, your command waits in the queue for its turn.
- One that runs past 2 minutes moves to the background, as Coder's do.
Watching for something
- Coder can start a monitor: a command running in the background whose every line comes to Coder as it happens, such as a server's "ready" line or an error in a log. It can listen to a WebSocket too.
- A monitor runs 5 minutes by default, up to 30. One that prints too much is slowed down, then stopped.
When Coder asks first
- The mode under the message box decides (
Ctrl/⌘+Shift+M, then 1 to 3):- Auto: Coder goes ahead, and a second AI checks each step before it runs.
- Accept edits: file changes, and commands that only read, run without asking. Any other command asks.
- Plan: Coder only looks around, then shows you its plan. Approve it, and Coder goes ahead in Auto or Accept edits.
- A question is a card under the step: Yes, Yes, and don't ask again for commands like it, Yes, and switch to auto mode, or No (you can add a note).
- In every mode, Coder asks before a command writes to a protected file (such as one in
.gitor.husky), and before a very long command. A dangerous delete asks too. In Auto, its card waits 2 minutes, and then the delete is blocked.
Permission rules
- In the mode menu, Permission rules… lists your rules: Allow, Ask and Deny, such as
Bash(npm test *)orWebFetch(domain:docs.example.com). A Deny wins over an Ask, and an Ask over an Allow. - Yes, and don't ask again adds an Allow rule for you. Rules are kept per repository.
- A repository's own
.claude/settings.jsonrules count too, as in Claude Code.
Settings and hooks
- In the gear's menu, Settings: how long a background command may run, whether stopping one also stops what it started, a warning for Coder when the disk or memory runs low, your hooks, refusing instead of asking, turning Auto mode off, and Auto mode's rules.
- Hooks are your own commands that run around Coder's steps (before a tool, after it, when a job starts or ends), written as in Claude Code's settings. One can stop a step, change it, or tell Coder something.
Where commands run
- Each chat has its own computer: Ubuntu 24.04, 4 CPUs and 16 GB of memory, with the tools Claude Code's has, and admin rights inside a sealed sandbox. It sleeps when it's quiet and keeps its disk, so what you installed stays.
- Commands run with no secrets in them. Your environment's keys are added on the way out, by Coder's server, and only for the sites they're for.
- What the computer can reach on the internet is set by the chat's environment.
- PowerShell can be turned on for an environment with
CODER_USE_POWERSHELL_TOOL=1.
Connectors
Connectors let Coder use your other services, such as Linear, Notion or Stripe, through their MCP servers. Add one once, and it works in every chat, for Coder and Gloopy.
Adding one
- In the gear's menu, Connectors. Discover lists ready ones (Neon, Supabase, Cloudflare, Sentry, Linear, Notion, Stripe and more), and Add takes any MCP server's address.
- Some sign you in on the service's own page; others take a key. Sign-ins and keys stay sealed on Coder's server: they never reach the chat's computer, and Coder never sees them.
What each tool may do
- A connector's page lists its tools, each set to Always allow, Needs approval or Blocked. Tools that only read start as Always allow, the rest as Needs approval.
- A Blocked tool is never offered. A tool whose service asks for your OK every time always asks, whatever it's set to.
In Coder's chats
- The connectors button by the message box turns each connector on or off for that chat.
- Needs approval asks first in every mode, Auto too. In Plan, a tool that changes something asks first, even one set to Always allow.
- A step shows as
Used DeepWiki: Read Wiki Structure, with the answer under it. A job started from GitHub gets no connectors.
In Gloopy's chat
- Always allow tools run right away. A Needs approval tool asks on Gloopy's card, with what it would send: Allow once, Always allow (which sets that tool to Always allow) or Deny. After a Deny, Gloopy doesn't ask about it again until your next message.
- Gloopy's helpers get only the Always allow tools, as they can't ask you.
Prompts, resources and big answers
- Type
/linear:triage(a connector's name, then one of its prompts) to send that prompt as your message, or@notion:notion://page/…to attach one of its resources. - An answer over 50,000 characters is saved to a file, and Coder reads the part it needs. What a connector sends back is treated as information, never as instructions.
- A call still running after 2 minutes goes on in the background, and Coder is told its answer when it comes.
- Coder loads a connector's tools only when it needs them: see Tool search.
Tool search
Like Claude Code, Coder doesn't get every tool's full instructions at the start of a chat. Some tools wait: Coder sees only their names, and loads the ones it needs with its tool_search tool. Every request stays smaller, however many connectors you add.
Which tools wait
- Coder's own
lsp,web_fetch,web_search,monitorandstop_job, the task tools (task_create,task_get,task_listandtask_update, ortodo_write) and the plan mode tools (enter_plan_modeandexit_plan_mode). - Every connector tool, with no limit on how many. A connector can mark a tool to load at the start.
- The rest, such as
bash,read,edit,write,grep,glob,ask_userand the environment tools, load at the start.
How it works
- Coder is told the waiting tools' names once. A tool it loads stays loaded for the rest of the chat, after a summary too. The chat shows no line for a search.
- If a connector is turned off or removed after Coder loaded one of its tools, Coder is told not to use that tool any more. Connectors waiting for you to sign in, and ones that failed to connect, are named to Coder too, so it can tell you when your request needs one.
- The tools a chat starts with stay in its requests even when one goes away mid-chat (a rule denies it, or its connector is turned off), as in Claude Code, so Grok's cache is kept: Coder is told why it can't use it, and told again when it comes back.
Settings
ENABLE_TOOL_SEARCH, in the chat's environment or the repository's.claude/settings.json: unset ortruekeeps it on;falsegives Coder every tool at the start;autoturns it on once the waiting tools would take up 10% of what Grok can read at once (auto:5for 5%).- A deny rule on
ToolSearch, orToolSearch(*), turns it off too. With it off, a request carries at most 350 tools, Grok's limit. CODER_MAX_MCP_DESCRIPTION_LENGTH(Claude Code'sCLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTHin a repository's settings) sets how much of a connector tool's description Coder gets. Without it: 4,096 characters at the start, 16,384 once loaded.