How does Atlas handle Bun's integrated toolchain?

Atlas is designed to work direct with Bun's integrated toolchain. It recognizes and leverages `bun test` for running tests, `bun install` for managing dependencies, and `bun fmt` for code formatting, integrating these commands into its planning and execution workflows.

Can Atlas understand Bun-native APIs like Bun.serve?

Yes, Atlas is configured to read and understand Bun-native APIs such as `Bun.serve`, `Bun.file`, and `bun:sqlite`. It uses AST declarations to index these specific APIs, allowing you to query their usage and definitions within your codebase.

Is it safe to let Atlas explore my Bun codebase?

Yes, Atlas ensures safety during exploration. Its `explore` subagent operates with a deny-by-default permission set, allowing only read-only operations like `grep` and `glob`. All tool calls are permission-gated, requiring your explicit approval before any action that could modify files.

How does Atlas help with Bun dependency management?

Atlas understands Bun's dependency management by reading your `bun.lock` and `package.json` files. It can identify installed packages and even suggest replacing Node compatibility shims with native Bun APIs, confirming behavior with `bun test`.

What if Atlas makes a mistake in my Bun project?

Atlas operates with multiple layers of safety. It drafts plans in a read-only agent, computes a unified diff for every proposed change, and requires your approval before writing any files. All edits are also snapshotted as git patches for easy rollback.

Can Atlas help me refactor Node.js code to Bun APIs?

Yes, Atlas can assist in refactoring. You can ask Atlas to replace a Node compatibility shim with a native Bun API, such as converting a Node.js file operation to `Bun.file`. It can then run `bun test` to confirm the refactored behavior.

Does Atlas support Bun's fast iteration speed?

Absolutely. Atlas leverages Bun's near-instant iteration speed, especially when running `bun test`. This allows Atlas to quickly execute tests behind a permission prompt, iterate on failures, and confirm changes with minimal delay, accelerating your development cycle.

Onboard to an Unfamiliar Bun Codebase with Atlas in 2026

Atlas helps Bun developers in 2026 rapidly build a working mental model of any unfamiliar repository without reading every file. It leverages Bun's integrated toolchain, understanding `bun test` for verification, `bun install` for dependencies, and `bun fmt` for code style, to provide context-rich insights and accelerate your onboarding process.

How does Atlas understand a Bun codebase's structure?

Atlas rapidly builds a structural understanding of any Bun codebase by 2026, starting with its core files like `package.json` and `bun.lock`. It uses `codebase_search` to semantically index declarations and `glob` to map the directory shape, providing a high-level overview in just a few seconds.

When you first encounter an unfamiliar Bun project, Atlas doesn't just look at filenames; it starts from meaning. Atlas uses `codebase_search` to query a semantic index built from AST declarations, not blind line windows. This means you can ask a plain-language question, such as 'how requests are authenticated', and Atlas returns ranked snippets with relevant file paths, even if the files have obscure names. Before diving into specific files, Atlas runs `glob` on the top-level directories. This provides a quick visual map of the package layout and naming conventions, helping you understand the project's architecture, including where `Bun.serve` or `bun:sqlite` implementations might reside, without opening a single file. Atlas also reads your `package.json` scripts and `bun.lock` to understand the project's dependencies and common operations, like `bun test` or `bun install`.

How does Atlas navigate Bun code and dependencies?

Atlas navigates Bun code efficiently by 2026, focusing on the most relevant files first. After an initial semantic search, it reads the top 2-3 ranked files and then uses the `lsp` tool's `goToDefinition` operation to follow imports, quickly mapping out the dependency graph for `Bun.file` or other native APIs.

Once Atlas has an initial understanding of the codebase structure, it deepens its knowledge by focusing on critical files. Following the results from `codebase_search`, Atlas uses the `read` tool to pull the two or three files ranked highest for your query. From these entry points, Atlas leverages the `lsp` tool's `goToDefinition` operation. This allows it to follow imports and understand how different modules connect, whether they are local files, `node_modules` dependencies managed by `bun install`, or native Bun APIs like `Bun.serve` or `bun:sqlite`. This targeted approach means Atlas builds a precise mental model of the relevant code paths without requiring you to manually trace every import or read every file in the repository.

How does Atlas safely explore a Bun repository?

Atlas ensures safe exploration of any Bun repository by 2026 through its `explore` subagent, which operates with a deny-by-default permission set. This subagent can perform wide sweeps using tools like `grep` and `glob` but is strictly prevented from making any changes, offering a secure way to investigate unfamiliar code.

For broader investigations or when you need to search across a wider scope without risking unintended modifications, Atlas delegates work to the `explore` subagent. This subagent is invoked through the `task` tool and is defined with a deny-by-default permission set. This means it can only execute a predefined, limited set of tools: `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. Crucially, it cannot write files or execute arbitrary commands that could alter the codebase. This read-only constraint ensures that while the `explore` subagent can perform wide sweeps to find patterns, identify `Bun.file` usage, or locate `package.json` scripts, it cannot change anything while it looks around. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, providing an additional layer of safety.

How does Atlas ensure code quality and review for Bun changes?

Atlas integrates directly with Bun's toolchain to ensure code quality and facilitate review for any proposed changes by 2026. Before any commit, Atlas computes a unified diff for every file edit and surfaces it for approval, and can automatically run `bun fmt` over the diff to maintain consistent style.

When Atlas proposes changes to a Bun codebase, it prioritizes safety and code quality. Atlas drafts a plan in a read-only plan agent and asks for approval before switching to a build agent that can make modifications. For every file edit, Atlas computes a unified diff and surfaces it for your approval, allowing you to review exactly what changes are being made. Before you approve the commit, Atlas can run `bun fmt` over the diff, ensuring that all changes adhere to the project's formatting standards, just as you would manually. Furthermore, Atlas can run `bun test` behind a permission prompt, which takes almost no time with Bun's speed, allowing it to quickly iterate on failures and confirm behavior. Atlas also snapshots file changes as git patches, so edits can be easily diffed and rolled back if needed, providing robust version control integration.

Step by step

01Initialize Atlas within your Bun project directory, ensuring `bun.lock` and `package.json` are present for Atlas to read your Bun-native APIs like `Bun.serve` and `bun:sqlite`.
02Ask Atlas a plain-language question about the codebase's functionality using `codebase_search`, for example: `codebase_search 'how requests are authenticated'` to query the semantic index.
03Run `glob .` to quickly visualize the top-level directory structure and understand the Bun project's package layout and naming conventions before opening any files.
04Use the `read` tool to examine the two or three files `codebase_search` ranked highest, then follow imports and definitions with the `lsp` tool's `goToDefinition` operation to trace Bun-specific module interactions.
05Delegate wide sweeps or deeper investigations to the `explore` subagent via the `task` tool, for instance: `task explore 'grep for all instances of Bun.file across the project'`.
06Record any open questions or areas for further investigation as a `todowrite` list, ensuring your learning progress and remaining tasks are preserved for the next turn.
07If making changes, let Atlas run `bun test` behind a permission prompt to quickly confirm behavior, leveraging Bun's near-instant iteration speed.
08Before approving any commit, have Atlas run `bun fmt` over the generated diff to ensure all changes adhere to Bun's formatting standards.

Frequently asked questions

How does Atlas handle Bun's integrated toolchain?: Atlas is designed to work direct with Bun's integrated toolchain. It recognizes and leverages `bun test` for running tests, `bun install` for managing dependencies, and `bun fmt` for code formatting, integrating these commands into its planning and execution workflows.
Can Atlas understand Bun-native APIs like Bun.serve?: Yes, Atlas is configured to read and understand Bun-native APIs such as `Bun.serve`, `Bun.file`, and `bun:sqlite`. It uses AST declarations to index these specific APIs, allowing you to query their usage and definitions within your codebase.
Is it safe to let Atlas explore my Bun codebase?: Yes, Atlas ensures safety during exploration. Its `explore` subagent operates with a deny-by-default permission set, allowing only read-only operations like `grep` and `glob`. All tool calls are permission-gated, requiring your explicit approval before any action that could modify files.
How does Atlas help with Bun dependency management?: Atlas understands Bun's dependency management by reading your `bun.lock` and `package.json` files. It can identify installed packages and even suggest replacing Node compatibility shims with native Bun APIs, confirming behavior with `bun test`.
What if Atlas makes a mistake in my Bun project?: Atlas operates with multiple layers of safety. It drafts plans in a read-only agent, computes a unified diff for every proposed change, and requires your approval before writing any files. All edits are also snapshotted as git patches for easy rollback.
Can Atlas help me refactor Node.js code to Bun APIs?: Yes, Atlas can assist in refactoring. You can ask Atlas to replace a Node compatibility shim with a native Bun API, such as converting a Node.js file operation to `Bun.file`. It can then run `bun test` to confirm the refactored behavior.
Does Atlas support Bun's fast iteration speed?: Absolutely. Atlas leverages Bun's near-instant iteration speed, especially when running `bun test`. This allows Atlas to quickly execute tests behind a permission prompt, iterate on failures, and confirm changes with minimal delay, accelerating your development cycle.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

Atlas for Bun: Terminal-Native AI Coding in 2026

Atlas is a terminal-native AI coding agent for Bun. Swap Node compatibility shims for Bun.serve and bun:sqlite, iterate with bun test, and format with bun fmt in 2026.

Migrate a deprecated API across every callsite in Bun with Atlas in 2026

Effortlessly migrate deprecated APIs across your Bun codebase in 2026 using Atlas. Ensure every callsite is updated with precision, leveraging `bun test` and `bun fmt` for verified changes.

Self-review your working diff before committing in Bun with Atlas in 2026

Catch your own mistakes in uncommitted Bun diffs before they reach review or CI. Atlas helps Bun developers in 2026 self-review code, run `bun test`, and `bun fmt`.

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.

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.

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

Trace a runtime bug from a stack trace in Bun with Atlas in 2026

Pinpoint Bun runtime bugs from production stack traces using Atlas, the terminal-native AI agent. Quickly identify the responsible line and apply fixes without a debugger attached in 2026.

Browse this resource hub