Atlas is a terminal-native AI coding agent that pairs with Bun, where the runtime, bundler, package manager, and test runner are one binary and iteration is nearly instant. Run atlas in a project with a bun.lock and a package.json, and Atlas reads your Bun-native APIs such as Bun.serve, Bun.file, and bun:sqlite along with the scripts in package.json. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so replacing a Node compatibility shim with the native Bun API is a change you read first.
Why Bun developers use Atlas
Bun developers use Atlas because Bun's speed changes what an agent can do. bun test takes almost no time, so in 2026 Atlas can iterate on a real failure instead of proposing one large speculative change, and it reads your Bun-native APIs (Bun.serve, Bun.file, bun:sqlite) and the scripts in package.json first.
An agent's usefulness is bounded by how fast it can check itself. In ecosystems where the test suite takes four minutes to start, an agent guesses. With Bun, the runtime, bundler, package manager, and test runner are one binary, so the edit, run, and read-the-failure loop is tight enough that Atlas converges by iteration. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so a question like where do we still use a Node shim returns the actual import sites rather than every file that mentions node.
Replacing Node compatibility shims with native Bun APIs
Ask Atlas to replace a Node compatibility shim with the native Bun API and confirm behavior with a test. Most Bun projects carry 3 kinds of leftover from a Node port: an http server that should be Bun.serve, a fs read that should be Bun.file, and a driver that bun:sqlite already covers.
Bun runs Node code, which is why the shims survive. A project ships, the Node-shaped modules keep working, and nobody revisits them. The native equivalents are usually shorter and closer to the runtime: Bun.serve for the HTTP entry point, Bun.file for reads, bun:sqlite for local storage. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so it finds those import sites by declaration and rewrites the call sites together. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so you see the full list of shims before one line changes.
Iterating fast with bun test
Atlas runs bun test behind a permission prompt, which takes almost no time and lets it iterate quickly on a failure. Bun packs 4 tools into one binary, the runtime, bundler, package manager, and test runner, so Atlas can edit, run bun test, read the failing assertion, and correct itself before you finish the first diff.
Fast tests change agent behavior for the better. Rather than writing a large change and hoping, Atlas can make a small edit, run bun test, and use the actual failure output as its next input. The permission prompt still applies, so bun test runs only because you allowed it, and Atlas fans out work to subagents that can run in the foreground or in parallel background sessions when several packages in a workspace need the same shim removed. Every edit that survives the loop still arrives as a unified diff for approval.
Working in a Bun project day to day
Working in Bun day to day with Atlas means 2 files carry the project: package.json and bun.lock. Atlas reads the scripts in package.json alongside your bun.lock, so a request like add a route to the server lands in the Bun.serve fetch handler you already have rather than a Node http server it invented.
Bun projects tend to be lean: a package.json with a handful of scripts, a bun.lock, and code that leans on the runtime instead of a dependency for each primitive. Atlas reading those scripts is what keeps its shell commands honest, because it runs the script you defined rather than guessing at a test command. Atlas lets you switch the active model and provider on the fly with favorites and recents, which is convenient when a quick handler edit and a larger migration off a Node shim want different models.
Review and safety in a Bun repo
Every Atlas tool call is permission-gated against 3 rules, allow, ask, and deny, so in a Bun repo bun test can be allowed while a script that deploys or writes to a real bun:sqlite database file stays on ask. Atlas snapshots file changes as git patches so edits can be diffed and rolled back.
Speed and safety are separate concerns, and Bun only gives you the first. Atlas supplies the second: gated tool calls, a unified diff for every file edit, and git patch snapshots so a bad refactor is one rollback away. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, so after bun fmt has run over the diff the commit contains only the shim removals and the tests that prove they behave the same.
Getting started
- 01Run atlas in a project with a bun.lock and a package.json.
- 02Let Atlas read your Bun-native APIs (Bun.serve, Bun.file, bun:sqlite) and the scripts in package.json.
- 03Ask Atlas to replace a Node compatibility shim with the native Bun API and confirm behavior with a test.
- 04Let Atlas run bun test behind a permission prompt, which takes almost no time and lets it iterate quickly on a failure.
- 05Have Atlas run bun fmt over the diff before you approve the commit.
Frequently asked questions
- how to use an AI coding agent with bun
- Run atlas in a project with a bun.lock and a package.json. Atlas reads your Bun-native APIs (Bun.serve, Bun.file, bun:sqlite) and the scripts in package.json, then proposes edits as unified diffs.
- how do I migrate node code to native bun APIs
- Ask Atlas to replace a Node compatibility shim with the native Bun API and confirm behavior with a test, so an http server becomes Bun.serve and a local database becomes bun:sqlite.
- can an AI agent run bun test
- Yes. Atlas runs bun test behind a permission prompt, which takes almost no time and lets it iterate quickly on a failure rather than guessing at a fix.
- does an AI coding agent format bun code
- Atlas runs bun fmt over the diff before you approve the commit, so review is about the logic rather than the whitespace.
- is it safe to let an AI agent run commands in a bun project
- Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, so bun test can be allowed while deploy scripts stay on ask or deny.
- can I undo an AI refactor in a bun repo
- Yes. Atlas snapshots file changes as git patches so edits can be diffed and rolled back, and every edit is shown as a unified diff first.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Review a pull request in Bun with Atlas in 2026
Streamline your Bun pull request reviews in 2026 with Atlas, the terminal-native AI coding agent. Atlas leverages `bun test`, `bun fmt`, and `bun install` to ensure robust, context-aware code changes.
Run the Bun Test Suite and Triage Failures with Atlas in 2026
Streamline Bun test suite triage in 2026 with Atlas, the terminal-native AI agent. Quickly turn red `bun test` output into a prioritized list of distinct root causes, ensuring efficient bug resolution.
Audit a Bun Repository with Parallel Subagents in 2026
Sweep your Bun repository for problems without context window limits using Atlas's parallel subagents. Leverage bun test, bun install, and bun fmt for efficient, safe audits.
Onboard to an Unfamiliar Bun Codebase with Atlas in 2026
Quickly build a mental model of any Bun codebase using Atlas, the terminal-native AI coding agent. Understand `bun test`, `bun install`, and `bun fmt` workflows.
Refactor a Legacy Module in Bun with Atlas in 2026
Refactor legacy Bun modules safely with Atlas, the terminal-native AI agent. Leverage `bun test` and `bun fmt` for verified changes, ensuring no breaking callers in your 2026 Bun projects. Atlas maps APIs, pins
Diagnose a Hanging or Long-Running Command in Bun with Atlas in 2026
Pinpoint why your Bun scripts or builds are stuck in 2026. Atlas helps Bun developers diagnose if a command is genuinely slow or silently blocked on input, providing clear steps to get unstuck.
Write unit tests for untested code in Bun with Atlas in 2026
Learn how Atlas helps Bun developers in 2026 add real unit tests to untested modules, matching existing repo conventions using `bun test`, `bun install`, and `bun fmt`.
Locate where a behavior is implemented in Bun with Atlas in 2026
Pinpoint the exact file and symbol responsible for any behavior in your Bun codebase using Atlas. Leverage semantic search, `grep`, and LSP tools for precise results and a streamlined workflow.