Atlas helps MATLAB developers in 2026 review pull requests by fetching diffs, reading full `.m` files for context, checking function references with its `lsp` tool, and running `matlab.unittest (runtests)` behind permission prompts to catch bugs a line-by-line read might miss.
How Atlas reviews MATLAB pull requests for context
Atlas in 2026 enhances MATLAB pull request reviews by moving beyond simple diffs. It fetches the raw patch using `bash`, then uses its `read` tool to pull full `.m` files, ensuring developers see context outside the immediate changes in `classdef` blocks or standalone functions.
When a MATLAB developer initiates a pull request review, Atlas first uses its `bash` tool to interact with the underlying version control system, fetching the specific branch and generating the raw patch. This initial step provides the basic line-by-line changes. However, to fulfill the job of catching bugs a line-by-line read would miss, Atlas then employs its `read` tool. This tool pulls the complete content of all changed `.m` files, including function definitions, `classdef` blocks, and even `buildfile.m` scripts. By reading the full files, Atlas ensures that the developer, and its own agents, have access to the surrounding code context, which is crucial for understanding the true impact of a change, especially in MATLAB where function dependencies and class properties can be spread across a file.
Checking MATLAB function signatures and callers with Atlas
Atlas employs its `lsp` tool to meticulously check MATLAB function signatures in 2026. For every changed function or method signature within `.m` files or `classdef` blocks, Atlas automatically runs `findReferences` to identify any callers that the pull request diff might not explicitly show, preventing silent breakage.
A critical aspect of reviewing MATLAB code is ensuring that changes to function or method signatures do not inadvertently break existing callers. The standard diff often fails to highlight these external dependencies. Atlas addresses this by leveraging its `lsp` tool. After identifying any modifications to function signatures in `.m` files or method signatures within `classdef` blocks, Atlas automatically invokes the `findReferences` operation. This operation scans the entire codebase, identifying all locations where the modified function or method is called. By doing so, Atlas can surface potential breaking changes in parts of the code that were not directly touched by the pull request, providing a comprehensive safety net for MATLAB developers.
Finding unupdated patterns in MATLAB codebases with Atlas
In 2026, Atlas uses its `grep` tool to proactively identify unupdated patterns across MATLAB codebases. After reviewing a pull request, Atlas searches for old constant names, stale copies of code, or feature flags that should have been modified but were overlooked in the `.m` files, ensuring consistency.
Beyond explicit code changes, pull requests often require updates to related patterns throughout the codebase. This could include renaming a constant used in multiple `.m` files, updating a deprecated function call, or removing a feature flag that is no longer needed. Atlas's `grep` tool is instrumental here. After processing the diff and checking references, Atlas can be instructed to `grep` for specific patterns that the change *should* have updated but did not. For example, if a constant `OLD_MAX_VALUE` was changed to `NEW_MAX_VALUE`, Atlas can `grep` for `OLD_MAX_VALUE` to ensure all instances in `.m` files have been updated. This helps catch subtle inconsistencies and ensures a thorough review of the MATLAB codebase.
Running MATLAB unit tests and reporting with Atlas
Atlas integrates directly with `matlab.unittest (runtests)` in 2026 to validate pull request changes. It executes the test suite using `bash` behind a permission prompt, then compiles any failing assertions from `matlab.unittest.TestCase` subclasses into a `todowrite` list, ordered by severity, for immediate action.
Automated testing is paramount for code quality. Atlas direct integrates with MATLAB's native testing framework, `matlab.unittest`. When reviewing a pull request, Atlas uses its `bash` tool to execute the test suite. This typically involves running a command like `matlab -batch "runtests('tests')"` or `matlab -batch "buildtool test"` if a `buildfile.m` is present. Crucially, this execution is permission-gated, meaning Atlas will ask for explicit approval before running the tests. Once the tests complete, Atlas processes the results, identifying any failing assertions from `matlab.unittest.TestCase` subclasses. These failures are then compiled into a `todowrite` list, which is presented to the developer, ordered by severity, providing a clear and actionable summary of issues.
Ensuring MATLAB code style with Atlas Format Code
Before final approval, Atlas can apply the `MATLAB Format Code` conventions to touched files in 2026. This ensures consistency across `.m` files, `classdef` blocks, and `buildfile.m`, aligning the pull request with the project's established style guidelines and reducing manual formatting effort.
Maintaining consistent code style across a MATLAB project is vital for readability and collaboration. Atlas can assist with this by integrating with the `MATLAB Format Code` utility. After the functional review and testing, Atlas can use its `bash` tool to invoke the formatter on the `.m` files that were modified in the pull request. An example command might be `matlab -batch "matlab.desktop.editor.formatDocument('myFunction.m')"`. This ensures that all touched files adhere to the project's formatting standards, as defined by `MATLAB Format Code`. Like all actions that modify files, this operation is permission-gated, and Atlas will present a unified diff of the formatting changes for approval before writing them to disk, giving the developer full control.
Atlas's safety and approval workflow for MATLAB changes
Atlas employs a robust safety workflow for MATLAB changes in 2026, starting with a read-only plan agent. Every tool call, including `matlab.unittest (runtests)` or `MATLAB Format Code`, is permission-gated, and all file edits are presented as a unified diff for explicit user approval before writing, ensuring developer control.
Developer trust and control are central to Atlas's design. When reviewing a MATLAB pull request, Atlas first drafts a plan in a read-only plan agent, outlining its intended actions without making any changes. Every subsequent tool call, whether it's `bash` to run `matlab.unittest (runtests)`, `lsp` to check references, or `bash` to apply `MATLAB Format Code`, is permission-gated. This means Atlas will explicitly ask for approval based on 'allow', 'ask', or 'deny' rules before executing. Furthermore, before any file modifications are written to disk, Atlas computes a unified diff for every proposed edit and surfaces it for explicit user approval. This allows MATLAB developers to review exactly what changes Atlas intends to make. Atlas also snapshots file changes as git patches, providing a clear audit trail and the ability to roll back edits if needed, ensuring a secure and transparent workflow.
Step by step
- 01Atlas fetches the pull request branch and generates a raw diff for `.m` files using its `bash` tool.
- 02Atlas uses its `read` tool to pull the full content of all changed `.m` files, `classdef` definitions, and `buildfile.m` for complete context.
- 03For every modified function or method signature in `.m` files, Atlas invokes the `lsp` tool's `findReferences` operation to check for breaking changes in callers.
- 04Atlas runs `grep` to search for old constant names, stale code copies, or feature flags that should have been updated but were missed in the `.m` files.
- 05Atlas executes the `matlab.unittest (runtests)` suite via `bash` (e.g., `matlab -batch "runtests('tests')"` or `matlab -batch "buildtool test"`) after a permission prompt.
- 06Atlas compiles any failing assertions from `matlab.unittest` into a `todowrite` list, ordered by severity, for the developer.
- 07Atlas applies `MATLAB Format Code` conventions to the touched `.m` files using `bash` (e.g., `matlab -batch "matlab.desktop.editor.formatDocument('filename.m')"`) for style consistency.
- 08Atlas presents a unified diff of all proposed changes for explicit user approval before writing to disk, with rollback options via git patches.
Frequently asked questions
- How does Atlas ensure I see full MATLAB file context during a PR review?
- Atlas uses its `read` tool to pull the complete content of changed `.m` files, `classdef` blocks, and `buildfile.m`, providing context beyond the immediate diff hunks to help catch subtle bugs.
- Can Atlas check for breaking changes in MATLAB function calls not shown in the diff?
- Yes, for every changed function or method signature in `.m` files, Atlas's `lsp` tool runs `findReferences` to identify any callers that might be affected, even if they are outside the pull request's diff.
- How does Atlas run `matlab.unittest` for a pull request?
- Atlas executes `matlab.unittest (runtests)` via its `bash` tool, typically using a command like `matlab -batch "runtests('tests')"` or `matlab -batch "buildtool test"`, always behind a permission prompt for user control.
- Does Atlas apply `MATLAB Format Code` automatically?
- Atlas can apply `MATLAB Format Code` conventions to touched `.m` files using its `bash` tool, but it always seeks explicit user approval through a permission prompt and presents a unified diff before writing changes.
- What safety features does Atlas offer when reviewing MATLAB code?
- Atlas operates with a read-only plan agent, permission-gates every tool call (e.g., `matlab.unittest`, `MATLAB Format Code`), and presents a unified diff for all proposed file edits for explicit user approval before writing.
- How does Atlas help find unupdated code patterns in MATLAB?
- Atlas uses its `grep` tool to search for specific patterns like old constant names, stale code copies, or feature flags within `.m` files that should have been updated by the pull request but were overlooked.
- Can Atlas integrate with my existing MATLAB build process?
- Yes, Atlas can execute commands from your `buildfile.m` or other custom scripts via its `bash` tool, allowing it to integrate with your existing MATLAB build and test workflows behind permission prompts.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Review a Pull Request with Atlas (2026 Workflow)
How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.
Run Atlas Headless in CI for MATLAB Projects in 2026
Automate Atlas in your MATLAB CI/CD pipelines. Get machine-readable output, pre-approve tools, and integrate with matlab.unittest and MATLAB Format Code for efficient, non-interactive code generation and review.
Migrate a deprecated API across every callsite in MATLAB with Atlas in 2026
Streamline deprecated API migrations in MATLAB codebases with Atlas in 2026. Automate finding all callers, applying patches, and verifying with `matlab.unittest (runtests)` for a complete, safe transition.
Rename a symbol across the repo in MATLAB with Atlas in 2026
In 2026, Atlas empowers MATLAB developers to rename functions, classes, and constants across their repositories with unparalleled precision. Leverage semantic analysis and robust verification for comprehensive, safe
Self-review your working diff before committing in MATLAB with Atlas in 2026
Catch your own mistakes in uncommitted MATLAB code diffs before they reach review or CI. Atlas helps MATLAB developers in 2026 self-review changes, run `matlab.unittest (runtests)`, and apply `MATLAB Format Code` for
Audit a repo with parallel subagents in MATLAB with Atlas in 2026
Sweep your MATLAB repository for issues without context window limits. Atlas uses parallel subagents to audit .m files, classdef blocks, and matlab.unittest test classes efficiently.
Refactor a Legacy MATLAB Module with Atlas in 2026
Modernize your MATLAB codebase in 2026. Atlas helps refactor legacy modules without breaking callers, using matlab.unittest (runtests) and precise code edits.
Write unit tests for untested code in MATLAB with Atlas in 2026
Add real unit tests to your MATLAB code in 2026 using Atlas. Learn how Atlas leverages matlab.unittest (runtests) and existing repo conventions for robust testing.