How does Atlas audit `Flyway migrations` for best practices?

Atlas can launch `explore` subagents to sweep your `src/main/resources/db/migration/V*.sql` files, identifying patterns that violate best practices or specific organizational standards. It can check for common issues like missing transaction blocks or non-idempotent statements, returning findings to your main session.

Can Atlas check `pgTAP` test coverage for my SQL functions?

Yes, Atlas can use `grep` and `glob` with `explore` subagents to cross-reference `CREATE FUNCTION` statements in your SQL files with corresponding `pgTAP` test files in your `tests/` directory. It can report functions that appear to lack dedicated test coverage.

What SQL formatting issues can Atlas find using `sqlfluff format`?

Atlas subagents can identify any deviations from your configured `sqlfluff format` rules across your entire SQL codebase. It can flag incorrect indentation, inconsistent casing, missing semicolons, or other style violations, and the main agent can then help apply `sqlfluff format` fixes with diff review.

Is it safe for Atlas to modify my SQL code during an audit?

During an audit, Atlas primarily uses `explore` subagents which are strictly read-only and cannot modify files. Any actual code changes, such as fixing `sqlfluff format` issues or drafting new `pgTAP` tests, are performed by the main agent with explicit user approval after presenting a unified diff.

How does Atlas handle large SQL files or complex schemas?

Atlas indexes code by AST declarations using tree-sitter, providing a deep understanding of SQL structures beyond simple line windows. For large files, parallel subagents can process different sections or aspects, ensuring that even complex `schema.sql` definitions or extensive stored procedures are thoroughly audited without context window limitations.

Can Atlas integrate with my existing SQL CI/CD pipeline?

While Atlas is terminal-native, its ability to generate `git patches` and work with `git branches` means its audit findings and proposed fixes can be easily integrated into a CI/CD workflow. The output from subagents can inform automated checks, and approved changes can be committed directly.

Audit a SQL Repo with Parallel Subagents in 2026 using Atlas

SQL developers in 2026 can sweep an entire repository for a class of problems without blowing the main session's context window by using Atlas's parallel subagents. This approach allows for comprehensive audits of `Flyway migrations`, `pgTAP` tests, and `sqlfluff format` compliance across large SQL codebases, ensuring no issue is missed due to AI context limitations.

How Atlas Audits SQL Repositories with Parallel Subagents

In 2026, Atlas revolutionizes SQL repository audits by deploying parallel subagents, allowing developers to sweep vast codebases for issues like missing `pgTAP` tests or `sqlfluff format` violations without overwhelming the main session's context window. This method ensures thoroughness and efficiency.

Atlas, the terminal-native AI coding agent, performs comprehensive audits of SQL repositories by fanning out work to multiple subagents. When a SQL developer initiates an audit, Atlas splits the task into independent slices, perhaps by directory such as `src/main/resources/db/migration/` or by specific rule sets like 'find all stored procedures without `pgTAP` tests'. Each slice is then assigned to a dedicated subagent, which runs in its own isolated session. This isolation is critical for SQL projects, as it prevents the voluminous content of `.sql` files, `Flyway migrations`, or complex `schema.sql` definitions from consuming the main agent's context. Only the subagent's final conclusions or error messages are returned to the main session, making it feasible to audit even the largest SQL codebases efficiently. Atlas's ability to index code by AST declarations using tree-sitter, rather than blind line windows, further enhances its understanding of SQL structures, allowing for more precise problem identification.

Splitting SQL Audit Tasks for Parallel Execution

To effectively audit a large SQL codebase in 2026, Atlas recommends splitting the audit into independent slices, ensuring subagents do not overlap. This strategy is crucial for projects with extensive `Flyway migrations` or numerous `functions/` directories, maximizing parallel processing efficiency.

Dividing a SQL repository audit into manageable, independent slices is a cornerstone of Atlas's parallel subagent workflow. For a SQL project, this might involve segmenting the audit by logical components such as `src/main/resources/db/migration/V*.sql` files for migration history, `src/main/resources/functions/*.sql` for stored procedures, or `src/main/resources/views/*.sql` for view definitions. Alternatively, an audit could be sliced by specific problem types, like checking all `CREATE TABLE` statements for a specific naming convention or verifying `pgTAP` test coverage for all `CREATE FUNCTION` statements. Atlas's `glob` tool can be used to define these slices, for example, `glob('src/main/resources/db/migration/**/*.sql')`. By issuing multiple `task` calls together, each targeting a distinct slice, Atlas ensures these subagents run concurrently rather than sequentially. This parallel execution significantly reduces the total time required for a full repository sweep, making it practical to maintain high code quality standards across complex SQL projects.

Running Read-Only SQL Sweeps with Atlas Explore Subagents

For a safe, read-only sweep of SQL code in 2026, Atlas's `explore` subagent type is the ideal choice. This subagent is deny-by-default, ensuring no modifications are made to critical files like `schema.sql` or `Flyway migrations` during an audit.

When conducting an audit where no changes should be made to the SQL codebase, Atlas provides the `explore` subagent type. This subagent operates under a deny-by-default policy, meaning it is strictly read-only and cannot execute commands that alter files or system state. This makes it perfectly suited for tasks such as sweeping `src/main/resources/db/migration/` for deprecated SQL syntax, identifying `sqlfluff format` violations across all `.sql` files, or checking `pgTAP` test files for common anti-patterns. A SQL developer would launch a task using `atlas task --subagent_type explore 'grep for specific SQL patterns in functions/'`. The `explore` subagent can still leverage Atlas's powerful `grep` and `glob` tools to search through SQL files, configuration files like `flyway.conf`, and test scripts. Its findings, such as a list of `CREATE FUNCTION` statements missing corresponding `pgTAP` tests, are then returned to the main session for review, without ever risking unintended modifications to the underlying SQL code.

Reviewing and Merging SQL Audit Findings with Atlas

After parallel subagents complete their SQL audits in 2026, Atlas centralizes their findings, allowing developers to merge issues into a single `todowrite` list. This streamlined process facilitates efficient review and targeted fixes for `Flyway migrations` or `pgTAP` tests.

Once all parallel subagents have completed their read-only sweeps of the SQL repository, Atlas collects their final messages. If a subagent encounters an error, Atlas surfaces the child's error text verbatim, providing clear diagnostic information. For successful audits, the subagents return their conclusions, which might include lists of `sqlfluff format` violations, identified `pgTAP` test gaps, or potential issues within `Flyway migrations`. The SQL developer then uses Atlas's `todowrite` tool to consolidate these disparate findings into a unified list of actionable items. From this consolidated list, the developer can use the `edit` tool in the main session to address each issue. Atlas computes a unified diff for every file edit, such as changes to `schema.sql` or a `V*.sql` migration file, and surfaces it for approval before writing. This robust review mechanism, combined with Atlas's ability to snapshot file changes as git patches, ensures that all modifications to the SQL codebase are intentional, transparent, and fully reversible, maintaining the integrity of the project.

Integrating SQL Toolchain with Atlas Audits and Fixes

Atlas direct integrates with the real SQL toolchain in 2026, allowing developers to audit and fix issues related to `pgTAP`, `Flyway migrations`, and `sqlfluff format`. This integration ensures that Atlas's recommendations are actionable within familiar SQL development workflows.

Atlas is designed to work hand-in-hand with the established SQL toolchain, making it an indispensable asset for SQL developers. During an audit, subagents can identify issues that directly relate to these tools. For instance, an `explore` subagent might flag `.sql` files that do not conform to `sqlfluff format` standards, or `CREATE FUNCTION` statements that lack corresponding `pgTAP` test files in the `tests/` directory. When it comes time to fix these issues, the main Atlas agent can assist. For formatting, Atlas can suggest running `sqlfluff format path/to/file.sql` and present the diff for approval. For `Flyway migrations`, Atlas can help draft new `V*.sql` migration files or refactor existing ones, ensuring they adhere to best practices. For testing, Atlas can assist in generating boilerplate for `pgTAP` tests. Every Atlas tool call is permission-gated, and changes are presented as unified diffs, giving the SQL developer full control and confidence when interacting with their `pgTAP` tests, `Flyway migrations`, and `sqlfluff format` configurations.

Step by step

01Initialize Atlas in your SQL repository, ensuring it can read your `schema.sql`, `Flyway migrations` in `src/main/resources/db/migration/`, and `pgTAP` test files in `tests/`.
02Define independent audit slices for your SQL codebase, for example, `glob('src/main/resources/functions/**/*.sql')` for stored procedures and `glob('src/main/resources/views/**/*.sql')` for views.
03Launch parallel `task` calls using `subagent_type explore` for each slice to perform read-only sweeps. For instance, `atlas task --subagent_type explore 'grep for missing pgTAP tests in functions/'` and `atlas task --subagent_type explore 'check sqlfluff format compliance in views/'`.
04Issue all `task` calls concurrently to maximize parallel execution, allowing subagents to simultaneously audit different parts of your SQL project.
05Collect each subagent's final message, which will include findings on `sqlfluff format` violations, `pgTAP` test coverage gaps, or other identified SQL code problems.
06Merge the collected findings into a single `todowrite` list within the main Atlas session, consolidating all identified issues from your `Flyway migrations` and other SQL files.
07Use the `edit` tool to address each item on the `todowrite` list, applying fixes to `.sql` files, drafting new `pgTAP` tests, or correcting `sqlfluff format` issues, reviewing the unified diff for each change.
08Approve the proposed changes, allowing Atlas to write the corrected SQL code and optionally stage or commit the updates to your version control system.

Frequently asked questions

How does Atlas audit `Flyway migrations` for best practices?: Atlas can launch `explore` subagents to sweep your `src/main/resources/db/migration/V*.sql` files, identifying patterns that violate best practices or specific organizational standards. It can check for common issues like missing transaction blocks or non-idempotent statements, returning findings to your main session.
Can Atlas check `pgTAP` test coverage for my SQL functions?: Yes, Atlas can use `grep` and `glob` with `explore` subagents to cross-reference `CREATE FUNCTION` statements in your SQL files with corresponding `pgTAP` test files in your `tests/` directory. It can report functions that appear to lack dedicated test coverage.
What SQL formatting issues can Atlas find using `sqlfluff format`?: Atlas subagents can identify any deviations from your configured `sqlfluff format` rules across your entire SQL codebase. It can flag incorrect indentation, inconsistent casing, missing semicolons, or other style violations, and the main agent can then help apply `sqlfluff format` fixes with diff review.
Is it safe for Atlas to modify my SQL code during an audit?: During an audit, Atlas primarily uses `explore` subagents which are strictly read-only and cannot modify files. Any actual code changes, such as fixing `sqlfluff format` issues or drafting new `pgTAP` tests, are performed by the main agent with explicit user approval after presenting a unified diff.
How does Atlas handle large SQL files or complex schemas?: Atlas indexes code by AST declarations using tree-sitter, providing a deep understanding of SQL structures beyond simple line windows. For large files, parallel subagents can process different sections or aspects, ensuring that even complex `schema.sql` definitions or extensive stored procedures are thoroughly audited without context window limitations.
Can Atlas integrate with my existing SQL CI/CD pipeline?: While Atlas is terminal-native, its ability to generate `git patches` and work with `git branches` means its audit findings and proposed fixes can be easily integrated into a CI/CD workflow. The output from subagents can inform automated checks, and approved changes can be committed directly.

Try Atlas in your terminal

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

Install Atlas

Related guides

Audit a Repo with Parallel Subagents in Atlas (2026 Workflow)

How to audit a repo with parallel subagents in Atlas in 2026: the task tool launches explore subagents in their own sessions, so only conclusions return to your context.

Atlas for SQL in 2026

Atlas is a terminal-native AI coding agent for SQL in 2026. Run it in a repo with your migrations or .sql files, optimize a query, and review the diff before applying.

Diagnose a Hanging or Long-Running SQL Command with Atlas in 2026

In 2026, use Atlas to quickly diagnose if your SQL scripts, `Flyway migrations`, or `pgTAP` tests are genuinely slow or silently blocked on input, getting you unstuck fast.

Add a Regression Test for a SQL Bug Fix with Atlas in 2026

Lock in SQL bug fixes with Atlas in 2026. Learn to add a regression test that fails before the fix and passes after, using pgTAP and Flyway migrations.

Run Atlas Headless in CI for SQL in 2026

Automate SQL development workflows in CI with Atlas. Learn how to run Atlas headless, integrate with pgTAP and Flyway migrations, and get machine-readable output for your SQL pipelines.

Run the pgTAP Test Suite and Triage SQL Failures with Atlas in 2026

SQL developers in 2026 use Atlas to run pgTAP test suites, triage failures with grep, and track fixes with todowrite, turning red output into prioritized tasks.

Locate Where a Behavior is Implemented in SQL with Atlas in 2026

In 2026, Atlas helps SQL developers quickly locate the exact file and symbol responsible for a behavior across Flyway migrations and .sql files, using semantic search and LSP.

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

Catch your own mistakes in uncommitted SQL diffs before they reach review or CI. Atlas helps SQL developers in 2026 self-review changes, run pgTAP tests, and format with sqlfluff.

Browse this resource hub