How does Atlas ensure code quality for Laravel pull requests?

Atlas ensures code quality by integrating with `Laravel Pint` for formatting, running `Pest` tests for functional validation, and performing deep contextual analysis using `lsp` and `grep` to catch issues beyond simple diffs in your Laravel project.

Can Atlas detect breaking changes in Laravel Eloquent models?

Yes, Atlas detects breaking changes in Laravel Eloquent models by using its `lsp` tool's `findReferences` operation. This identifies all callers of a modified model method or property, even if they are outside the immediate diff, preventing silent breakages.

How does Atlas handle Laravel configuration file changes?

Atlas reviews Laravel configuration file changes by reading the full file content with its `read` tool and using `grep` to ensure consistency. For example, it can verify that old constant names or feature flags in `config/app.php` or `config/services.php` are properly updated or removed.

What Laravel testing tools does Atlas support?

Atlas fully supports `Pest`, Laravel's preferred test runner. It uses its `bash` tool to execute `php artisan pest` commands, processing the output to report test failures and warnings as part of the pull request review.

Is Atlas safe to use for modifying Laravel code?

Yes, Atlas is designed with safety in mind. It drafts a plan in a read-only agent, asks for approval before switching to a build agent, and surfaces a unified diff for every file edit in your Laravel project for your explicit approval before writing any changes.

Can Atlas help with `Composer` dependencies in Laravel PRs?

While the primary focus is code review, Atlas can interact with `Composer` via its `bash` tool. It can run `composer install` or `composer update` as part of the testing workflow, ensuring dependency changes in `composer.json` are validated.

How does Atlas provide context for Laravel routes and controllers?

Atlas provides context for Laravel routes and controllers by reading full files like `routes/web.php` or `app/Http/Controllers/UserController.php` with its `read` tool. This allows it to understand the broader logic and potential impacts of changes beyond just the modified lines.

Review a Pull Request in Laravel with Atlas in 2026

Atlas empowers Laravel developers in 2026 to review pull requests comprehensively by integrating directly with `Composer`, `Pest`, and `Laravel Pint`, ensuring deep context beyond simple line-by-line diffs to catch subtle bugs.

How Atlas Fetches and Diffs Laravel Pull Requests

Atlas fetches Laravel pull request changes using its `bash` tool, leveraging git's capabilities to retrieve the branch and produce a raw patch. This process ensures that in 2026, developers get an accurate, up-to-date view of all modifications, including those to `app/Http/Controllers` or `database/migrations`.

When reviewing a pull request in a Laravel project, Atlas first uses its `bash` tool to interact with the underlying Git repository. This allows Atlas to fetch the specific feature branch and then generate a comprehensive diff. Atlas's VCS layer exposes `status`, `diff`, `diffRaw`, and `commits` operations, providing a robust interface to the same Git data a human developer would use. This initial step is crucial for understanding the scope of changes, whether they involve new Eloquent models in `app/Models`, updated routes in `routes/web.php`, or modifications to `config/app.php`. By producing the raw patch, Atlas establishes the foundation for a detailed, context-aware review, ensuring no change, however small, is overlooked in the Laravel codebase.

Reading Full Laravel Files for Context Beyond the Diff

Atlas reads full Laravel files, not just diff hunks, using its `read` tool to provide essential surrounding context. This capability is vital for understanding how changes to a single method in `app/Http/Controllers/UserController.php` might impact the broader application logic in 2026.

A line-by-line diff often hides critical context, especially in a framework like Laravel where components are interconnected. Atlas addresses this by using its `read` tool to pull the full content of any changed file, rather than just the modified hunks. For instance, if a pull request modifies a few lines within an Eloquent model in `app/Models/Order.php`, Atlas will read the entire `Order.php` file. This allows the agent to understand the model's relationships, scopes, and mutators that might be relevant to the change but are not directly part of the diff. This holistic view is indispensable for catching bugs that arise from changes interacting unexpectedly with existing, untouched code, such as a new validation rule in a form request (`app/Http/Requests`) conflicting with an existing database constraint.

Catching Breaking Changes in Laravel with LSP `findReferences`

For every changed function signature in a Laravel application, Atlas runs the `lsp` tool's `findReferences` operation to check for callers the diff never touched. This ensures that modifications to a service method in `app/Services/PaymentService.php` do not inadvertently break other parts of the application in 2026.

One of the most common sources of bugs in pull requests is a change to a method signature that breaks its callers elsewhere in the codebase. Atlas mitigates this risk by leveraging its `lsp` (Language Server Protocol) tool. After identifying changed function or method signatures,for example, in a controller method within `app/Http/Controllers` or a utility function in `app/Helpers`,Atlas executes the `findReferences` operation. This powerful check identifies all locations where the modified signature is called, even if those calling sites are in files not included in the pull request's diff. This proactive approach is particularly valuable in Laravel projects, where methods on Eloquent models, repositories, or service classes can be invoked from numerous controllers, jobs, or console commands, preventing silent breakages that a human reviewer might easily miss.

Grep for Stale Laravel Code and Feature Flags

Atlas uses its `grep` tool to search for patterns that the change should have updated but did not, such as old constant names or stale copies in Laravel configuration files. This helps identify overlooked cleanups or incomplete feature flag removals across the `config` directory or `resources/views` in 2026.

Beyond direct code changes, pull requests often require updates to related constants, configuration values, or even the removal of old feature flags. Atlas employs its `grep` tool to systematically search for these patterns. For instance, if a feature flag named `FEATURE_OLD_PAYMENT_GATEWAY` is being deprecated, Atlas can `grep` the entire Laravel project to ensure all references in `config/services.php`, `resources/views`, or even `app/Providers` are updated or removed. Similarly, if a constant defined in `config/constants.php` or a specific string literal used in a Blade template (`resources/views`) is modified, Atlas can verify that all its occurrences are consistently updated. This ensures the codebase remains clean, consistent, and free from lingering, outdated references that could lead to future bugs or confusion.

Running Laravel Tests with Pest and Atlas

Atlas runs the project's tests using its `bash` tool, specifically invoking `Pest`, Laravel's preferred test runner, to validate the changes. This step provides immediate feedback on the functional correctness of the pull request, reporting findings as a `todowrite` list ordered by severity in 2026.

No review is complete without verifying the code's behavior through automated tests. Atlas integrates directly with Laravel's testing ecosystem by using its `bash` tool to execute `Pest`, the framework's popular test runner. Atlas can run the entire test suite with `php artisan pest` or target specific test files or groups. The output from `Pest` is then processed by Atlas, and any failures or warnings are reported back to the developer. Atlas organizes these findings into a `todowrite` list, prioritizing issues by severity. This ensures that even if a change passes initial static analysis, any regressions or new bugs introduced are immediately flagged, providing a critical safety net for maintaining the integrity of the Laravel application.

Atlas's Safety and Approval Workflow for Laravel Edits

Atlas employs a multi-stage safety and approval workflow, starting with a read-only plan agent, before any changes are applied to a Laravel project. This ensures that all proposed modifications, from new controllers to migration files, are explicitly approved by the developer in 2026.

Atlas prioritizes developer control and safety throughout the review and modification process. Before making any changes to your Laravel codebase, Atlas drafts a plan in a read-only plan agent, detailing its intended actions. This plan is presented for your approval. Only after explicit consent does Atlas switch to a build agent to execute the plan. Every file edit, whether it's modifying an Eloquent model, adding a new route, or adjusting a `Composer` dependency, results in a unified diff that Atlas surfaces for your final approval before writing. Furthermore, Atlas snapshots file changes as Git patches, allowing edits to be easily diffed and rolled back if necessary. This meticulous approval process, combined with the ability to switch active models and providers on the fly, ensures that developers maintain full oversight and confidence when working with Atlas in their Laravel projects.

Step by step

011. Initialize Atlas in your Laravel application by running `atlas` in the project root, ensuring the `artisan` file is present.
022. Fetch the feature branch and generate the diff for your Laravel application using `atlas bash git fetch origin <branch_name> && git diff origin/main..<branch_name>`.
033. Instruct Atlas to `read` the full content of all changed Laravel files (e.g., `app/Http/Controllers/`, `app/Models/`, `routes/web.php`) to gain complete context beyond the diff hunks.
044. For any modified method signatures in your Laravel code, use `atlas lsp findReferences` to identify all callers across the project, including those in `app/Jobs` or `app/Console/Commands`.
055. Employ `atlas grep` to search for old constant names, stale feature flags, or other patterns that should have been updated in Laravel config files (e.g., `config/app.php`, `config/services.php`) or Blade templates.
066. Run the Laravel test suite with `Pest` using `atlas bash php artisan pest` to validate the changes and report findings.
077. Review Atlas's proposed changes and `todowrite` list, then approve or modify them before Atlas writes to your Laravel project.
088. Use `atlas git stage` and `atlas git commit` to stage and commit the approved changes to your Laravel repository.

Frequently asked questions

How does Atlas ensure code quality for Laravel pull requests?: Atlas ensures code quality by integrating with `Laravel Pint` for formatting, running `Pest` tests for functional validation, and performing deep contextual analysis using `lsp` and `grep` to catch issues beyond simple diffs in your Laravel project.
Can Atlas detect breaking changes in Laravel Eloquent models?: Yes, Atlas detects breaking changes in Laravel Eloquent models by using its `lsp` tool's `findReferences` operation. This identifies all callers of a modified model method or property, even if they are outside the immediate diff, preventing silent breakages.
How does Atlas handle Laravel configuration file changes?: Atlas reviews Laravel configuration file changes by reading the full file content with its `read` tool and using `grep` to ensure consistency. For example, it can verify that old constant names or feature flags in `config/app.php` or `config/services.php` are properly updated or removed.
What Laravel testing tools does Atlas support?: Atlas fully supports `Pest`, Laravel's preferred test runner. It uses its `bash` tool to execute `php artisan pest` commands, processing the output to report test failures and warnings as part of the pull request review.
Is Atlas safe to use for modifying Laravel code?: Yes, Atlas is designed with safety in mind. It drafts a plan in a read-only agent, asks for approval before switching to a build agent, and surfaces a unified diff for every file edit in your Laravel project for your explicit approval before writing any changes.
Can Atlas help with `Composer` dependencies in Laravel PRs?: While the primary focus is code review, Atlas can interact with `Composer` via its `bash` tool. It can run `composer install` or `composer update` as part of the testing workflow, ensuring dependency changes in `composer.json` are validated.
How does Atlas provide context for Laravel routes and controllers?: Atlas provides context for Laravel routes and controllers by reading full files like `routes/web.php` or `app/Http/Controllers/UserController.php` with its `read` tool. This allows it to understand the broader logic and potential impacts of changes beyond just the modified lines.

Try Atlas in your terminal

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

Install Atlas

Related 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.

Atlas for Laravel in 2026

Atlas is a terminal-native AI coding agent for Laravel in 2026. Run it in a Laravel app with an artisan file, add a controller or Pest test, and review the diff.

Onboard to an Unfamiliar Laravel Codebase with Atlas in 2026

Quickly build a working mental model of any Laravel project in 2026 using Atlas. Leverage semantic search, explore tools, and review changes to understand Eloquent models, routes, and more.

Upgrade a Dependency and Fix Breakage in Laravel with Atlas in 2026

In 2026, Atlas empowers Laravel developers to direct upgrade Composer dependencies, fixing compile and test failures with precision. Leverage Atlas to manage your Laravel projects, ensuring smooth transitions and

Locate Laravel Behavior Implementations with Atlas in 2026

In 2026, Laravel developers use Atlas to quickly locate behavior implementations, pinpointing exact files and symbols across Eloquent models, routes, and Artisan commands. Find code by describing its function.

Plan a Multi-File Change Before Editing in Laravel with Atlas in 2026

In 2026, Laravel developers use Atlas to plan complex, multi-file changes across models, routes, and tests. Design, review, and refine your entire architectural shift before modifying a single line of code.

Run Atlas Headless in CI with Laravel in 2026

Run Atlas non-interactively in your Laravel CI pipeline in 2026. Get machine-readable output, integrate with Pest and Composer, and ensure safety with pre-approved tools.

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

Pinpoint and fix Laravel runtime bugs directly from production stack traces using Atlas, the terminal-native AI coding agent. Leverage Composer, Pest, and Laravel Pint for a streamlined workflow.

Browse this resource hub