Atlas documents SolidJS modules by analyzing live source code, ensuring your README reflects current functionality rather than outdated specifications. It integrates directly with your existing SolidJS toolchain, leveraging `pnpm` for package management, `vitest (@solidjs/testing-library)` for test verification, and `prettier` for consistent code formatting, all within your terminal in 2026.
How Atlas Ensures Accurate SolidJS Module Documentation
In 2026, Atlas ensures SolidJS module documentation is accurate by generating READMEs directly from source code, not from memory or outdated specifications. This process guarantees that the documentation describes what the code actually does today, providing 100% traceability for every claim.
Atlas approaches documentation for SolidJS modules by treating your codebase as the single source of truth. Instead of relying on an agent's memory or a year-old design document, Atlas uses its `lsp` tool's `documentSymbol` operation to enumerate the real exported surface of your SolidJS module. It then employs the `read` tool to understand the behavior of each export and `codebase_search` to find how callers actually use these exports in practice. This method ensures that the generated `README.md` is a direct reflection of the current SolidJS implementation, making every claim traceable back to a specific line of code.
Integrating Atlas with the SolidJS Toolchain for READMEs
Atlas integrates direct with the SolidJS toolchain, recognizing common tools like `pnpm`, `vitest (@solidjs/testing-library)`, and `prettier` in 2026. This allows Atlas to operate within your familiar development environment, respecting your project's established conventions and configurations.
When documenting a SolidJS module, Atlas leverages your existing toolchain to ensure consistency and correctness. It expects a SolidJS project with a `vite.config.ts` using `vite-plugin-solid`. Atlas uses `pnpm` as the package manager for any necessary installations or script executions. For verifying code samples within the generated `README.md`, Atlas can run `vitest (@solidjs/testing-library)` behind a permission prompt, ensuring that examples are functional. Finally, after generating or modifying a `README.md`, Atlas can be instructed to run `prettier` on the touched `.tsx` files or the `README.md` itself, maintaining your project's formatting standards.
Enumerating SolidJS Module APIs and Analyzing Real-World Usage
Atlas precisely enumerates a SolidJS module's public API using the `lsp` tool's `documentSymbol` operation, ensuring no export is missed or invented. It then dives into the implementation, analyzing `createSignal`, `createMemo`, and `createEffect` graphs to understand the module's dynamic behavior in 2026.
To create comprehensive documentation, Atlas first identifies the complete public interface of your SolidJS module. The `lsp` tool's `documentSymbol` operation provides an accurate list of all exported functions, components, and variables. Following this, Atlas uses the `read` tool to delve into the implementation details of each export. This includes understanding the reactivity graph formed by `createSignal`, `createMemo`, and `createEffect` calls, which is fundamental to SolidJS's reactive paradigm. Furthermore, Atlas employs `codebase_search` to find real-world examples of how these exports are used by other parts of your application, providing practical context and usage patterns for the `README.md`.
Verifying SolidJS Code Samples in READMEs with `bash`
A critical step in Atlas's documentation workflow for SolidJS is verifying every code sample in the generated `README.md` by running it with `bash`. This process ensures that all examples are executable and correct, preventing 0 errors and making the documentation a reliable resource in 2026.
Outdated or incorrect code samples are a significant liability in any documentation. For SolidJS modules, Atlas addresses this by integrating a robust verification step. After drafting the `README.md` with the `write` tool, Atlas uses the `bash` tool to execute every code sample included in the document. This direct execution confirms that the code snippets are syntactically correct, functionally sound, and accurately reflect the module's behavior. If a sample fails to run or produces an unexpected output, Atlas flags it, ensuring that only verified, working examples are presented to the SolidJS developer reading the `README.md`.
Atlas's Safety and Review Process for SolidJS Documentation
Atlas incorporates multiple safety and review mechanisms to ensure developers maintain full control over SolidJS documentation changes in 2026. Every Atlas tool call is permission-gated, and all proposed edits are presented as a unified diff for explicit approval before writing to disk.
The documentation process with Atlas is designed with developer control at its core. Before any tool call, such as `lsp`, `read`, `codebase_search`, `grep`, `write`, or `bash`, Atlas checks against permission-gated allow, ask, and deny rules. This ensures that no operation runs without explicit or pre-approved consent. Atlas drafts its plan in a read-only plan agent, asking for approval before switching to a build agent that can make changes. Crucially, for every file edit, including the creation or modification of a SolidJS `README.md`, Atlas computes a unified diff and surfaces it for your approval. This allows you to review every proposed change, ensuring the generated documentation meets your standards before it is committed to your SolidJS project.
Step by step
- 01Initialize Atlas in your SolidJS project, ensuring a `vite.config.ts` using `vite-plugin-solid` is present: `atlas init`
- 02Ask Atlas to enumerate the module's public API using the `lsp` tool's `documentSymbol` operation: `atlas ask "Enumerate the public API of this SolidJS module using the lsp tool's documentSymbol operation."`
- 03Instruct Atlas to read implementation details, including `createSignal` and `createEffect` graphs, and find real-world usage with `codebase_search`: `atlas ask "Read the implementation of each SolidJS export, and use codebase_search to find how callers actually use it in practice."`
- 04Guide Atlas to find an existing `README.md` in the repository to match its heading structure and tone: `atlas ask "Grep the repo for an existing README to match heading structure and tone."`
- 05Have Atlas draft the `README.md` for your SolidJS module using the `write` tool, quoting real signatures and file paths: `atlas ask "Write the README with the write tool, quoting real signatures and real file paths."`
- 06Verify every code sample in the drafted `README.md` by running it with `bash`, ensuring they are executable and correct: `atlas ask "Verify every code sample in the doc by running it with bash; a sample that was never executed is a liability."`
- 07Review the proposed changes to the `README.md` presented by Atlas as a unified diff and approve them: `atlas review`
- 08Apply `prettier` formatting to the new `README.md` file to maintain code style consistency: `pnpm exec prettier --write README.md`
Frequently asked questions
- How does Atlas ensure SolidJS documentation reflects current code, not old specs?
- Atlas directly reads your SolidJS source code using `lsp` and `read` tools, analyzing `createSignal`, `createMemo`, and `createEffect` graphs to document what the code *actually* does today, not what it was intended to do a year ago.
- What SolidJS-specific tools does Atlas integrate with for documentation?
- Atlas integrates with your SolidJS toolchain, using `pnpm` for package management, `vitest (@solidjs/testing-library)` for verifying code samples, and `prettier` for formatting generated documentation files like `README.md`.
- Can Atlas document SolidStart routes or complex SolidJS component structures?
- Yes, Atlas is designed to read your `createSignal`, `createMemo`, and `createEffect` graph, and can also read any SolidStart routes, ensuring comprehensive documentation for your SolidJS application's structure.
- How does Atlas verify code examples in the generated SolidJS README?
- Every code sample Atlas includes in a SolidJS `README.md` is verified by running it with the `bash` tool. This ensures that all examples are executable and accurate, preventing outdated or incorrect code snippets.
- What safety measures does Atlas have when writing SolidJS documentation?
- Atlas operates with permission-gated tool calls, drafts plans in a read-only agent, and presents a unified diff for every file edit. You must approve changes to your SolidJS `README.md` before they are written.
- Does Atlas help with common SolidJS reactivity bugs during documentation?
- While documenting, Atlas can be asked to fix common SolidJS bugs, such as a destructured prop that broke reactivity, which is a frequent issue for SolidJS developers.
- How does Atlas handle existing README files in a SolidJS project?
- Atlas uses the `grep` tool to search for an existing `README.md` in your SolidJS repository. This allows it to match the established heading structure and tone, ensuring consistency rather than inventing a new format.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated 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 SolidJS: A Terminal-Native AI Coding Agent Built on Solid, for Solid, in 2026
Atlas is a terminal-native AI coding agent for SolidJS in 2026. It reads your createSignal and createMemo graph, fixes destructured props that break reactivity, and runs vitest.
Automate GitHub Issue and Pull Request Triage in SolidJS with Atlas in 2026
Streamline GitHub issue and pull request triage in your SolidJS projects using Atlas. Configure workflows to safely automate responses, enforce trusted user permissions, and integrate with your `pnpm` and `vitest`
Extract a Shared Helper from Duplicated Code in SolidJS with Atlas in 2026
Refactor your SolidJS codebase in 2026 by extracting duplicated logic into a shared helper using Atlas. Leverage pnpm, vitest (@solidjs/testing-library), and prettier for a streamlined workflow.
Self-review your working diff before committing in SolidJS with Atlas in 2026
Catch your own mistakes in SolidJS before they reach review or CI. Atlas helps SolidJS developers in 2026 self-review uncommitted diffs, run vitest, prettier, and manage changes.
Run the test suite and triage failures in SolidJS with Atlas in 2026
Streamline SolidJS test failure triage in 2026 with Atlas. Quickly turn `vitest` output into a prioritized list of distinct root causes, leveraging `pnpm` and `prettier` for efficient debugging and fixes.
Rename a symbol across the repo in SolidJS with Atlas in 2026
In 2026, rename functions, classes, or constants across your SolidJS codebase with Atlas. Leverage lsp, grep, and edit for precise, verified refactoring.
Run Atlas Headless in CI for SolidJS Projects in 2026
Automate Atlas in your SolidJS CI pipeline for machine-readable output. Leverage pnpm, vitest, and prettier to integrate AI-driven code changes and testing direct in 2026.