# Review a Pull Request in Symfony with Atlas in 2026 > Atlas helps Symfony developers in 2026 review pull requests by fetching full files, checking references with LSP, and running `PHPUnit (WebTestCase)` to catch bugs a simple diff would miss. Atlas empowers Symfony developers in 2026 to review pull requests comprehensively, moving beyond line-by-line diffs to understand the full impact of changes across bundles, services, and Doctrine entities, integrating directly with `PHPUnit (WebTestCase)`, `Composer`, and `PHP-CS-Fixer` for a robust review workflow that catches bugs a simple diff would miss. ## Key takeaways - Atlas reviews Symfony pull requests by fetching full files, not just diff hunks, for complete context. - Atlas uses its `lsp` tool to `findReferences` for changed Symfony service methods and controllers, catching hidden bugs. - `PHPUnit (WebTestCase)` is run by Atlas via `bash` to validate Symfony application behavior and prevent regressions. - Atlas indexes Symfony code by AST, understanding bundles, services, Doctrine entities, and configuration files like `config/services.yaml`. - All Atlas actions are permission-gated and require approval, providing a secure and transparent Symfony review process. - Atlas can build its code index with local Ollama embeddings, keeping your Symfony codebase private. ## How Atlas Enhances Symfony Pull Request Reviews In 2026, Atlas transforms Symfony pull request reviews by moving beyond simple diffs. It fetches the full changed files, not just hunks, providing 100% of the surrounding context needed to spot subtle issues in your bundles or services that a line-by-line read would miss. Atlas approaches pull request review for Symfony applications the way a careful human does: it gets the diff, then leaves the diff to gather more context. Using its `bash` tool, Atlas first fetches the relevant branch and produces the raw patch. Crucially, Atlas then uses its `read` tool to pull the full content of changed files, rather than just the diff hunks. This ensures that the reviewer, guided by Atlas, sees the complete surrounding code, which is vital for understanding the full impact of changes on Symfony's service container definitions in `config/services.yaml`, route configurations in `config/routes`, or Doctrine entity mappings. Atlas's VCS layer exposes `status`, `diff`, `diffRaw`, and `commits` over the same git data, providing a comprehensive view of the changes. ## Verifying Symfony Changes with PHPUnit and Composer Atlas integrates directly with Symfony's core toolchain to validate pull requests. It runs `PHPUnit (WebTestCase)` to ensure all 0 regressions are introduced, and leverages `Composer` for dependency management, providing a robust, automated verification step within your review process. A critical part of reviewing any Symfony pull request is verifying its functional correctness and adherence to standards. Atlas facilitates this by executing real Symfony toolchain commands via its `bash` tool. Before running tests, Atlas can ensure all project dependencies are correctly installed by running `composer install`. Subsequently, it executes `PHPUnit (WebTestCase)` using the command `./bin/phpunit`. This allows Atlas to validate controllers, services, and other components within your Symfony application, catching bugs that might not be apparent from code inspection alone. Atlas can also add `PHPUnit WebTestCase` coverage and run `PHP-CS-Fixer` over the diff to maintain code quality and style consistency. All findings are reported as a `todowrite` list, ordered by severity, for efficient developer action. ## Catching Hidden Bugs with Atlas's LSP and Grep in Symfony To catch bugs a line-by-line diff misses, Atlas employs its `lsp` tool to `findReferences` for every changed function signature in your Symfony codebase. This ensures that even if a change in a service or controller affects 5 other files, Atlas will identify all callers, preventing runtime errors. Symfony applications often involve complex interdependencies between services, controllers, and entities. A seemingly small change to a method signature in one service, for example, `App\Service\MyService::doSomething()`, could silently break multiple callers across different bundles or controllers. Atlas addresses this by using its `lsp` tool's `findReferences` operation for every changed function signature. This capability allows Atlas to identify all locations in the Symfony codebase that call the modified signature, even if those files were not part of the original diff. Furthermore, Atlas can `grep` for specific patterns, such as old constant names, stale copies of code, or feature flags that should have been updated but were overlooked, ensuring a thorough review across your `src/` directory and `config/` files. ## Secure and Transparent Review Workflow with Atlas in Symfony Atlas ensures a secure and transparent review process for Symfony pull requests, with every tool call permission-gated against allow, ask, and deny rules. Before any changes are written, Atlas drafts a plan in a read-only agent and computes a unified diff for approval, offering 100% control to the developer. Security and control are paramount when making changes to a Symfony application. Atlas is designed with a robust safety mechanism: every tool call is permission-gated against allow, ask, and deny rules, giving developers explicit control over what Atlas can execute. Before any modifications are applied, Atlas drafts a comprehensive plan in a read-only plan agent and asks for explicit approval before switching to a build agent. For every file edit, Atlas computes a unified diff and surfaces it for approval, ensuring transparency and preventing unintended changes. Atlas also snapshots file changes as git patches, allowing edits to be easily diffed and rolled back if necessary, providing a secure and auditable workflow for even the most critical Symfony projects. ## Symfony-Specific Code Indexing and Context with Atlas Atlas builds its code index using AST declarations via tree-sitter, not blind line windows, providing a deep understanding of Symfony's structure. This allows it to accurately map controllers, autowired services, and Doctrine entity mappings, even supporting local Ollama embeddings for 0 data leakage to third-party servers. Atlas's ability to provide deep, relevant context for Symfony code stems from its advanced indexing capabilities. Instead of relying on blind line windows, Atlas indexes code by AST (Abstract Syntax Tree) declarations using tree-sitter. This allows it to understand the semantic structure of your Symfony application, recognizing controllers, autowired services defined in `config/services.yaml`, Doctrine entity mappings, and routes in `config/routes`. This deep understanding is crucial for tasks like moving a fat controller into an injected service or adding a Symfony Messenger handler. Furthermore, Atlas can build its code index with local Ollama embeddings, keeping your sensitive Symfony code entirely off third-party servers and ensuring data privacy. ## Steps 1. Fetch the pull request branch in your Symfony project: `atlas bash git fetch origin && git checkout ` 2. Produce the raw diff for review: `atlas bash git diff HEAD~1 HEAD` 3. Read the full content of changed Symfony files for complete context, e.g., `atlas read src/Controller/MyController.php config/services.yaml` 4. For every changed function signature in a Symfony service or controller, run `atlas lsp findReferences ` to check for broken callers. 5. Grep for patterns that should have been updated but were not, such as old constant names or feature flags across `src/` and `config/` directories: `atlas grep "OLD_FEATURE_FLAG" src/ config/` 6. Install or update Composer dependencies for the Symfony project: `atlas bash composer install` 7. Run Symfony's `PHPUnit (WebTestCase)` to validate changes: `atlas bash ./bin/phpunit` 8. Report all findings and suggested actions as a prioritized list: `atlas todowrite "Review findings for Symfony PR #123"` ## FAQ ### How does Atlas handle Symfony service container changes during a PR review? Atlas indexes Symfony's `config/services.yaml` and other configuration files using AST, allowing it to understand how changes to service definitions or autowiring impact the application, providing context beyond a simple line diff. ### Can Atlas run `PHPUnit WebTestCase` for my Symfony project? Yes, Atlas uses its `bash` tool to execute `./bin/phpunit`, specifically supporting `PHPUnit (WebTestCase)` to run your Symfony application's functional and unit tests as part of the pull request review. ### How does Atlas ensure code quality with `PHP-CS-Fixer` in Symfony PRs? Atlas can be instructed to run `PHP-CS-Fixer` over the diff of a Symfony pull request, ensuring that code style standards are maintained and automatically applied before final approval. ### What if a Symfony controller method signature changes? How does Atlas catch breaking changes? For every changed function signature in a Symfony controller or service, Atlas's `lsp` tool performs a `findReferences` operation across the entire codebase, identifying all callers that might be broken by the modification. ### Does Atlas keep my Symfony codebase private during review? Yes, Atlas can build its code index with local Ollama embeddings, ensuring that your Symfony application's source code remains entirely on your local machine and is not sent to third-party servers. ### How does Atlas provide context beyond the diff for Symfony files like `config/routes.yaml`? Atlas uses its `read` tool to pull the full content of changed files, such as `config/routes.yaml` or Doctrine entity mappings, rather than just diff hunks, giving you complete surrounding context for informed decisions. ### Can Atlas help me understand the impact of a Doctrine entity change in Symfony? Atlas indexes Doctrine entity mappings by AST declarations, allowing it to understand the structure and relationships. It can also run `bin/console doctrine:migrations:diff` and show the generated SQL for review before any database changes are applied. --- Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-symfony Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-symfony` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.