How does Atlas ensure PHP documentation is up-to-date with the code?

Atlas generates PHP documentation by directly reading the source code using tools like `lsp` and `read`, and by observing real-world usage with `codebase_search`. This ensures the documentation reflects the code's current state, not outdated assumptions.

Can Atlas document PHP classes that use `Composer` autoloading?

Yes, Atlas is designed to work within PHP projects that use `Composer`. It reads your `composer.json` file to understand namespaces, autoloading configurations (e.g., `psr-4`), and dependencies, allowing it to accurately navigate and document your PHP codebase.

How does Atlas handle code examples in PHP READMEs?

Atlas includes PHP code examples in READMEs and then uses the `bash` tool to execute every single one. This verification step guarantees that all code samples are functional and accurate, preventing the inclusion of broken or misleading examples.

What PHP tools does Atlas integrate with for documentation?

Atlas integrates deeply with the PHP ecosystem, recognizing `Composer` for package management, `PHPUnit` for testing, and `PHP-CS-Fixer` for formatting. It understands `PSR` standards and uses real PHP file paths and idioms.

Is it safe to let Atlas modify my PHP project files?

Yes, Atlas prioritizes safety. It operates with permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every proposed file edit (like a `README.md` update) for your explicit approval before writing any changes.

Can Atlas match my existing PHP project's documentation style?

Yes, Atlas uses the `grep` tool to search for existing `README.md` files in your repository. This allows it to analyze and match the established heading structure, tone, and overall format, ensuring consistency with your project's current documentation.

How does Atlas identify the public API of a PHP module?

Atlas uses the `lsp` tool's `documentSymbol` operation to enumerate the public API of a PHP module. This method precisely identifies all exported classes, interfaces, traits, functions, and constants, ensuring no public surface area is missed or invented.

Document a PHP Module with a README in 2026

Atlas empowers PHP developers in 2026 to produce precise README documentation that reflects the current state of their code, not outdated specifications. By integrating directly with your PHP codebase, Atlas uses tools like `lsp` to enumerate public APIs, `read` to understand implementation, and `write` to generate the README, all while respecting your `composer.json` configuration and `PSR` standards.

How Atlas Documents PHP Modules with READMEs

Atlas streamlines the creation of accurate README documentation for PHP modules by following a 5-step workflow that directly inspects your codebase. This process ensures the generated documentation reflects the code's current behavior, not just its initial design from a year ago, by leveraging tools like `lsp` and `read`.

Atlas generates README documentation for PHP modules by executing a precise, verifiable workflow. It begins by using the `lsp` tool's `documentSymbol` operation to enumerate the module's public API, ensuring no exported function, class, or constant is missed or invented. This operation provides a complete and accurate surface area of the PHP module. Following this, Atlas employs the `read` tool to examine the implementation details of each identified export. To understand real-world usage, `codebase_search` is utilized to find how callers actually interact with these exports within the broader PHP project. Before writing, Atlas uses `grep` to locate any existing `README.md` files in the repository, allowing it to match the established heading structure and tone rather than inventing a new format. Finally, the `write` tool emits the new or updated `README.md`, quoting real PHP signatures and actual file paths like `src/MyModule/MyClass.php`. This entire process is grounded in reading the source, making the documentation traceable and reliable for any PHP developer in 2026.

Verifying PHP Code Samples in Atlas Documentation

Atlas ensures the reliability of PHP documentation by verifying every code sample with `bash`, a critical step that prevents the inclusion of non-functional examples. This rigorous approach guarantees that any PHP code snippet presented in a README will execute correctly, providing 100% confidence in its accuracy.

A key differentiator for Atlas-generated PHP documentation is the automatic verification of all code samples. After drafting the `README.md` with the `write` tool, Atlas uses the `bash` tool to execute every PHP code sample embedded within the documentation. This crucial step confirms that the examples are not merely plausible but are actually runnable and produce the expected output within the context of your PHP project. A code sample that has never been executed is considered a liability, as it can quickly become outdated or incorrect, misleading developers. By running these samples, Atlas eliminates this risk, providing PHP developers with documentation that is not only descriptive but also demonstrably correct. This verification process is integral to the workflow, ensuring that the documentation accurately reflects the current behavior of the PHP code, including interactions with `Composer` dependencies or specific `PSR` implementations.

Integrating Atlas with Your PHP Development Environment

Atlas direct integrates into existing PHP development environments by recognizing standard tools and configurations, starting with your `composer.json` file. This allows Atlas to understand your project's namespaces, autoloading setup, and dependencies, ensuring its operations are fully aligned with your PHP codebase in 2026.

Atlas is designed to work natively within PHP projects, understanding the conventions and tools PHP developers use daily. When run in a project containing a `composer.json` file, Atlas automatically reads and interprets its contents. This includes understanding defined namespaces, autoloading configurations (e.g., `psr-4`), and project dependencies managed by `Composer`. This deep integration allows Atlas to accurately navigate your PHP codebase, resolve symbols, and understand the project structure, which is vital for tasks like enumerating public APIs with `lsp` or performing `codebase_search`. Furthermore, Atlas can be instructed to perform common PHP development tasks, such as adding `PHPUnit` tests or applying `PSR-12` formatting, and will present a unified diff for review before making any changes. This ensures that Atlas's actions are always consistent with your project's established standards and toolchain.

Safety and Review for Atlas-Generated PHP Documentation

Atlas prioritizes safety and developer control when generating PHP documentation, implementing a multi-stage review process before any changes are committed. Every Atlas tool call is permission-gated, and all proposed file edits are presented as a unified diff for explicit approval, ensuring 100% transparency and preventing unintended modifications.

The safety and integrity of your PHP codebase are paramount when using Atlas. Before any tool is executed, Atlas employs a permission-gating system based on allow, ask, and deny rules, giving developers granular control over its actions. The documentation workflow begins with Atlas drafting a plan in a read-only plan agent, which is then presented for developer review and approval before switching to a build agent to execute the plan. When Atlas proposes changes, such as writing a `README.md` or modifying a PHP file, it computes a unified diff for every file edit. This diff is surfaced for explicit approval, allowing developers to inspect every line change before it is written to disk. Additionally, Atlas reads `git` branches, status, and diffs, and can stage and create commits on your behalf, with all changes snapshot as `git` patches for easy rollback. This comprehensive review process ensures that all Atlas-generated documentation and code modifications are intentional and approved by the PHP developer.

Concrete Atlas Commands for Documenting PHP Code

To document a PHP module with a README using Atlas, developers will interact with specific commands that leverage the `lsp`, `read`, `write`, and `bash` tools. For instance, initiating the documentation process might involve a command like `atlas document module src/MyModule/MyClass.php`, which then orchestrates the 4 core steps of the workflow.

Interacting with Atlas to document PHP code involves using its integrated tools through a natural language interface or direct command invocation. While the exact command structure can vary based on plugin configuration, the underlying Atlas tools are consistently applied. For example, to enumerate the public API of a PHP class located at `src/MyModule/MyClass.php`, Atlas internally uses the `lsp` tool's `documentSymbol` operation. When gathering implementation details, the `read` tool accesses the contents of files like `src/MyModule/MyClass.php`. To find usage patterns, `codebase_search` scans the entire project. The `grep` tool is used to find existing `README.md` files. Finally, the `write` tool is responsible for generating the `README.md` file itself, potentially at the project root or within a module directory. After generation, the `bash` tool is invoked to run any PHP code samples within the new `README.md`, ensuring their validity. Developers can also ask Atlas to apply `PSR-12` formatting using `PHP-CS-Fixer` or run `PHPUnit` tests, all through a conversational interface that translates into concrete tool calls.

Step by step

01Run Atlas in your PHP project directory containing `composer.json` to allow it to index your codebase and understand `PSR` namespaces.
02Instruct Atlas to enumerate the public API of your target PHP module, for example, `atlas lsp documentSymbol src/MyModule/MyClass.php`, to identify all exports.
03Ask Atlas to read the implementation of each identified PHP export and use `codebase_search` to find real-world usage examples within your project.
04Direct Atlas to `grep` for existing `README.md` files in your repository to match the established documentation style and structure.
05Command Atlas to `write` the `README.md` for the PHP module, ensuring it quotes real PHP signatures and file paths like `src/MyModule/MyClass.php`.
06Approve the unified diff presented by Atlas for the new `README.md` file, verifying all proposed changes.
07Observe Atlas using `bash` to execute every PHP code sample within the generated `README.md` to confirm their accuracy and functionality.

Frequently asked questions

How does Atlas ensure PHP documentation is up-to-date with the code?: Atlas generates PHP documentation by directly reading the source code using tools like `lsp` and `read`, and by observing real-world usage with `codebase_search`. This ensures the documentation reflects the code's current state, not outdated assumptions.
Can Atlas document PHP classes that use `Composer` autoloading?: Yes, Atlas is designed to work within PHP projects that use `Composer`. It reads your `composer.json` file to understand namespaces, autoloading configurations (e.g., `psr-4`), and dependencies, allowing it to accurately navigate and document your PHP codebase.
How does Atlas handle code examples in PHP READMEs?: Atlas includes PHP code examples in READMEs and then uses the `bash` tool to execute every single one. This verification step guarantees that all code samples are functional and accurate, preventing the inclusion of broken or misleading examples.
What PHP tools does Atlas integrate with for documentation?: Atlas integrates deeply with the PHP ecosystem, recognizing `Composer` for package management, `PHPUnit` for testing, and `PHP-CS-Fixer` for formatting. It understands `PSR` standards and uses real PHP file paths and idioms.
Is it safe to let Atlas modify my PHP project files?: Yes, Atlas prioritizes safety. It operates with permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every proposed file edit (like a `README.md` update) for your explicit approval before writing any changes.
Can Atlas match my existing PHP project's documentation style?: Yes, Atlas uses the `grep` tool to search for existing `README.md` files in your repository. This allows it to analyze and match the established heading structure, tone, and overall format, ensuring consistency with your project's current documentation.
How does Atlas identify the public API of a PHP module?: Atlas uses the `lsp` tool's `documentSymbol` operation to enumerate the public API of a PHP module. This method precisely identifies all exported classes, interfaces, traits, functions, and constants, ensuring no public surface area is missed or invented.

Try Atlas in your terminal

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

Install Atlas

Related guides

Document a Module with a README Using Atlas (2026 Workflow)

How to document a module with a README using Atlas in 2026: the lsp tool's documentSymbol enumerates the real exports, read supplies the behavior, write emits the README.

Atlas for PHP in 2026

Atlas, the terminal-native AI coding agent, empowers PHP developers in 2026 with intelligent code understanding, secure workflows, and direct integration for Composer and PSR standards.

Extract a shared helper from duplicated code in PHP with Atlas (2026)

The same PHP logic is copy-pasted in 5 controllers with different variable names. Atlas finds it by meaning with codebase_search, extracts one helper, and proves it with PHPUnit.

Migrate a Deprecated API Across Every Callsite in PHP with Atlas in 2026

Move your PHP codebase off deprecated functions or modules onto replacements without missing a single caller. Atlas integrates with Composer and PHPUnit for a verified migration.

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

Catch your own mistakes in PHP code before they reach a reviewer or CI. Atlas helps PHP developers in 2026 self-review uncommitted diffs, run PHPUnit tests, and apply PHP-CS-Fixer formatting.

Locate Where a Behavior Is Implemented in PHP with Atlas (2026)

Track a PHP behavior down to the exact class and method in 2026. Atlas fuses semantic retrieval, ripgrep-backed regex, and the lsp symbol graph across your src tree.

Write unit tests for untested code in PHP with Atlas (2026)

Write PHPUnit tests for untested PHP code in 2026 with Atlas: enumerate exported symbols with documentSymbol, copy the repo's test conventions, then actually run them.

Audit a PHP Repository with Parallel Subagents in 2026

Sweep your entire PHP codebase for issues without context window limits. Atlas uses parallel subagents to audit Composer packages and PSR standards, integrating with PHPUnit and PHP-CS-Fixer.

Browse this resource hub