To lock in a Solidity bug fix with a regression test, Atlas guides you through a red-first, green-second workflow, leveraging `forge test` to prove the bug and confirm the fix. Atlas ensures your smart contracts are robust by writing a failing test, running it with `bash`, applying the fix, and then re-running the test to confirm success, all within your Foundry project and using its native toolchain.
How Atlas adds regression tests for Solidity bug fixes
Atlas streamlines the process of adding regression tests for Solidity bug fixes by adhering to a strict red-first, green-second discipline, a proven method for locking in fixes since 2026. It uses its `bash` tool to execute `forge test` and confirm the bug's presence before any code changes are made.
Atlas integrates directly into your Foundry project, understanding the structure of your Solidity contracts in `src/` and your test files in `test/`. When tasked with adding a regression test, Atlas first uses its `bash` tool to run `forge test` on your existing codebase. This step is crucial for reproducing the bug and capturing the exact failing command and output, ensuring the bug is unambiguously present. Atlas then employs its `write` tool to generate a new Solidity test file, typically within your `test/` directory, containing an assertion that specifically fails due to the bug. This new test is designed to be minimal and focused, isolating the problematic behavior. After the failing test is written, Atlas again uses `bash` to run `forge test` on this specific test, confirming it fails as expected. The `bash` tool records the process exit code, providing concrete proof of the failure. Once the bug is confirmed to be reproducible by the new test, Atlas uses its `edit` tool to apply the necessary fix to your Solidity contract. This `edit` tool requires an exact-enough `oldString` and refuses ambiguous multi-match replacements, ensuring precise modifications. Finally, Atlas re-runs the same `forge test` command, expecting the test to now pass, thereby confirming the bug fix. This systematic approach ensures that every bug fix is accompanied by a robust, verifiable regression test.
What Solidity commands and files does Atlas use for regression tests?
Atlas leverages the native Solidity toolchain, specifically `forge test`, to manage and execute regression tests within your Foundry project, a standard practice since 2026. It interacts with your `src/` directory for contract code and `test/` for test files, ensuring direct integration.
For Solidity regression testing, Atlas primarily interacts with `forge test`, the standard test runner for Foundry projects. When reproducing a bug or confirming a fix, Atlas executes `forge test` commands via its `bash` tool. For instance, to confirm a bug, Atlas might run `bash -c 'forge test --match-path test/MyContract.t.sol -vvv'`. When writing a new regression test, Atlas's `write` tool creates a new Solidity file, such as `test/MyContractRegression.t.sol`, containing the specific test logic. This file will typically import the contract from `src/MyContract.sol` and include a `function test_BugFixScenario()` that asserts the incorrect behavior. Atlas also understands the project's `foundry.toml` configuration, allowing it to operate within the established project context. While `soldeer` (via `forge soldeer install`) is used for package management, Atlas primarily focuses on `forge test` for the execution and validation of regression tests. After a fix is applied, Atlas can also run `forge fmt` on the modified files to ensure code style consistency, and `forge snapshot` to analyze gas cost deltas, providing a comprehensive view of the changes.
How does Atlas ensure safety and review for Solidity bug fixes?
Atlas prioritizes safety and transparency in Solidity bug fixes by implementing permission-gated tool calls and presenting unified diffs for every proposed change, a critical feature for smart contract development in 2026. Every action, from writing a test to applying a fix, requires explicit approval.
Ensuring the integrity of Solidity smart contracts is paramount, and Atlas incorporates several safety mechanisms. Every Atlas tool call, including `bash`, `write`, and `edit`, is permission-gated against `allow`, `ask`, and `deny` rules, giving you granular control over its actions. Before making any modifications, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent to execute the changes. This allows you to review the proposed steps without any risk of unintended modifications. When Atlas applies a fix using its `edit` tool, it computes a unified diff for every file edit and surfaces it for your approval before writing to disk. This means you see exactly what lines are added, removed, or changed in your `src/MyContract.sol` or `test/MyContractRegression.t.sol` files. For Solidity projects, where every diff has a gas cost and an attack surface, this level of scrutiny is invaluable. Atlas can also run `forge snapshot` to show you the gas delta before you approve the changes, providing concrete data on the economic impact of your fix. Furthermore, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, ensuring that approved changes are properly version-controlled. This comprehensive review process minimizes risk and maintains high standards for Solidity code quality.
Step by step
- 01Reproduce the bug: Use Atlas's `bash` tool to run `forge test` on your existing Solidity codebase, confirming the bug and capturing the exact failing command and output.
- 02Write the failing test: Instruct Atlas to `write` a new Solidity test file, for example, `test/MyContractRegression.t.sol`, asserting the observed wrong behavior that reproduces the bug.
- 03Confirm test failure: Use Atlas's `bash` tool to execute `forge test` specifically on the newly written regression test, ensuring it fails as expected and Atlas records the process exit code.
- 04Apply the fix: Use Atlas's `edit` tool to modify the relevant Solidity contract in your `src/` directory, implementing the bug fix. Review the unified diff presented by Atlas for approval.
- 05Confirm test pass: Re-run the same `forge test` command via Atlas's `bash` tool on the regression test, verifying that it now passes, confirming the bug fix is effective.
- 06Run wider suite: Execute `forge test` on the entire test suite using Atlas's `bash` tool to check for any collateral damage or unintended regressions introduced by the fix.
- 07Review gas delta and format: Optionally, have Atlas run `forge snapshot` to see the gas cost delta, and then `forge fmt` on the modified files to ensure consistent Solidity code style.
- 08Commit changes: Approve the final changes and allow Atlas to stage and create a git commit on your behalf, locking in the bug fix and its regression test.
Frequently asked questions
- How does Atlas ensure a Solidity regression test truly fails before a fix?
- Atlas uses its `bash` tool to execute `forge test` and captures the exact process exit code, unambiguously confirming the test's failure state before any fix is applied to your Solidity contract.
- Can Atlas help with Solidity dependency management during bug fixes?
- Yes, Atlas understands Foundry projects and can interact with `soldeer` to manage dependencies. While fixing a bug, it can read libraries installed by `forge soldeer install` to ensure correct context.
- What safety measures does Atlas have for modifying Solidity contracts?
- Atlas employs permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every file edit, requiring explicit approval before writing any changes to your Solidity codebase.
- How does Atlas handle gas cost changes in Solidity bug fixes?
- After applying a fix, Atlas can run `forge snapshot` to compute and display the gas delta, allowing you to review the economic impact of your Solidity changes before final approval.
- Does Atlas format Solidity code after a bug fix?
- Yes, Atlas can run `forge fmt` on the generated diffs or the entire project to ensure your Solidity code adheres to established formatting standards after a bug fix is applied.
- How does Atlas integrate with existing Solidity Foundry projects?
- Atlas is designed to work direct within Foundry projects, reading `foundry.toml`, `src/` directories, and understanding Solidity contracts, storage layouts, modifiers, and installed libraries.
- Can Atlas commit changes after a Solidity bug fix?
- Yes, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf after you approve the changes for your Solidity project, ensuring proper version control.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Add a Regression Test for a Bug Fix with Atlas in 2026
How to add a regression test with Atlas in 2026: red first, then green. bash records the exit code, write creates the failing test, and edit applies the fix.
Audit a Solidity Repo with Parallel Subagents in Atlas, 2026
Sweep your Solidity repository for common problems using Atlas's parallel subagents. Identify issues in Foundry projects without blowing your context window, ensuring secure smart contracts.
Diagnose a Hanging or Long-Running Command in Solidity with Atlas in 2026
Solidity developers in 2026 can use Atlas to diagnose whether a `forge test` or `forge soldeer install` command is genuinely slow or silently blocked on input, and get it unstuck.
Locate Where a Behavior is Implemented in Solidity with Atlas in 2026
Discover how Atlas helps Solidity developers in 2026 pinpoint exact file and symbol implementations for contract behaviors using Foundry's toolchain, semantic search, and LSP.
Automate GitHub Issue and Pull Request Triage in Solidity with Atlas in 2026
Automate GitHub issue and pull request triage for Solidity projects using Atlas. Safely respond to PRs and issues in 2026, ensuring trusted users and proper context handling with Foundry.
Review a Pull Request in Solidity with Atlas in 2026
Atlas helps Solidity developers in 2026 review pull requests by providing deep context, running `forge test`, and checking for vulnerabilities. Catch subtle bugs in your smart contracts and ensure robust code quality.
Document a module with a README in Solidity with Atlas in 2026
In 2026, Atlas helps Solidity developers generate accurate READMEs for smart contracts. It uses `forge test`, `soldeer`, and `forge fmt` to reflect current code behavior.
Write Unit Tests for Untested Solidity Code with Atlas in 2026
Add robust unit tests to your Solidity contracts using Atlas. Leverage `forge test`, `soldeer`, and `forge fmt` to ensure code quality and security in 2026.