To extract a shared helper from duplicated Rust code, Atlas treats duplication as a semantic problem, not a textual one, because the copies usually differ in variable names and lifetimes. Atlas asks codebase_search for the behavior rather than the exact code, so near-duplicate functions across your crate's modules surface even when grep would miss them. The write tool creates the new shared module, apply_patch swaps each copy for a call in one reviewable patch per file, and cargo test proves nothing broke.
How do I find duplicated logic in a Rust crate that grep cannot see?
Atlas finds duplicated Rust logic with codebase_search, which queries the semantic index for the behavior rather than the literal text. 2 copies of the same retry loop, one in src/client.rs and one in src/worker.rs, will differ in binding names and lifetimes, so grep misses them while a meaning-based query does not.
Duplication in Rust rarely survives copy-paste unchanged. One copy borrows, another clones. One returns Result<T, Error>, another returns Option<T>. Variable names drift. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so a plain-language description of the behavior ranks both copies even when they share almost no identical tokens. Atlas also indexes code by AST declarations using tree-sitter, not blind line windows, which means the hits come back as whole fn declarations and impl blocks rather than arbitrary line slices you then have to reconstruct.
How do I confirm two Rust functions are really duplicates before merging them?
Atlas reads each codebase_search hit with the read tool and confirms 2 Rust functions are genuinely equivalent before collapsing them. 3 differences disqualify a merge: a different error type, different borrow semantics, or a single early return. Functions that merely look alike are not duplicates, and merging them changes behavior.
Confirmation is the step people skip, and in Rust the compiler will happily accept a merge that quietly changes semantics. Read both fn bodies in full. Check whether one takes &str and the other String, whether one propagates with the question mark operator and the other unwraps, whether lifetimes differ. Only when the copies are actually equivalent does the extraction make sense. Because Atlas keeps the full declarations in context rather than fragments, the comparison is done against real Rust code, not a summary of it.
How do I swap each duplicate for a call without breaking the Rust build?
Atlas replaces each duplicated Rust block with a call using apply_patch, 1 file per patch, so every swap is independently reviewable and revertible. A patch against src/client.rs and a patch against src/worker.rs land separately, and cargo test runs after each one rather than once at the end.
One patch per file is what keeps a Rust extraction recoverable. If the third swap turns out to need a different trait bound, the first two are already green and committed rather than tangled into one giant diff. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, and Atlas snapshots file changes as git patches so a bad swap can be diffed and rolled back. Running cargo test after each swap catches a borrow-checker or trait-resolution failure at the file that caused it.
How do I prove no duplicate Rust code survived the refactor?
Atlas finishes a Rust extraction by running cargo test after every swap, then grepping once more for the old logic until the search returns 0 hits. A 4th copy hiding in a benches or examples directory is exactly the kind of leftover that a final grep pass catches.
The last pass is cheap and worth it. Atlas runs cargo test with the bash tool, which records the process exit code in its metadata, so the green state is unambiguous rather than inferred from console text. Then grep sweeps the crate for the distinctive tokens the old copies shared, catching stragglers in test modules, benchmarks, or a second crate in the cargo workspace. Running rustfmt over the touched files and re-running cargo test leaves a clean, reviewable diff: one new helper, several call sites, no dead duplicates.
Step by step
- 01Run atlas in a crate with a Cargo.toml and let Atlas read your modules, traits, and cargo workspace.
- 02Ask codebase_search for the behavior, not the exact code, to surface near-duplicate Rust implementations that grep would miss because the copies differ in binding names and lifetimes.
- 03Read each hit with the read tool and confirm the fn bodies are genuinely equivalent, checking error types, borrows, and early returns before collapsing them.
- 04Create the shared helper with write, for example a new src/util.rs with a pub(crate) signature; write shows the full diff in the permission prompt before the file is created.
- 05Replace each duplicate with a call using apply_patch, one file per patch, so each swap is independently reviewable and revertible.
- 06Run cargo test with bash after every swap, not once at the end, so a borrow-checker or trait failure is attributed to the file that caused it.
- 07Grep for the old logic one final time to prove no copy survived in tests, benches, or another crate of the cargo workspace.
- 08Run rustfmt over the touched files and let Atlas stage the commit.
Frequently asked questions
- how to find duplicated code in a rust crate with an AI agent
- Ask Atlas to run codebase_search for the behavior rather than the literal text. Rust copies usually differ in binding names, borrows, and lifetimes, so a semantic query finds what grep misses.
- how do i extract a shared helper function in rust safely
- Have Atlas create the module with write, which shows the full diff in the permission prompt, then swap each duplicate with apply_patch, one file per patch, running cargo test after every swap.
- why use apply_patch instead of edit for a rust refactor
- apply_patch applies a structural change as one reviewable patch per file, so each Rust call-site swap can be reviewed and reverted on its own instead of being tangled into one large diff.
- does atlas understand rust traits and modules
- Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so hits come back as whole fn declarations and impl blocks. Run atlas in a crate with a Cargo.toml and it reads your modules, traits, and cargo workspace.
- can atlas fix borrow checker errors after a refactor
- Ask Atlas to fix borrow-checker errors or clippy warnings and review the diff before cargo build. Atlas runs cargo test through bash, which records the process exit code in its metadata, so failures are unambiguous.
- how do i make sure no duplicate rust code is left after extracting a helper
- Finish with a grep pass for the distinctive tokens the old copies shared. Leftovers commonly hide in test modules, benches, or a second crate in the same cargo workspace.
- does atlas format rust code with rustfmt
- Atlas can run rustfmt over the files it touched through the bash tool, so the extraction commit shows the new helper and the call sites rather than formatting churn.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Extract a Shared Helper from Duplicated Code with Atlas (2026 Workflow)
How to extract a shared helper from duplicated code with Atlas in 2026: codebase_search finds the copies by meaning, write creates the module, apply_patch swaps each call.
Atlas for Rust in 2026
Adopt Atlas, the terminal-native AI coding agent, for Rust development in 2026. Tackle borrow checker errors and clippy lints with Atlas's secure, approval-gated assistance.
Diagnose a Hanging or Long-Running Command in Rust with Atlas (2026)
Is your cargo build slow or silently blocked on stdin? Atlas races every command against a timeout in 2026 and tells you which one it is, plus how to get unstuck.
Research a Third-Party API Before Integrating It in Rust with Atlas (2026)
How Atlas researches a third-party API before you write the Rust integration in 2026: websearch, webfetch behind a permission prompt, then cargo test on a real diff.
Upgrade a dependency and fix the breakage in Rust with Atlas (2026)
Bump a crate to a new major version in 2026 and let Atlas repair the fallout: cargo output read by the agent, release notes fetched, callsites fixed, cargo test green.
Refactor a legacy module in Rust with Atlas (2026)
Refactor a legacy Rust module in 2026 with Atlas: enumerate callers with the lsp tool's findReferences, restructure with apply_patch, and prove behavior with cargo test.
Trace a Runtime Bug From a Stack Trace in Rust with Atlas (2026)
Go from a Rust panic backtrace to the responsible line without a debugger. Atlas reads each frame at its offset in 2026, then proves the fix with cargo test.
Document a module with a README in Rust with Atlas (2026)
Write a Rust module README that matches the code as it stands in 2026. Atlas enumerates the pub surface with lsp, reads the impls, and verifies every sample with cargo test.