How does Atlas run `busted` tests in Lua?

Atlas uses its `bash` tool to execute `busted` commands directly, allowing you to specify filter flags like `-t "test name"` to run a single test in your Lua project.

Can Atlas debug Lua code in Neovim plugins or OpenResty?

Yes, Atlas works with any Lua codebase, including Neovim plugins, OpenResty handlers, or embedded game scripts, by understanding `.lua` modules and `rockspec` files.

How does Atlas ensure my Lua code changes are safe?

Atlas operates with permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every proposed edit to your `.lua` files for approval.

What Lua tools does Atlas integrate with?

Atlas integrates natively with the `busted` test runner, the `luarocks` package manager, and the `stylua` formatter, using their actual commands and configurations.

Can Atlas help me understand the call stack of a failing Lua test?

Absolutely. Atlas uses its `lsp` tool to perform `goToDefinition` and `findReferences` operations, allowing it to walk the call graph from a failing `busted` test through your `.lua` modules.

How does Atlas handle temporary logging for debugging Lua?

Atlas can add temporary `print` statements or other logging to your `.lua` files using the `edit` tool, and then remove them after the debugging session, all with your approval.

Does Atlas support `luarocks` for dependency management?

Yes, Atlas can read and understand the rocks resolved by `luarocks`, ensuring it has full context of your Lua project's dependencies when debugging or making changes.

What if a Lua code fix spans multiple files or hunks?

For complex changes spanning several hunks or files, Atlas can use the `apply_patch` tool to ensure a cohesive and atomic update to your Lua codebase, rather than chaining brittle `edit` commands.

Debug a single failing test in Lua with Atlas in 2026

Atlas empowers Lua developers in 2026 to quickly debug a single failing `busted` test by running it in isolation, analyzing the call graph with `lsp`, and proposing precise code fixes. This process leverages the familiar `busted` test runner and `luarocks` package manager, ensuring a native Lua development experience.

How Atlas debugs a single failing `busted` test in Lua

Atlas in 2026 streamlines debugging for Lua developers by isolating single `busted` tests. It uses its `bash` tool to execute `busted` with specific filter flags, ensuring only the relevant test runs. This focused approach significantly reduces output noise, allowing for quicker problem identification.

When a `busted` test fails in a Lua project, Atlas begins by running just that specific test in isolation. It achieves this by leveraging its `bash` tool to execute the `busted` command with the framework's filter flag. For example, Atlas might run `busted spec/my_module_spec.lua -t "should handle specific input"`. Because `bash` is a real shell, all the debugging levers a Lua developer would use by hand, such as extra logging, a focused test filter, or a verbose flag, are available to Atlas. After running the test, Atlas uses its `read` tool to analyze the assertion and the Lua code it exercises. It then employs the `lsp` tool's `goToDefinition` and `findReferences` operations to walk the call graph, understanding the flow from the failing test through the `.lua` modules to the production code. This detailed analysis helps Atlas form a precise hypothesis about the root cause of the failure.

What Lua commands and files does Atlas use for debugging?

Atlas interacts with standard Lua project files and commands, ensuring a native debugging experience for developers in 2026. It directly invokes `busted` for test execution and reads `.lua` modules, `rockspec` files, and `spec/` directories. This integration respects the existing Lua toolchain.

Atlas operates directly within the Lua ecosystem, recognizing and interacting with its core components. It expects to be run where your `.lua` modules and `rockspec` files reside, allowing it to build its code index with local Ollama embeddings. Atlas reads your module returns, metatables, and the rocks resolved by `luarocks`, providing a comprehensive understanding of your project's structure. For debugging, Atlas uses the actual `busted` command to run tests, such as `busted spec/my_feature_spec.lua -t "test for bug #123"`. When a fix is identified, Atlas uses its `edit` tool to modify the production `.lua` code. If a change spans several hunks or files, Atlas can use `apply_patch` instead of chaining brittle `edit` commands, ensuring atomic and coherent updates to your Lua codebase. After changes, Atlas can run `stylua` over the touched modules to maintain formatting standards.

How Atlas ensures safety and review for Lua code changes

Atlas provides robust safety mechanisms for Lua developers in 2026, ensuring every code change is reviewed and approved. Before any tool execution, Atlas presents permission prompts, and all proposed edits generate a unified diff. This transparent process prevents unintended modifications to `.lua` files.

Safety and developer control are paramount in Atlas's workflow for Lua projects. Every Atlas tool call, including `bash` for running `busted` or `edit` for modifying `.lua` files, is permission-gated against allow, ask, and deny rules before it runs. Atlas first drafts a plan in a read-only plan agent and asks for approval before switching to a build agent to execute changes. For every file edit, Atlas computes a unified diff and surfaces it for your approval before writing to disk. This allows Lua developers to review exactly what changes Atlas proposes to their `.lua` modules. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf. Furthermore, Atlas snapshots file changes as `git` patches, so edits can be easily diffed and rolled back if necessary, providing a secure and auditable debugging experience for Lua code.

Step by step

01Run Atlas in your Lua project root, ensuring your `.lua` modules and `rockspec` files are accessible for indexing.
02Ask Atlas to run the specific failing `busted` test using its `bash` tool, for example: `atlas bash "busted spec/my_module_spec.lua -t 'should handle edge cases'"`.
03Instruct Atlas to read the test and the exercised Lua module, then use the `lsp` tool's `goToDefinition` and `findReferences` to trace the call path within your `.lua` files.
04Form a hypothesis and have Atlas check it by adding temporary logging to the production `.lua` code using the `edit` tool, or re-run `busted` with a verbose flag via `bash`.
05Approve Atlas's proposed fix to the production Lua code using the `edit` tool; for multi-hunk changes, use `apply_patch` to ensure atomic updates to your `.lua` modules.
06After the fix, ask Atlas to re-run the single `busted` test, then the full test suite, and remove any temporary logging from your `.lua` modules.
07Let Atlas run `stylua` over the touched Lua modules to maintain consistent code formatting standards across your project.

Frequently asked questions

How does Atlas run `busted` tests in Lua?: Atlas uses its `bash` tool to execute `busted` commands directly, allowing you to specify filter flags like `-t "test name"` to run a single test in your Lua project.
Can Atlas debug Lua code in Neovim plugins or OpenResty?: Yes, Atlas works with any Lua codebase, including Neovim plugins, OpenResty handlers, or embedded game scripts, by understanding `.lua` modules and `rockspec` files.
How does Atlas ensure my Lua code changes are safe?: Atlas operates with permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every proposed edit to your `.lua` files for approval.
What Lua tools does Atlas integrate with?: Atlas integrates natively with the `busted` test runner, the `luarocks` package manager, and the `stylua` formatter, using their actual commands and configurations.
Can Atlas help me understand the call stack of a failing Lua test?: Absolutely. Atlas uses its `lsp` tool to perform `goToDefinition` and `findReferences` operations, allowing it to walk the call graph from a failing `busted` test through your `.lua` modules.
How does Atlas handle temporary logging for debugging Lua?: Atlas can add temporary `print` statements or other logging to your `.lua` files using the `edit` tool, and then remove them after the debugging session, all with your approval.
Does Atlas support `luarocks` for dependency management?: Yes, Atlas can read and understand the rocks resolved by `luarocks`, ensuring it has full context of your Lua project's dependencies when debugging or making changes.
What if a Lua code fix spans multiple files or hunks?: For complex changes spanning several hunks or files, Atlas can use the `apply_patch` tool to ensure a cohesive and atomic update to your Lua codebase, rather than chaining brittle `edit` commands.

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.

Research a Third-Party API Before Integrating It in Lua with Atlas in 2026

For Lua developers in 2026, Atlas streamlines third-party API research and integration. Leverage `websearch` and `webfetch` for current docs, then integrate with `luarocks`, `busted`, and `stylua`.

Extract a Shared Helper from Duplicated Lua Code in 2026 with Atlas

In 2026, Lua developers use Atlas to find and refactor duplicated logic into shared, tested helpers. Leverage `busted`, `luarocks`, and `stylua` for robust code quality and consistency.

Review a Pull Request in Lua with Atlas in 2026

In 2026, Atlas empowers Lua developers to thoroughly review pull requests by analyzing full file context, checking for breaking changes with LSP, and running `busted` tests.

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

Migrate deprecated Lua APIs across your entire codebase with Atlas in 2026. Leverage lsp for complete callsite enumeration, apply_patch for safe refactoring, and integrate with busted, luarocks, and stylua for a

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

Trace Lua runtime bugs from production stack traces to the exact line and fix in 2026 with Atlas. Leverage Atlas's code search and analysis, integrated with `luarocks` and `busted`.

Rename a Symbol Across Your Lua Repository with Atlas in 2026

Safely rename Lua functions, classes, or constants across your codebase in 2026 with Atlas. Leverage `busted` for tests, `luarocks` for dependencies, and `stylua` for formatting, ensuring accurate, safe refactoring.

Automate GitHub Issue and Pull Request Triage in Lua with Atlas in 2026

Streamline GitHub issue and pull request triage for your Lua projects using Atlas. Leverage real Lua tools like busted, luarocks, and stylua within a secure, permission-gated workflow.

Browse this resource hub