How does Atlas run Deno tests?

Atlas uses its `bash` tool to execute `deno test` commands, allowing you to specify filters like `--filter "test_name"` to isolate a single failing test, just as you would manually in 2026. This direct execution ensures compatibility with all `deno test` flags and behaviors, providing a familiar debugging environment for Deno developers.

Can Atlas trace Deno module imports?

Yes, Atlas leverages its `lsp` tool to perform `goToDefinition` and `findReferences` operations, effectively tracing imports and function calls within your Deno modules. This capability extends to understanding dependencies specified via JSR and npm specifiers, as well as those defined in your `deno.json` import map, providing a comprehensive view of your Deno project's structure.

What Deno configuration files does Atlas support?

Atlas reads your `deno.json` or `deno.jsonc` file to understand crucial project configurations. This includes import maps, JSR and npm specifiers, and any tasks defined within the config, ensuring Atlas operates within your Deno project's specific context and adheres to its setup and permissions in 2026.

How does Atlas ensure safety when modifying Deno code?

Atlas employs a robust permission-gated system where every tool call, including code modifications, requires explicit approval. It drafts a plan in a read-only plan agent, presents a unified diff for all proposed code edits, and connects to Model Context Protocol servers, providing transparency and control over changes to your Deno codebase.

Can Atlas help with Deno permissions?

Yes, Atlas can assist in refining Deno's permission flags. It can analyze your code and suggest tightening broad `--allow-all` Deno tasks down to the specific scopes the code truly needs, such as `--allow-net` and `--allow-read`, aligning with Deno's secure-by-default runtime model and enhancing your project's security posture.

How does Atlas handle Deno dependencies?

Atlas streamlines Deno dependency management. Instead of hand-editing your import map, you can instruct Atlas to add dependencies using `deno add jsr:@std/...` or other specifiers. Atlas will then correctly update your project's configuration, ensuring new packages are integrated direct into your Deno environment.

Does Atlas support Deno's formatting and linting tools?

Absolutely. Atlas integrates with Deno's built-in quality tools. It can run `deno fmt` to format your code, `deno lint` to check for stylistic and potential issues on proposed diffs, and `deno check` behind a permission prompt, ensuring your Deno codebase maintains high standards and adheres to best practices.

What if a Deno fix spans multiple files?

For fixes that are more extensive and span several hunks or multiple files, Atlas can utilize its `apply_patch` tool. This method is more robust and efficient than chaining multiple `edit` commands, allowing for comprehensive and atomic changes across your Deno project while maintaining reviewability through unified diffs.

Debug a Single Failing Test in Deno with Atlas in 2026

Deno developers in 2026 can debug a single failing test efficiently with Atlas by leveraging its `bash` tool to run `deno test` with specific filters, then using `lsp` to trace the call graph, and `edit` to apply fixes. Atlas integrates directly with Deno's batteries-included toolchain, making the debugging workflow intuitive and powerful for identifying and resolving code issues.

How Atlas isolates a failing Deno test

In 2026, Atlas isolates a single failing Deno test by executing `deno test` directly via its `bash` tool, allowing you to apply the same filter flags you would use manually. This ensures the test output is focused, often reducing hundreds of lines of logs to just a few relevant ones for efficient debugging.

Atlas leverages its `bash` tool to run `deno test` commands, mirroring how a Deno developer would manually debug. When a specific test fails, Atlas can execute `deno test --filter "my_failing_test_name"` to run only that test. This capability is crucial because it drastically reduces the amount of output, making it easier to pinpoint the exact failure. Since `bash` is a real shell, all standard Deno test runner flags, such as `--allow-net` or `--allow-read` for permissions, are available to Atlas, ensuring the test runs in the correct environment as defined in your `deno.json` or `deno.jsonc` configuration.

Tracing Deno code with Atlas's LSP tool

To understand why a Deno test fails, Atlas uses its `lsp` tool to walk the call graph, starting from the test and the module it exercises. This allows the agent to perform `goToDefinition` and `findReferences` operations, providing a precise understanding of code flow within your Deno project in 2026.

Once a failing Deno test is isolated, Atlas employs its `lsp` tool to delve into the codebase. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, which enables highly accurate code navigation. The `lsp` tool can perform `goToDefinition` to jump from a function call in the test to its implementation in a Deno module, or `findReferences` to see all usages of a variable or function. This is particularly effective for Deno projects, which often rely on explicit import maps and JSR or npm specifiers, allowing Atlas to accurately trace dependencies and understand the full call path leading to the test failure.

Forming and testing hypotheses in Deno

After tracing the Deno code, Atlas forms a hypothesis and checks it by adding temporary logging or re-running tests with verbose flags. In 2026, Atlas uses its `edit` tool to insert `console.log()` statements into your Deno modules or its `bash` tool to re-execute `deno test` with `--verbose`.

With a clear understanding of the Deno code's flow, Atlas can formulate a hypothesis about the root cause of the test failure. To validate this, Atlas can use its `edit` tool to insert temporary `console.log()` statements directly into the Deno source files, allowing you to inspect variable states at runtime. Alternatively, Atlas can re-run the `deno test` command via `bash` with additional flags like `--verbose` to get more detailed output from the Deno runtime. This iterative process of modifying code, running tests, and observing output is a core part of Atlas's debugging workflow, providing the same flexibility a Deno developer would have manually.

Fixing Deno code and reviewing changes

Atlas fixes production code in Deno projects using its `edit` tool for small changes or `apply_patch` for more extensive modifications spanning several hunks. Every proposed change, whether a single line or a multi-file patch, is presented as a unified diff for your approval in 2026.

Once the root cause of the Deno test failure is identified, Atlas proceeds to fix the production code. For minor adjustments, the `edit` tool is used to make precise changes to specific lines or sections of a Deno module. If the fix is more complex, spanning multiple files or requiring significant refactoring, Atlas can use `apply_patch` to apply a comprehensive set of changes. Crucially, Atlas computes a unified diff for every file edit and surfaces it for your approval before writing any changes to disk. This ensures transparency and allows you to review and understand every modification Atlas proposes for your Deno codebase, integrating with your existing `git` workflow.

Ensuring Deno code quality after a fix

After fixing a failing Deno test, Atlas ensures code quality by re-running the single test, then the full suite, and removing any temporary logging. In 2026, Atlas can also run `deno fmt` and `deno lint` on the diff, and `deno check` behind a permission prompt, maintaining high standards.

The debugging workflow with Atlas extends beyond just fixing the immediate issue. After applying a code fix, Atlas first re-runs the single failing Deno test to confirm the fix. Then, it executes the full `deno test` suite to ensure no regressions have been introduced. Any temporary logging added during the hypothesis testing phase is automatically removed by Atlas. Furthermore, Atlas integrates with Deno's built-in quality tools: it can run `deno fmt` to ensure consistent code style and `deno lint` on the modified files. Atlas can also perform `deno check` behind a permission prompt, verifying type safety and module resolution across your Deno project, ensuring the codebase remains robust and well-maintained.

Atlas's safety and permission model for Deno

Atlas operates with a robust safety and permission model, crucial for Deno's secure runtime environment in 2026. Every Atlas tool call, including those for `deno test` or `deno add`, is permission-gated against `allow`, `ask`, and `deny` rules, and a read-only plan agent drafts a strategy before switching to a build agent.

Atlas's design philosophy aligns perfectly with Deno's emphasis on security and explicit permissions. Every tool call Atlas makes, whether it's running `deno test`, adding dependencies with `deno add (JSR)`, or modifying files, is permission-gated. You can configure `allow`, `ask`, or `deny` rules for specific operations, giving you granular control. Before any changes are made, Atlas drafts a plan in a read-only plan agent, which you can review. Only after your approval does it switch to a build agent to execute the plan. This multi-layered safety mechanism, combined with Atlas's ability to help tighten Deno's `--allow-all` tasks to specific `--allow-net` or `--allow-read` scopes, ensures that your Deno project remains secure and under your full control.

Step by step

01Ask Atlas to run just the failing Deno test: `atlas run bash -- deno test --filter "my_failing_test_name"`.
02Instruct Atlas to read the relevant Deno test file and the module it exercises: `atlas read tests/my_test.ts src/my_module.ts`.
03Use Atlas's `lsp` tool to walk the Deno call graph, performing `goToDefinition` and `findReferences` to understand code flow.
04Ask Atlas to form a hypothesis and add temporary `console.log()` statements to your Deno module using `edit`, or re-run `deno test` with `--verbose` via `bash`.
05Re-run the single Deno test with Atlas to observe the new logging or verbose output: `atlas run bash -- deno test --filter "my_failing_test_name"`.
06Instruct Atlas to fix the production Deno code using `edit` for small changes or `apply_patch` for multi-hunk modifications, reviewing the unified diff.
07Re-run the single Deno test to confirm the fix, then run the full `deno test` suite to check for regressions: `atlas run bash -- deno test --filter "my_failing_test_name"` then `atlas run bash -- deno test`.
08Ask Atlas to remove any temporary logging you added and run `deno fmt` on the modified Deno files: `atlas edit src/my_module.ts --delete-line 15` then `atlas run bash -- deno fmt src/my_module.ts`.

Frequently asked questions

How does Atlas run Deno tests?: Atlas uses its `bash` tool to execute `deno test` commands, allowing you to specify filters like `--filter "test_name"` to isolate a single failing test, just as you would manually in 2026. This direct execution ensures compatibility with all `deno test` flags and behaviors, providing a familiar debugging environment for Deno developers.
Can Atlas trace Deno module imports?: Yes, Atlas leverages its `lsp` tool to perform `goToDefinition` and `findReferences` operations, effectively tracing imports and function calls within your Deno modules. This capability extends to understanding dependencies specified via JSR and npm specifiers, as well as those defined in your `deno.json` import map, providing a comprehensive view of your Deno project's structure.
What Deno configuration files does Atlas support?: Atlas reads your `deno.json` or `deno.jsonc` file to understand crucial project configurations. This includes import maps, JSR and npm specifiers, and any tasks defined within the config, ensuring Atlas operates within your Deno project's specific context and adheres to its setup and permissions in 2026.
How does Atlas ensure safety when modifying Deno code?: Atlas employs a robust permission-gated system where every tool call, including code modifications, requires explicit approval. It drafts a plan in a read-only plan agent, presents a unified diff for all proposed code edits, and connects to Model Context Protocol servers, providing transparency and control over changes to your Deno codebase.
Can Atlas help with Deno permissions?: Yes, Atlas can assist in refining Deno's permission flags. It can analyze your code and suggest tightening broad `--allow-all` Deno tasks down to the specific scopes the code truly needs, such as `--allow-net` and `--allow-read`, aligning with Deno's secure-by-default runtime model and enhancing your project's security posture.
How does Atlas handle Deno dependencies?: Atlas streamlines Deno dependency management. Instead of hand-editing your import map, you can instruct Atlas to add dependencies using `deno add jsr:@std/...` or other specifiers. Atlas will then correctly update your project's configuration, ensuring new packages are integrated direct into your Deno environment.
Does Atlas support Deno's formatting and linting tools?: Absolutely. Atlas integrates with Deno's built-in quality tools. It can run `deno fmt` to format your code, `deno lint` to check for stylistic and potential issues on proposed diffs, and `deno check` behind a permission prompt, ensuring your Deno codebase maintains high standards and adheres to best practices.
What if a Deno fix spans multiple files?: For fixes that are more extensive and span several hunks or multiple files, Atlas can utilize its `apply_patch` tool. This method is more robust and efficient than chaining multiple `edit` commands, allowing for comprehensive and atomic changes across your Deno project while maintaining reviewability through unified diffs.

Try Atlas in your terminal

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

Install Atlas

Related guides

Debug a Single Failing Test with Atlas in 2026

How to debug one failing test with Atlas in 2026: run it in isolation with bash, walk the call graph with the lsp tool, and fix the code, not the assertion.

Atlas for Deno: Terminal-Native AI Coding in 2026

Atlas is a terminal-native AI coding agent for Deno. Tighten --allow-all down to real permission scopes, add JSR deps, and run deno test and deno check in 2026.

Audit a Deno Repository with Parallel Subagents in Atlas, 2026

Sweep your Deno codebase for issues without context window limits using Atlas's parallel subagents. Leverage deno test, deno fmt, and JSR for efficient, permission-gated audits in 2026.

Document a Deno Module with a README in 2026

In 2026, Atlas helps Deno developers generate accurate README documentation directly from source code. Leverage deno test, deno fmt, and JSR with AI-driven code analysis.

Onboard to an Unfamiliar Deno Codebase with Atlas in 2026

Deno developers in 2026 can use Atlas to quickly build a mental model of new codebases. Leverage Deno's toolchain, `deno.json`, and semantic search to understand projects without reading every file.

Refactor a Legacy Deno Module with Atlas in 2026

Safely refactor legacy Deno modules in 2026 without breaking callers. Atlas uses `deno test`, `deno fmt`, and `deno.json` to ensure structural changes preserve behavior and API contracts.

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

Pinpoint Deno runtime bugs from production stack traces to a fix using Atlas. Go from a raw stack trace to the exact line of code and a solution, leveraging Deno's toolchain and Atlas's AI without a debugger.

Rename a symbol across the repo in Deno with Atlas in 2026

Refactor Deno code with Atlas to rename functions, classes, or constants across your repository. Atlas uses Deno's LSP for precise renames, ensuring all references are updated, including those in comments and strings

Browse this resource hub