# Review a Pull Request in PowerShell with Atlas in 2026 > Atlas helps PowerShell developers in 2026 review pull requests by providing deep context beyond simple diffs, integrating with Pester and PSScriptAnalyzer to ensure robust code quality. Atlas empowers PowerShell developers in 2026 to review pull requests comprehensively, integrating directly with your existing toolchain like Pester for testing, PSResourceGet for package management, and PSScriptAnalyzer Invoke-Formatter for code style. It goes beyond line-by-line diffs to provide crucial surrounding context, ensuring you catch subtle bugs that a superficial review might miss. ## Key takeaways - Atlas provides full file context for PowerShell `.psm1` modules, not just diff hunks. - Integrate `Pester` and `PSScriptAnalyzer Invoke-Formatter` directly into your Atlas review workflow. - Atlas's `lsp` tool checks for broken PowerShell function references across your entire project. - Permission-gated actions ensure you control every change Atlas proposes to your PowerShell code. - Atlas helps identify stale constants and feature flags in PowerShell scripts with `grep`. ## How Atlas Reviews PowerShell Pull Requests for Context Atlas enhances PowerShell pull request reviews by moving beyond simple diffs, providing the full file context for changed .psm1 modules and .psd1 manifests. In 2026, Atlas ensures you see the complete picture, not just isolated hunks, to identify issues a line-by-line review would miss. Atlas approaches pull request review for PowerShell projects by first fetching the relevant branch and producing a comprehensive diff using its internal VCS layer. Unlike traditional diff tools that only show isolated hunks, Atlas's `read` tool pulls the full content of all changed .psm1 module files and .psd1 manifests. This crucial step provides the surrounding context necessary to understand the true impact of a change, allowing you to spot bugs that a line-by-line review would overlook. For instance, a small change in a PowerShell advanced function's parameter block might have cascading effects on other parts of a .psm1 module that are not directly in the diff. Atlas's ability to read the entire file ensures that such contextual dependencies are visible, enabling a more thorough and effective review process for your PowerShell codebase. ## Automating PowerShell Code Quality Checks with Atlas Atlas integrates directly with your PowerShell toolchain to automate critical code quality checks during pull request review. It can run Invoke-Pester for your .Tests.ps1 files and apply PSScriptAnalyzer Invoke-Formatter over the diff, ensuring your code adheres to 2026 standards before merging. Integrating direct with the PowerShell ecosystem, Atlas leverages its `bash` tool to execute `Invoke-Pester` for your .Tests.ps1 files, providing immediate feedback on the integrity of the proposed changes. This ensures that any modifications to your .psm1 modules or scripts do not introduce regressions and maintain expected behavior. Furthermore, Atlas can clear PSScriptAnalyzer warnings and run `PSScriptAnalyzer Invoke-Formatter` specifically over the diff. This automated formatting step guarantees that all new or modified PowerShell code adheres to your project's established style guidelines, preventing inconsistencies and reducing manual review effort. Atlas's permission-gated tool calls mean you retain full control, approving these automated checks before they are applied to your PowerShell codebase. ## Ensuring Safety in PowerShell Refactors with Atlas When reviewing PowerShell refactors, Atlas provides deep contextual awareness to prevent unintended side effects. It uses its lsp tool to findReferences for any changed cmdlet or function signature, ensuring that 0 callers are broken across your .psm1 modules, even if they are outside the immediate diff. Refactoring PowerShell code, especially advanced functions or exported cmdlets within .psm1 modules, carries the risk of breaking dependent code. Atlas mitigates this risk by employing its `lsp` tool's `findReferences` operation. For every changed function signature or parameter block, Atlas proactively searches your entire codebase to identify all call sites. This capability is vital because a standard diff would only show the changes within the modified file, completely missing any external callers in other .psm1 files or scripts. By checking for broken references, Atlas ensures that your PowerShell refactors are safe and do not introduce silent failures. Atlas's read-only plan agent first drafts a strategy, and its unified diff for every file edit requires your approval, providing a robust safety net for complex PowerShell changes. ## Permission-Gated Review Workflow for PowerShell Modules Atlas operates with a permission-gated workflow, ensuring you maintain full control over every action taken on your PowerShell codebase. Before Atlas runs Invoke-Pester or modifies a .psm1 file, it explicitly asks for your approval, preventing any unintended changes in 2026. Atlas's core design prioritizes developer control through its permission-gated workflow. Every tool call, whether it's running `Invoke-Pester`, applying `PSScriptAnalyzer Invoke-Formatter`, or proposing to modify a .psm1 file, is subject to explicit allow, ask, or deny rules. This means that when Atlas suggests adding `CmdletBinding` and `SupportsShouldProcess` to a destructive PowerShell function to honor `-WhatIf`, or when it drafts `.Tests.ps1` files, it will always prompt for your permission before execution. This transparent and controlled process ensures that you, the PowerShell developer, are always in command, approving every step Atlas takes. The unified diff presented for every file edit further reinforces this control, allowing you to review and roll back any proposed changes before they are committed to your PowerShell repository. ## Steps 1. Fetch the pull request branch and generate a comprehensive diff using Atlas's VCS layer, which exposes `diffRaw` for your PowerShell project. 2. Instruct Atlas to `read` the full content of all changed `.psm1` module files and `.psd1` manifests, not just the diff hunks, to gain complete context. 3. For every modified PowerShell function or cmdlet signature, use Atlas's `lsp` tool to `findReferences` across your codebase, ensuring no callers are broken. 4. Employ Atlas's `grep` tool to search for old constant names, stale copies, or feature flags that should have been updated within your PowerShell scripts. 5. Execute `Invoke-Pester` for all relevant `.Tests.ps1` files using Atlas's `bash` tool, reporting findings as a `todowrite` list ordered by severity. 6. Have Atlas clear `PSScriptAnalyzer` warnings and run `PSScriptAnalyzer Invoke-Formatter` over the generated diff, applying consistent style to your PowerShell code. 7. Review Atlas's proposed changes and unified diffs, approving or rolling back edits as needed before committing to your PowerShell repository. ## FAQ ### How does Atlas handle PowerShell module dependencies during review? Atlas reads your `.psd1` manifest and the modules pinned in your requirements, understanding the dependencies of your PowerShell project. It can then use this context when performing operations like `findReferences` or analyzing code. ### Can Atlas run Pester tests automatically for a PowerShell pull request? Yes, Atlas can run `Invoke-Pester` for your `.Tests.ps1` files using its `bash` tool. It will then report the findings as a `todowrite` list, but only after you grant permission. ### How does Atlas ensure PowerShell code style consistency? Atlas can clear `PSScriptAnalyzer` warnings and run `PSScriptAnalyzer Invoke-Formatter` over the diff of your PowerShell code. This ensures that all changes adhere to your project's defined style guidelines before being committed. ### What if a PowerShell function signature changes outside the diff? Atlas uses its `lsp` tool's `findReferences` operation for every changed function signature in your PowerShell `.psm1` modules. This proactively checks for any callers that the diff might not show, preventing silent breakage. ### Is Atlas safe to use for destructive PowerShell functions? Atlas operates with permission-gated tool calls. It can suggest adding `CmdletBinding` and `SupportsShouldProcess` to destructive PowerShell functions, honoring `-WhatIf`, but it will always ask for your explicit approval before making any such changes. ### How does Atlas provide context beyond a standard git diff for PowerShell? Atlas's `read` tool pulls the full content of changed PowerShell files, not just the hunks. This allows it to provide surrounding context that a line-by-line diff would miss, helping you catch subtle bugs in your `.psm1` files. ### Can Atlas help me find old feature flags in my PowerShell scripts? Yes, Atlas's `grep` tool can search for specific patterns like old constant names, stale copies, or feature flags that should have been updated but were missed in the PowerShell changes. --- Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-powershell Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-powershell` (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.