# Run the vitest Test Suite and Triage Failures in Remix with Atlas in 2026 > Atlas helps Remix developers in 2026 turn a wall of `vitest` test output into a prioritized list of distinct root causes, integrating with `pnpm` and `prettier`. In 2026, Atlas empowers Remix developers to efficiently triage `vitest` test suite failures by transforming extensive red output into a prioritized list of distinct root causes. It integrates directly with your `pnpm` workflow, allowing you to run `vitest` tests, analyze full logs, and track fixes without leaving your terminal. ## Key takeaways - Atlas uses `bash` to run `pnpm vitest` in Remix, capturing full logs even when output is truncated. - Group `vitest` failures by root cause with Atlas `grep` over the complete log, not just test names. - Track distinct Remix `vitest` failure fixes with `todowrite` entries, ensuring no issue is forgotten. - Iteratively fix Remix code with `atlas edit`, re-running only affected `vitest` tests for rapid feedback. - Atlas provides unified diffs and permission-gated tool calls for safe, controlled changes to your Remix application. ## How Atlas Runs Remix vitest Tests and Manages Output Running your Remix application's `vitest` suite with Atlas is straightforward, even for large projects in 2026. Atlas uses its `bash` tool to execute `pnpm vitest`, ensuring that even if the output exceeds 2000 lines or 50 KB, the complete log is saved to a file for thorough analysis. Atlas's `bash` tool is designed to handle the verbose output of a full `vitest` test suite in a Remix project. When you instruct Atlas to run `pnpm vitest`, it executes the command and captures the output. If the terminal output is truncated, Atlas automatically writes the complete log to a retained file, providing you with the exact path. This ensures that no critical failure details are lost, allowing you to analyze the entire context of your Remix loaders, actions, and nested route tests, rather than just a partial tail. You can also pass a generous timeout in milliseconds to `bash` to prevent slow `vitest` suites from being prematurely terminated. ## Grouping Remix Test Failures by Root Cause with Atlas grep After running a `vitest` suite in your Remix project, Atlas helps you group failures by distinct root causes rather than just test names. Using the `grep` tool, Atlas can efficiently scan the complete test log, which might be several megabytes in 2026, to identify recurring patterns and underlying issues. Instead of sifting through individual `vitest` failures one by one, Atlas's `grep` tool allows you to intelligently group them by their underlying root causes. This is crucial for Remix applications where a single issue in a loader, action, or `ErrorBoundary` component might manifest across multiple tests. Atlas directs `grep` to search the full log file (provided by the `bash` tool) for specific error messages, stack trace patterns, or file paths within your `routes/` directory or `vite.config.ts`. This approach helps you quickly identify the core problems, such as a misconfigured `pnpm` dependency or a logic error affecting several related components, making the triage process significantly more efficient. ## Tracking Remix Fixes with Atlas todowrite Once distinct root causes for `vitest` failures in your Remix project are identified, Atlas helps you track their resolution using the `todowrite` tool. This ensures that every identified issue, from a `routes.ts` bug to a `prettier` formatting conflict, is recorded as a pending task, preventing any fixes from being overlooked in 2026. The `todowrite` tool in Atlas is essential for managing the remediation of `vitest` failures in your Remix codebase. For each distinct root cause identified through `grep`, Atlas can create a `todowrite` entry with a 'pending' status. This transforms your triage efforts into an actionable backlog, ensuring that fixes for issues affecting your Remix loaders, actions, or even `vite.config.ts` are systematically addressed. Atlas's ability to snapshot file changes as git patches also means that any edits made during the fixing process can be diffed and rolled back, providing a robust safety net as you work through your `todowrite` list. ## Iterative Fixing and Review in Remix with Atlas edit Atlas facilitates an iterative fix-and-retest cycle for `vitest` failures in Remix, allowing you to address issues one at a time. With the `edit` tool, you can modify code, such as a `routes/` file or a `vite.config.ts` entry, and then re-run only the affected `vitest` tests, often completing a fix within minutes in 2026. When you're ready to fix a specific `vitest` failure in your Remix application, Atlas's `edit` tool provides a controlled environment. You can use `edit` to make precise changes to your code, whether it's adjusting a loader function in `routes/dashboard.tsx` or correcting a configuration in `vite.config.ts`. After making an edit, Atlas allows you to re-run only the relevant `vitest` tests via the `bash` tool, significantly speeding up the feedback loop. Before any changes are written to disk, Atlas computes a unified diff for every file edit and surfaces it for your approval, ensuring you maintain full control over your Remix codebase. Furthermore, Atlas can run `pnpm prettier` across touched route modules after your edits are approved, maintaining code consistency. ## Atlas Safety and Control for Remix Codebase Changes Atlas prioritizes safety and developer control when making changes to your Remix codebase, especially when fixing `vitest` failures. Every Atlas tool call, including `bash` for `pnpm vitest` or `edit` for `routes.ts`, is permission-gated against allow, ask, and deny rules, providing a robust security layer in 2026. Working with Atlas on your Remix project means you retain complete oversight of all code modifications. Before Atlas executes any tool, such as running `pnpm vitest` or modifying a `routes/` file, it drafts a plan in a read-only plan agent and asks for your approval. This allows you to review the proposed actions before they are taken. When Atlas suggests an `edit`, it presents a unified diff for your review and explicit approval before writing any changes. This granular control, combined with Atlas's ability to snapshot file changes as git patches for easy rollback, ensures that your Remix application's integrity is always protected, whether you're debugging a `vitest` failure or refactoring a loader. ## Steps 1. Initiate Atlas in your Remix project, ensuring it can read your `routes/` directory and `vite.config.ts`. 2. Run the full `vitest` test suite using Atlas: `atlas bash 'pnpm vitest --timeout=60000'` to capture all output, even if it's extensive. 3. If the `vitest` output was truncated, use `atlas read ` to review the complete log file path provided by Atlas. 4. Group `vitest` failures by distinct root cause using Atlas: `atlas grep 'Error: (.*)' ` to identify common patterns in your Remix code. 5. Record each distinct root cause as a pending task: `atlas todowrite 'Fix: '` to create an actionable list. 6. Select a `todowrite` entry and use `atlas edit ` to modify the relevant Remix file, such as a loader in `routes/` or a `vite.config.ts` entry. 7. After editing, re-run only the affected `vitest` tests: `atlas bash 'pnpm vitest '` to quickly verify your fix. 8. Approve the unified diff presented by Atlas for your changes, then let Atlas run `pnpm prettier` across the touched Remix route modules. 9. Mark the `todowrite` entry as complete once the `vitest` tests pass and the changes are approved. ## FAQ ### How does Atlas handle large `vitest` output in a Remix project? Atlas's `bash` tool runs `pnpm vitest` and, if the output exceeds 2000 lines or 50 KB, it automatically saves the complete log to a retained file. Atlas then provides you with the path to this file, ensuring you have access to all `vitest` failure details for your Remix loaders and actions. ### Can Atlas help me find the root cause of multiple `vitest` failures in Remix? Yes, Atlas uses its `grep` tool to scan the complete `vitest` log file, allowing you to identify common error patterns or stack traces. This helps you group failures by distinct root causes rather than individual test names, streamlining the triage process for your Remix application. ### How does Atlas ensure I don't forget to fix a `vitest` failure in my Remix app? Atlas integrates the `todowrite` tool into the workflow. For each distinct root cause identified from your `vitest` failures, Atlas can create a 'pending' `todowrite` entry. This ensures that every issue affecting your Remix `routes/` or `vite.config.ts` is tracked until it's resolved. ### What safety features does Atlas offer when I'm editing Remix code? Atlas provides robust safety features. It drafts a plan in a read-only agent for your approval, computes a unified diff for every `edit` before writing, and allows you to roll back changes with git patches. All tool calls are permission-gated, giving you full control over modifications to your Remix codebase. ### Can Atlas re-run only specific `vitest` tests after I make a change in Remix? Absolutely. After using `atlas edit` to modify a Remix file, you can instruct Atlas's `bash` tool to run `pnpm vitest ` for only the affected tests. This significantly accelerates the feedback loop, allowing for rapid iteration on fixes for your Remix loaders or actions. ### Does Atlas integrate with `prettier` for Remix code formatting? Yes, after you approve an `edit` and Atlas writes the changes, it can automatically run `pnpm prettier` across the touched Remix route modules. This ensures that your codebase remains consistently formatted according to your project's standards, even after Atlas-assisted fixes. ### How does Atlas use Remix-specific file structures like `routes/`? Atlas is designed to understand Remix's conventions. It reads your `routes/` directory, `routes.ts`, `vite.config.ts`, and recognizes loaders, actions, and `ErrorBoundary` components. This allows Atlas to provide context-aware assistance when debugging `vitest` failures or suggesting code modifications within your Remix application. --- Canonical HTML: https://runatlas.sh/resources/stacks/run-the-test-suite-and-triage-failures-in-remix Source of truth: aeo_pages row `/resources/stacks/run-the-test-suite-and-triage-failures-in-remix` (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.