How does Atlas handle SolidJS reactivity and signals?

Atlas understands SolidJS's reactivity model by indexing `createSignal`, `createMemo`, and `createEffect` declarations using tree-sitter. Its `lsp` tool can walk the call graph, tracing how signals propagate and affect components, which is crucial for debugging issues like a destructured prop breaking reactivity. Atlas is also configured to read your `vite.config.ts` for SolidJS-specific build configurations.

What test runner does Atlas use for SolidJS projects?

Atlas uses `vitest (@solidjs/testing-library)` as the test runner for SolidJS projects. It executes `pnpm vitest` commands via its `bash` tool, allowing for precise control over test execution, including running single tests with specific filter flags to streamline debugging.

Can Atlas fix common SolidJS bugs like destructured props breaking reactivity?

Yes, Atlas is specifically designed to identify and fix common SolidJS bugs, including instances where destructured props can inadvertently break reactivity. By understanding the SolidJS reactivity graph through its `lsp` tool, Atlas can propose and apply precise code fixes using its `edit` or `apply_patch` tools.

How do I review and approve code changes Atlas makes in my SolidJS codebase?

Atlas provides a robust review process. Every tool call is permission-gated, and for any proposed code change in your SolidJS `.tsx` files, Atlas computes and displays a unified diff. You must explicitly approve these changes before they are written to disk, ensuring you have full control over your codebase. Atlas also integrates with `git` for easy rollback.

Does Atlas support SolidStart routes and other SolidJS ecosystem tools?

Yes, Atlas is designed to work within the broader SolidJS ecosystem. It can read your SolidStart routes and integrate with common tools like `pnpm` for package management and `prettier` for code formatting. Atlas's extensibility through plugins also allows for future integrations with other SolidJS-specific tools and frameworks.

How does Atlas ensure code quality and formatting in SolidJS projects?

Atlas helps maintain code quality by proposing targeted fixes for bugs and can automatically run `prettier` on touched `.tsx` files after making edits. This ensures that your SolidJS codebase adheres to your project's formatting standards, providing a consistent and clean development experience.

Debug a single failing test in SolidJS with Atlas in 2026

Atlas helps SolidJS developers debug a single failing test by running `vitest (@solidjs/testing-library)` in isolation, analyzing the call graph with LSP, and proposing precise code fixes using `pnpm` and `prettier` for a streamlined workflow in 2026. This process ensures that even complex reactivity bugs, like those stemming from destructured props, are identified and resolved directly in your terminal.

How Atlas runs a specific SolidJS test with `vitest`

Atlas isolates a single failing SolidJS test by executing `pnpm vitest` with a specific filter flag via its `bash` tool, ensuring a focused debugging environment. This approach, effective in 2026, minimizes output noise, allowing developers to concentrate on the 1 relevant test case without sifting through an entire test suite.

When a SolidJS test fails, Atlas uses its `bash` tool to run `vitest (@solidjs/testing-library)` with a targeted filter. For instance, to debug a test named "should render correctly with signal" within `src/components/MyComponent.test.tsx`, Atlas executes a command similar to `atlas bash 'pnpm vitest src/components/MyComponent.test.tsx -t "should render correctly with signal"'`. This command directly invokes `vitest`, the standard test runner for SolidJS projects, ensuring that only the specified test runs. The output is then captured and analyzed by Atlas, providing a clear view of the assertion failure without the distraction of other passing or failing tests. This precise execution mirrors how a SolidJS developer would manually isolate a test, making the debugging process intuitive and efficient.

How Atlas traces SolidJS reactivity and call graphs with LSP

Atlas leverages its `lsp` tool to meticulously trace the reactivity graph of SolidJS components, understanding `createSignal`, `createMemo`, and `createEffect` declarations. By indexing code via AST declarations using tree-sitter, Atlas provides a deep understanding of SolidJS's unique one-time component body execution model, crucial for debugging in 2026.

After identifying a failing SolidJS test, Atlas employs its `lsp` tool to work through the codebase and understand the flow of data and reactivity. Atlas's `lsp` capabilities, such as `goToDefinition` and `findReferences`, are specifically tailored to SolidJS's paradigm. It can trace the usage of `createSignal`, `createMemo`, and `createEffect` hooks, which form the core of SolidJS's reactivity model. By building its code index with AST declarations using tree-sitter, Atlas comprehends the exact relationships between these reactive primitives and how they influence component rendering. This allows Atlas to accurately walk the call graph, even when dealing with complex SolidJS idioms or issues like destructured props that can break reactivity. Atlas also reads your `vite.config.ts` using `vite-plugin-solid` to ensure it understands your project's specific build configuration.

How Atlas fixes SolidJS code and common reactivity bugs

Atlas fixes SolidJS production code using its `edit` tool, or `apply_patch` for more extensive changes, directly addressing issues like broken reactivity from destructured props. Before any modification, Atlas drafts a plan in a read-only agent, ensuring a thoughtful approach to fixing the 1 most common SolidJS bugs in 2026.

Once a hypothesis is formed about the root cause of a SolidJS test failure, Atlas proceeds to fix the production code. For minor, localized changes, the `edit` tool is used, allowing Atlas to insert, delete, or replace specific lines of code. For example, if a destructured prop is identified as breaking reactivity, Atlas can precisely modify the component to ensure proper signal access. If the fix spans multiple hunks or requires a more complex refactor, Atlas utilizes `apply_patch` to ensure atomic and reliable changes. Every proposed edit is first formulated by a read-only plan agent, which then transitions to a build agent for execution. Atlas computes a unified diff for every file edit, which is presented for your approval before any changes are written to disk. After the fix, Atlas can automatically run `prettier` on touched `.tsx` files to maintain code formatting consistency.

Reviewing and approving Atlas's SolidJS code changes

Atlas prioritizes developer control and safety by requiring explicit approval for all proposed SolidJS code changes. Every Atlas tool call is permission-gated, and a unified diff is presented for review, allowing you to accept or reject modifications to your `.tsx` files in 2026. This ensures you maintain full oversight of your SolidJS codebase.

Atlas integrates robust review and safety mechanisms into its workflow for SolidJS projects. Before any `edit` or `apply_patch` operation is executed, Atlas presents a permission prompt, allowing you to `allow`, `ask`, or `deny` the tool call. This granular control ensures that Atlas only performs actions you explicitly authorize. When Atlas proposes a code fix, it generates a unified diff, clearly showing the exact changes to your SolidJS `.tsx` files. This diff is surfaced for your approval, giving you the opportunity to review every line of code Atlas intends to modify. Furthermore, Atlas reads `git` branches, status, and diffs, and can stage and create commits on your behalf, or snapshot file changes as `git` patches, allowing for easy rollback if needed. This comprehensive review process ensures that all changes to your SolidJS application are transparent and under your control.

Step by step

011: Run just the failing SolidJS test in isolation using Atlas's `bash` tool and `pnpm vitest`. For example: `atlas bash 'pnpm vitest src/components/MyComponent.test.tsx -t "should render correctly with signal"'`.
022: Read the failing SolidJS test file and the module it exercises using `atlas read`. Then, use `atlas lsp goToDefinition` and `findReferences` to walk the SolidJS component's call path and reactivity graph, focusing on `createSignal` or `createMemo` usage.
033: Form a hypothesis about the SolidJS bug. Check it by adding temporary `console.log` statements with `atlas edit src/components/MyComponent.tsx --insert "console.log('Debug value:', mySignal());"` or re-running the test with a verbose flag through `atlas bash`.
044: Fix the SolidJS production code. For small changes, use `atlas edit src/components/MyComponent.tsx --replace "old code" "new code"`. If the fix involves several hunks or a larger refactor, use `atlas apply_patch` to ensure a cohesive change, especially for reactivity issues like destructured props.
055: Re-run the single SolidJS test with `atlas bash 'pnpm vitest src/components/MyComponent.test.tsx -t "should render correctly with signal"'` to confirm the fix.
066: Run the full SolidJS test suite with `atlas bash 'pnpm vitest'` to ensure no regressions were introduced by the fix.
077: Remove any temporary logging added in step 3 using `atlas edit src/components/MyComponent.tsx --delete "console.log('Debug value:', mySignal());"`.
088: Review the unified diff presented by Atlas for all changes to your SolidJS `.tsx` files and approve them. Atlas can then automatically run `pnpm prettier --write src/components/MyComponent.tsx` to format the code.

Frequently asked questions

How does Atlas handle SolidJS reactivity and signals?: Atlas understands SolidJS's reactivity model by indexing `createSignal`, `createMemo`, and `createEffect` declarations using tree-sitter. Its `lsp` tool can walk the call graph, tracing how signals propagate and affect components, which is crucial for debugging issues like a destructured prop breaking reactivity. Atlas is also configured to read your `vite.config.ts` for SolidJS-specific build configurations.
What test runner does Atlas use for SolidJS projects?: Atlas uses `vitest (@solidjs/testing-library)` as the test runner for SolidJS projects. It executes `pnpm vitest` commands via its `bash` tool, allowing for precise control over test execution, including running single tests with specific filter flags to streamline debugging.
Can Atlas fix common SolidJS bugs like destructured props breaking reactivity?: Yes, Atlas is specifically designed to identify and fix common SolidJS bugs, including instances where destructured props can inadvertently break reactivity. By understanding the SolidJS reactivity graph through its `lsp` tool, Atlas can propose and apply precise code fixes using its `edit` or `apply_patch` tools.
How do I review and approve code changes Atlas makes in my SolidJS codebase?: Atlas provides a robust review process. Every tool call is permission-gated, and for any proposed code change in your SolidJS `.tsx` files, Atlas computes and displays a unified diff. You must explicitly approve these changes before they are written to disk, ensuring you have full control over your codebase. Atlas also integrates with `git` for easy rollback.
Does Atlas support SolidStart routes and other SolidJS ecosystem tools?: Yes, Atlas is designed to work within the broader SolidJS ecosystem. It can read your SolidStart routes and integrate with common tools like `pnpm` for package management and `prettier` for code formatting. Atlas's extensibility through plugins also allows for future integrations with other SolidJS-specific tools and frameworks.
How does Atlas ensure code quality and formatting in SolidJS projects?: Atlas helps maintain code quality by proposing targeted fixes for bugs and can automatically run `prettier` on touched `.tsx` files after making edits. This ensures that your SolidJS codebase adheres to your project's formatting standards, providing a consistent and clean development experience.

Try Atlas in your terminal

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

Install Atlas

Related guides

Debug a Single Failing Test with Atlas in 2026

How to debug one failing test with Atlas in 2026: run it in isolation with bash, walk the call graph with the lsp tool, and fix the code, not the assertion.

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.

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

SolidJS developers in 2026 can use Atlas to efficiently upgrade major dependencies, automatically fixing compile and test failures. Atlas integrates with pnpm, vitest, and prettier to streamline your workflow.

Document a SolidJS Module with a README in 2026 using Atlas

In 2026, Atlas helps SolidJS developers generate accurate READMEs for modules by analyzing live code, ensuring documentation reflects current implementation, not outdated plans. It integrates with your existing SolidJS

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`

Locate where a behavior is implemented in SolidJS with Atlas in 2026

In 2026, SolidJS developers use Atlas to pinpoint exact file and symbol implementations. Leverage semantic search, grep, and LSP for `createSignal` and component behaviors.

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.

Refactor a Legacy SolidJS Module with Atlas in 2026

Streamline your SolidJS codebase in 2026 by refactoring legacy modules with Atlas. Maintain behavior, prevent breaking changes, and leverage your existing pnpm, vitest, and prettier toolchain.

Browse this resource hub