How does Atlas help me review Solidity gas costs before committing?

Atlas can run `forge snapshot` on your behalf, allowing you to see the gas delta of your Solidity changes before approving them. This provides crucial insight into the efficiency impact of your modifications.

Can Atlas help me add security features like reentrancy guards to my Solidity contracts?

Yes, you can ask Atlas to add a reentrancy guard to your Solidity contracts. Atlas understands contract structure and can implement such features, subject to your permission.

How does Atlas handle Solidity package dependencies installed by `soldeer`?

Atlas can read the libraries installed by `forge soldeer`, allowing it to understand your project's full dependency tree and provide context-aware assistance for your Solidity code.

What if Atlas makes an unwanted change to my Solidity code during a session?

Atlas snapshots file changes as git patches, so any edits it makes are recoverable. You can diff these changes and roll them back using Atlas's session revert flow if an unwanted modification occurs.

Does Atlas keep my Solidity code private when indexing it?

Yes, Atlas can build its code index with local Ollama embeddings, ensuring that your Solidity code remains on your local machine and off third-party servers, maintaining privacy and security.

How does Atlas ensure I approve its actions on my Solidity codebase?

Every Atlas tool call is permission-gated against allow, ask, and deny rules. Atlas also drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent to modify your Solidity files.

Can Atlas help me convert `require` strings to custom errors in Solidity?

Yes, you can ask Atlas to convert a `require` string to a custom error in your Solidity contracts. This can help cut deploy size and improve error handling, with Atlas performing the necessary code modifications.

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

In 2026, Solidity developers use Atlas to self-review uncommitted diffs, catching mistakes before they reach a reviewer or CI by integrating directly with `forge test`, `forge fmt`, and `soldeer` within Foundry projects. Atlas provides a terminal-native AI agent that understands your Solidity codebase, allowing you to inspect changes, run tests, and format code before committing.

How Atlas helps produce and read your Solidity working diff

Atlas helps Solidity developers in 2026 produce and read their working diffs by leveraging its deep integration with Git and its ability to index code. This ensures you review every change, not just the ones you remember touching, providing a comprehensive overview of your uncommitted Solidity modifications.

Atlas connects directly to your Git repository, reading branches, status, and diffs. When you're working on a Solidity project, Atlas can use its `bash` tool to execute `git diff`, presenting the raw working diff for your review. Beyond just showing the diff, Atlas computes a unified diff for every file edit it makes, surfacing it for your approval before writing. This capability means you can always see precisely what has changed in your `src/` directory or `test/` files. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, which allows it to understand the structure of your Solidity contracts, storage layout, and modifiers. This structural awareness helps when you ask Atlas to `read` each changed Solidity file in full, ensuring you check the change against its surroundings rather than just isolated lines, which is crucial for identifying subtle issues in complex smart contracts.

Checking Solidity changes against their surroundings with Atlas

Checking Solidity changes against their surroundings is critical for identifying unintended side effects or architectural deviations, a task Atlas simplifies in 2026. Atlas indexes your Solidity code by AST declarations, allowing it to understand the context of each modification within your `src/` contracts and `test/` files.

A raw diff can hide the broader context of a change, making it easy to miss how a small edit impacts a larger Solidity contract. Atlas addresses this by allowing you to read each changed file in full. Its AST-based indexing, powered by tree-sitter, means Atlas understands the declarations, modifiers, and storage layouts within your Solidity codebase. This deep understanding enables Atlas to provide more intelligent context when you review changes. For instance, if you modify a function in `src/MyContract.sol`, Atlas can help you review the entire function or even the entire contract, ensuring that your change aligns with the contract's overall logic and security considerations. This is particularly important in Solidity, where every diff has a gas cost and an attack surface, making a thorough contextual review indispensable before any code reaches a reviewer or CI.

Grep for debugging leftovers in Solidity with Atlas

Identifying and removing debugging leftovers like temporary logging or skipped tests is a vital step in Solidity self-review, and Atlas streamlines this process in 2026. Atlas's `grep` tool allows you to quickly scan your `src/` and `test/` directories for common debugging artifacts before committing.

Debugging artifacts, such as `console.log` statements, commented-out code blocks, or `skip` markers in `forge test` files, can inadvertently make their way into committed Solidity code. These leftovers can increase gas costs, expose sensitive information, or lead to incomplete test coverage. Atlas provides a `grep` tool that you can use to search your working tree for these common culprits. For example, you can instruct Atlas to `grep 'console.log'` across your `src/` directory to find any forgotten logging statements, or `grep 'skip'` in your `test/` directory to ensure all tests are active. This proactive scanning helps maintain clean, production-ready Solidity code and prevents unnecessary issues from being introduced into your codebase, saving valuable review time later.

Undoing unwanted Solidity changes with Atlas's session revert

If you discover an unwanted change in your Solidity diff, Atlas offers a robust session revert mechanism to restore your codebase from a snapshot, ensuring a clean slate. This feature, available in 2026, prevents half-written turns from being rolled back mid-flight, maintaining the integrity of your development session.

During the self-review process, you might identify changes that should not have been made or that introduce new issues. Atlas's session revert flow is specifically designed for these scenarios. It is backed by snapshots, meaning every edit Atlas made is recoverable. If an unwanted change is detected in your Solidity files, you can use Atlas's session revert to restore your project to a previous state. A key safety feature is that revert refuses to run on a busy session, which prevents a half-written turn from being rolled back mid-flight and ensures data consistency. This capability provides a secure safety net, allowing you to experiment with Solidity code modifications knowing that you can always roll back to a stable snapshot if needed, without manual hand-reversion.

Running Solidity tests and formatting with Atlas

Running `forge test` and `forge fmt` is a non-negotiable step in Solidity self-review, and Atlas integrates these commands directly into its workflow in 2026. This ensures your code is both functionally correct and adheres to project formatting standards before it ever leaves your local environment.

After reviewing your diff and making any necessary adjustments, the next critical step is to validate your Solidity code. Atlas allows you to run your entire Solidity toolchain using its `bash` tool. You can instruct Atlas to `bash forge test` to execute all tests defined in your `test/` directory, ensuring that your changes haven't introduced regressions or broken existing functionality. Furthermore, Atlas can run `forge snapshot` so you can see the gas delta before approving, providing crucial insights into the efficiency of your Solidity contracts. Following testing, you can have Atlas `bash forge fmt` to automatically format your Solidity code according to the standards defined in your Foundry project's `foundry.toml`. This ensures consistent code style across your team and reduces friction during code reviews. Every Atlas tool call, including these `bash` commands, is permission-gated against allow, ask, and deny rules, giving you full control over what Atlas executes.

Step by step

01Use Atlas to `bash git diff` to produce the working diff, reviewing all uncommitted Solidity changes across your Foundry project.
02Ask Atlas to `read` each changed Solidity file in your `src/` directory to check the modifications against their surrounding contract logic and storage layout.
03Instruct Atlas to `grep` for debugging leftovers like `console.log` in `src/` or `skip` in `test/` files within your Solidity codebase.
04If an unwanted Solidity change is identified, use Atlas's session revert to restore from a snapshot, ensuring the session is not busy first.
05Have Atlas `bash forge test` to run all Solidity tests in your `test/` directory, verifying functionality and gas costs.
06Ask Atlas to `bash forge fmt` to automatically format your Solidity code according to your project's `foundry.toml` standards.
07Review the unified diff Atlas surfaces for every file edit and approve it before writing the changes to your Solidity files.

Frequently asked questions

How does Atlas help me review Solidity gas costs before committing?: Atlas can run `forge snapshot` on your behalf, allowing you to see the gas delta of your Solidity changes before approving them. This provides crucial insight into the efficiency impact of your modifications.
Can Atlas help me add security features like reentrancy guards to my Solidity contracts?: Yes, you can ask Atlas to add a reentrancy guard to your Solidity contracts. Atlas understands contract structure and can implement such features, subject to your permission.
How does Atlas handle Solidity package dependencies installed by `soldeer`?: Atlas can read the libraries installed by `forge soldeer`, allowing it to understand your project's full dependency tree and provide context-aware assistance for your Solidity code.
What if Atlas makes an unwanted change to my Solidity code during a session?: Atlas snapshots file changes as git patches, so any edits it makes are recoverable. You can diff these changes and roll them back using Atlas's session revert flow if an unwanted modification occurs.
Does Atlas keep my Solidity code private when indexing it?: Yes, Atlas can build its code index with local Ollama embeddings, ensuring that your Solidity code remains on your local machine and off third-party servers, maintaining privacy and security.
How does Atlas ensure I approve its actions on my Solidity codebase?: Every Atlas tool call is permission-gated against allow, ask, and deny rules. Atlas also drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent to modify your Solidity files.
Can Atlas help me convert `require` strings to custom errors in Solidity?: Yes, you can ask Atlas to convert a `require` string to a custom error in your Solidity contracts. This can help cut deploy size and improve error handling, with Atlas performing the necessary code modifications.

Try Atlas in your terminal

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

Install Atlas

Related guides

Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow)

How to self-review your working diff before committing with Atlas in 2026: bash produces the diff, read checks each file, grep finds leftovers, session revert undoes bad edits.

Trace a Runtime Bug from a Solidity Stack Trace with Atlas in 2026

Pinpoint and fix Solidity runtime bugs from production stack traces using Atlas. Leverage Foundry's `forge test` and `soldeer` for a secure, gas-efficient workflow.

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

Migrate deprecated Solidity APIs across your entire codebase with Atlas. Leverage forge test, soldeer, and forge fmt for a complete, verified, and safe transition in your Foundry project.

Onboard to an Unfamiliar Solidity Codebase with Atlas in 2026

Solidity developers in 2026 can rapidly build a mental model of any unfamiliar codebase using Atlas. Leverage semantic search, AST indexing, and Foundry toolchain integration with forge test, soldeer, and forge fmt.

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.

Debug a single failing test in Solidity with Atlas in 2026

In 2026, Atlas helps Solidity developers debug single failing forge test cases within Foundry projects. Pinpoint issues, trace call graphs, and fix smart contract code with AI-driven precision and safety.

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.

Research a Third-Party API for Solidity Integration with Atlas in 2026

Streamline Solidity API integrations in 2026 with Atlas. Research external APIs, fetch documentation, and verify against Foundry's `forge test` and `forge fmt` standards.

Browse this resource hub