Can Atlas understand my custom Laravel `artisan` commands?

Yes, Atlas indexes code by AST declarations, allowing it to understand and search for custom `artisan` commands defined in your `app/Console/Commands` directory. You can ask `codebase_search` to find specific command implementations.

How does Atlas handle Laravel's Eloquent models and relationships?

Atlas's semantic index understands Eloquent models and their relationships. You can ask `codebase_search` questions like "show me the `User` model's relationships" or "where is the `Order` model defined?" to quickly locate relevant code.

Is it safe to let Atlas explore my Laravel project?

Yes, the `explore` subagent operates with a deny-by-default permission set, only allowing read-only tools like `grep`, `glob`, and `read`. This ensures no changes are made to your Laravel codebase without explicit approval, keeping your project safe.

Can Atlas help me find all `Pest` tests related to a specific Laravel feature?

Absolutely. You can use `atlas codebase_search "Pest tests for user authentication"` or `atlas task explore "find all Pest tests in tests/Feature that interact with the 'Order' model"` to locate relevant tests within your Laravel project.

How does Atlas integrate with Laravel's `Composer` dependencies?

While Atlas doesn't directly manage `Composer` dependencies, its semantic indexing and `read` tool can help you understand how your Laravel project uses packages defined in `composer.json` and `vendor/`, providing context on external libraries.

What if Atlas proposes a change to a Laravel file?

Atlas drafts a plan in a read-only agent, then computes a unified diff for every proposed file edit. You must review and approve this diff before any changes are written to your Laravel project, ensuring full control over modifications.

Can Atlas help me understand Laravel routes?

Yes, you can use `atlas read routes/web.php` or `routes/api.php` to inspect your route definitions. `codebase_search` can also help you find specific routes, e.g., "where is the `/dashboard` route defined?" within your Laravel application.

Onboard to an Unfamiliar Laravel Codebase with Atlas in 2026

In 2026, Atlas helps Laravel developers quickly build a working mental model of unfamiliar codebases by leveraging semantic search, exploring project structure with `glob`, and diving into specific files with `read` and `lsp`. It integrates directly with your Laravel project, understanding Eloquent models, routes, and `artisan` commands, while ensuring all changes are reviewed and approved before writing.

How does Atlas find Laravel-specific code patterns?

Atlas helps Laravel developers in 2026 quickly grasp unfamiliar code by semantically searching for concepts like authentication or Eloquent relationships, rather than just filenames. It indexes code by AST declarations, not blind line windows, ensuring precise results from your `app/Models` or `app/Http` directories, often returning results in under 1 second.

When you encounter an unfamiliar Laravel codebase, the first step is often to understand its core functionalities. Atlas's `codebase_search` tool allows you to ask plain-language questions, such as "how requests are authenticated" or "where is the `Order` model's `hasMany` relationship defined?". Atlas queries its semantic index, built using AST declarations, to return highly ranked snippets with relevant file paths. This means you get precise results from files like `app/Http/Middleware/Authenticate.php` or `app/Models/Order.php`, bypassing the need to manually grep or browse through countless files. This approach ensures that Atlas understands the meaning and structure of your Laravel code, not just keywords, providing a more intelligent starting point for your investigation.

How do I understand a Laravel project's directory layout?

To quickly grasp a Laravel project's architecture, Atlas's `glob` tool provides a top-level directory overview, revealing common structures like `app/Http/Controllers` or `database/migrations`. This initial scan, taking only a few seconds, helps you identify key areas before opening any files, giving you a crucial 20,000-foot view of the codebase's organization and naming conventions.

Before diving into specific files, understanding the overall layout of a Laravel project is crucial. The `glob` tool in Atlas allows you to quickly map the directory shape and identify standard Laravel conventions. For instance, running `atlas glob app/* config/* database/* routes/*` will show you the main directories where controllers, models, configuration, migrations, and route definitions reside. This helps you recognize familiar patterns like `app/Http/Controllers`, `app/Models`, `database/migrations`, and `routes/web.php`. By seeing the package layout and naming conventions upfront, you can form an initial mental model of the project's structure, making subsequent exploration more efficient and targeted.

How does Atlas help me read and navigate specific Laravel files?

After identifying key areas, Atlas allows you to `read` the two or three most relevant Laravel files, such as `routes/web.php` or a core Eloquent model, without opening your editor. For deeper understanding, the `lsp` tool's `goToDefinition` operation lets you instantly follow imports and method calls, like tracing a service injection from a controller to its implementation, saving you 10-15 minutes per deep dive.

Once `codebase_search` and `glob` have pointed you to interesting areas, Atlas's `read` tool lets you inspect the content of specific Laravel files directly in your terminal. For example, you might `atlas read app/Http/Controllers/UserController.php` or `atlas read app/Models/Product.php`. To understand how different parts of the Laravel application connect, the `lsp` tool is invaluable. Its `goToDefinition` operation allows you to follow imports, method calls, and class usages. If you see `use App\Services\PaymentGateway;` in a controller, you can use `lsp goToDefinition` on that line to jump directly to the `PaymentGateway` service definition, quickly building a call graph and understanding dependencies within your Laravel application.

How can Atlas explore a Laravel codebase without making changes?

For wide-ranging investigations across a Laravel codebase, the `explore` subagent can be delegated tasks, such as finding all `artisan` commands or usages of a specific trait. This subagent operates with a deny-by-default permission set, allowing only read-only actions like `grep`, `glob`, and `read`, ensuring your project remains untouched during its 2-5 minute search for patterns.

When you need to perform broader sweeps across a Laravel project without the risk of accidental modifications, the `explore` subagent is your go-to tool. You can delegate complex tasks to it using the `task` tool. For instance, you might ask `atlas task explore 'find all Eloquent models that use the SoftDeletes trait'` or `atlas task explore 'show me all controllers that interact with the 'Order' model'`. The `explore` subagent is permissioned with a deny-by-default rule set, meaning it can only execute safe, read-only operations like `grep`, `glob`, `read`, `bash` (for simple commands), `webfetch`, and `websearch`. This ensures that while it's looking around your `app/` directory or `database/migrations`, your Laravel codebase remains completely safe and unchanged.

How does Atlas ensure safe changes and track open questions in Laravel?

Atlas prioritizes safety and clarity when working with Laravel projects. Every proposed file edit, whether to an Eloquent model or a `Pest` test, generates a unified diff for your approval before writing. Additionally, the `todowrite` tool allows you to record open questions or insights, ensuring no crucial detail is lost during your 2026 onboarding process, making your workflow 100% transparent.

Building a mental model often involves identifying areas for further investigation or potential changes. Atlas provides robust mechanisms for both safety and knowledge retention. Before any modification is made to your Laravel project, such as adding a new controller or updating a `Pest` test, Atlas drafts a plan in a read-only agent. It then computes a unified diff for every proposed file edit, which is surfaced for your explicit approval. This ensures you have full control over what gets written to your `app/` directory or `database/` files. Furthermore, the `todowrite` tool allows you to record open questions, observations, or tasks directly within Atlas, ensuring that insights gained during your exploration, like 'TODO: Investigate why `OrderController` uses `Request` directly instead of a Form Request,' are preserved for future turns.

Step by step

01Run `atlas codebase_search "how requests are authenticated in Laravel"` to semantically find relevant files like `app/Http/Middleware/Authenticate.php`.
02Execute `atlas glob app/* config/* database/* routes/*` to quickly map the top-level directory structure of the Laravel project.
03Use `atlas read app/Http/Middleware/Authenticate.php routes/web.php` to inspect the content of the highest-ranked files.
04Apply `atlas lsp goToDefinition app/Http/Middleware/Authenticate.php:15` (adjust line number) to follow an import or method definition within a Laravel file.
05Delegate a wide search with `atlas task explore "find all Eloquent models with a 'soft delete' trait"` to the read-only subagent.
06Record any open questions or insights using `atlas todowrite "Investigate the purpose of the 'App\Services\PaymentGateway' class and its usage in controllers."`.

Frequently asked questions

Can Atlas understand my custom Laravel `artisan` commands?: Yes, Atlas indexes code by AST declarations, allowing it to understand and search for custom `artisan` commands defined in your `app/Console/Commands` directory. You can ask `codebase_search` to find specific command implementations.
How does Atlas handle Laravel's Eloquent models and relationships?: Atlas's semantic index understands Eloquent models and their relationships. You can ask `codebase_search` questions like "show me the `User` model's relationships" or "where is the `Order` model defined?" to quickly locate relevant code.
Is it safe to let Atlas explore my Laravel project?: Yes, the `explore` subagent operates with a deny-by-default permission set, only allowing read-only tools like `grep`, `glob`, and `read`. This ensures no changes are made to your Laravel codebase without explicit approval, keeping your project safe.
Can Atlas help me find all `Pest` tests related to a specific Laravel feature?: Absolutely. You can use `atlas codebase_search "Pest tests for user authentication"` or `atlas task explore "find all Pest tests in tests/Feature that interact with the 'Order' model"` to locate relevant tests within your Laravel project.
How does Atlas integrate with Laravel's `Composer` dependencies?: While Atlas doesn't directly manage `Composer` dependencies, its semantic indexing and `read` tool can help you understand how your Laravel project uses packages defined in `composer.json` and `vendor/`, providing context on external libraries.
What if Atlas proposes a change to a Laravel file?: Atlas drafts a plan in a read-only agent, then computes a unified diff for every proposed file edit. You must review and approve this diff before any changes are written to your Laravel project, ensuring full control over modifications.
Can Atlas help me understand Laravel routes?: Yes, you can use `atlas read routes/web.php` or `routes/api.php` to inspect your route definitions. `codebase_search` can also help you find specific routes, e.g., "where is the `/dashboard` route defined?" within your Laravel application.

Try Atlas in your terminal

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

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

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.

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.

Automate GitHub Issue and Pull Request Triage in Laravel with Atlas in 2026

Streamline GitHub issue and pull request triage for your Laravel projects in 2026 using Atlas. Automate responses safely, ensuring only trusted users trigger actions within your familiar Laravel toolchain.

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

Catch your own mistakes in uncommitted Laravel diffs before CI or review. Atlas helps Laravel developers in 2026 self-review code changes, run Pest tests, and apply Laravel Pint formatting.

Audit a Laravel Repository with Parallel Subagents in 2026

Sweep your Laravel application for code issues in 2026 using Atlas's parallel subagents. Efficiently audit Eloquent models, routes, and tests without blowing your context window.

Document a Module with a README in Laravel with Atlas in 2026

In 2026, Laravel developers use Atlas to generate accurate READMEs for modules, ensuring documentation reflects current code. Atlas leverages Pest and Composer to verify code samples and integrates with Laravel Pint for

Review a Pull Request in Laravel with Atlas in 2026

In 2026, Atlas helps Laravel developers review pull requests by fetching diffs, reading full files, checking LSP references, and running Pest tests for comprehensive bug detection.

Browse this resource hub