How does Atlas handle COBOL copybooks during a dependency upgrade?

Atlas reads your `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, including every `COPY` member it pulls in. When a dependency upgrade affects a `COPYLIB/MYCOPY.cpy` member, Atlas uses its `edit` tool to modify the relevant `PICTURE` clauses or data structures within that copybook, ensuring consistency with the new library version.

Can Atlas explain COBOL paragraphs before making changes?

Yes, Atlas can explain a `PROCEDURE DIVISION` paragraph in plain English before it touches it. This allows you to verify its understanding of `PIC` clauses, `CALL` statements, and batch logic, ensuring its proposed changes are accurate and align with your COBOL codebase's intent.

How does Atlas ensure COBOL code formatting is maintained after edits?

Atlas allows you to review the diff against the fixed-format column rules before you approve any changes. While Atlas focuses on functional fixes, you can integrate `Z Open Editor formatter` through a plugin or run it manually via `bash` after Atlas's edits to ensure formatting compliance.

What if the COBOL compiler output is very long during an upgrade?

If the output from `GnuCOBOL cobc` exceeds typical terminal limits, Atlas automatically saves it to a file. You can then use the `read` tool to inspect the full compiler output, ensuring no error messages or warnings are missed during the dependency upgrade process.

How does Atlas handle permissions for running COBOL commands?

Every Atlas tool call, including compiling with `cobc` under GnuCOBOL and running `COBOL Check` test cases, is permission-gated. Atlas will ask for your approval before executing these commands, giving you full control over what runs in your COBOL environment.

Can Atlas work with local COBOL code embeddings?

Yes, Atlas can build its code index with local Ollama embeddings, keeping your COBOL code, including `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, off third-party servers. This ensures your proprietary batch logic and `PIC` clauses remain secure and private during analysis.

How does Atlas help with reviewing COBOL changes before committing?

Atlas computes a unified diff for every file edit and surfaces it for approval before writing. It also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, providing a clear audit trail for all COBOL dependency upgrade fixes.

Upgrade a COBOL Dependency and Fix Breakage with Atlas in 2026

In 2026, COBOL developers can leverage Atlas to efficiently upgrade a dependency to a new major version, automatically repairing every compile and test failure it causes by interacting directly with `GnuCOBOL cobc` and `COBOL Check`. Atlas drives the package manager through `bash`, reads real compiler output, and fixes callsites with its `edit` tool, ensuring your `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions remain consistent and correct.

How Atlas upgrades COBOL dependencies and resolves compilation errors

Upgrading a COBOL dependency to a new major version often introduces breaking changes, but Atlas streamlines this process in 2026. It uses `bash` to run `GnuCOBOL cobc` for package management, capturing all output, even if it exceeds 100 lines, to identify compilation errors.

Atlas initiates the dependency upgrade by executing the relevant `GnuCOBOL cobc` command via its `bash` tool. For instance, if a new version of a utility library is available, Atlas would run a command like `bash -c "cobc --install-library new-utility-v2.0"`. The full output from this operation, including any warnings or errors from the package manager, is captured. If the output is extensive, exceeding typical terminal buffer limits, Atlas saves it to a file, which you can then `read` to understand the initial state of the upgrade. This ensures that Atlas has a complete picture of the changes and any immediate conflicts before proceeding to fix the codebase. Atlas then uses this output to identify which `COPY` members or `PROCEDURE DIVISION` paragraphs are affected by the new library version, preparing for targeted repairs.

Accessing COBOL library release notes for breaking changes

To accurately fix breaking changes after a COBOL dependency upgrade, Atlas fetches the library's release notes using its `webfetch` tool. This ensures that fixes align with the actual changes, preventing guesswork and saving developers significant time in 2026.

Before attempting any code modifications, Atlas uses its `webfetch` tool to retrieve the release notes or changelog for the newly upgraded COBOL library. For example, if `new-utility-v2.0` was installed, Atlas would `webfetch` its documentation to understand the specific breaking changes, deprecated features, or new API signatures. This crucial step provides context for the subsequent `edit` operations. By having the official documentation, Atlas can ensure that its proposed fixes, such as adjusting `CALL` statements or `PICTURE` clauses in `MYPROG.cbl` or `COPYLIB/MYCOPY.cpy`, correctly address the library's new requirements rather than making assumptions. This proactive approach, informed by real-world documentation, significantly improves the accuracy and efficiency of the repair process for your COBOL codebase.

How Atlas fixes COBOL compile and test failures

Atlas systematically addresses COBOL compile and test failures by leveraging `GnuCOBOL cobc` and `COBOL Check`. It iteratively builds the project, identifies errors, and uses its `edit` tool to apply precise fixes, often inspecting new signatures with `lsp` in 2026.

After fetching release notes, Atlas begins the iterative process of fixing the COBOL codebase. It first attempts to compile the project using `bash -c "cobc -x -o MYPROG MYPROG.cbl"`. Atlas reads the compiler output to identify specific errors, such as `PIC` clause mismatches or incorrect `CALL` parameters. For each error, Atlas uses its `edit` tool to modify the relevant `PROCEDURE DIVISION` or `DATA DIVISION` entries in files like `MYPROG.cbl` or `SUBPROG.cbl`. If a new signature is required, Atlas can use the `lsp` tool's `goToDefinition` operation to inspect the updated `COPY` members or `CALL` targets within the upgraded package, ensuring the `edit` is accurate. Once compilation is clean, Atlas runs the `COBOL Check` test suite with `bash -c "COBOL Check --test-suite=TESTS/MYTEST.tst"`. Any test failures are similarly analyzed, and Atlas uses `edit` to correct the logic in the `PROCEDURE DIVISION` until all tests pass. This cycle of `bash` (build/test) -> `read` (output) -> `edit` (fix) -> `lsp` (inspect) continues until the entire codebase compiles and all `COBOL Check` tests pass, ensuring a robust and functional upgrade.

Reviewing and committing COBOL code changes with Atlas

Atlas ensures safety and developer control throughout the COBOL dependency upgrade process by presenting a unified diff for every file edit. Before writing any changes, developers must approve the modifications, maintaining oversight of their `IDENTIFICATION` and `DATA` divisions in 2026.

Every modification Atlas proposes, whether to a `PROCEDURE DIVISION` in `MYPROG.cbl` or a `PICTURE` clause in `COPYLIB/MYCOPY.cpy`, is presented as a unified diff for your approval. This allows you to review the exact changes Atlas intends to make, ensuring they align with COBOL's fixed-format column rules and your project's coding standards. Atlas also snapshots file changes as `git` patches, providing a robust rollback mechanism if any approved change introduces unforeseen issues. Furthermore, Atlas connects to your `git` repository, reading branches, status, and diffs. Once you are satisfied with the fixes, Atlas can stage the changes and create a commit on your behalf, complete with a descriptive message, streamlining the version control process for your COBOL codebase. This permission-gated approach, combined with transparent diffs and `git` integration, gives you complete control over the dependency upgrade and its impact on your forty years of batch logic.

Step by step

01Run Atlas in your COBOL project directory where `MYPROG.cbl` and `COPYLIB` members reside.
02Execute `bash -c "cobc --upgrade-package my-dependency-v2.0"` to upgrade the COBOL library and capture the full output.
03Use `webfetch` to retrieve the release notes for `my-dependency-v2.0` to understand breaking changes.
04Compile your COBOL programs with `bash -c "cobc -x -o MYPROG MYPROG.cbl"` and `read` the compiler output to identify errors.
05For each identified error, use `edit` to modify the `PROCEDURE DIVISION` or `DATA DIVISION` in affected `.cbl` or `.cpy` files, using `lsp` to inspect new signatures if needed.
06Re-run `bash -c "cobc -x -o MYPROG MYPROG.cbl"` until compilation is clean.
07Execute `bash -c "COBOL Check --test-suite=TESTS/MYTEST.tst"` to run your COBOL Check tests.
08For any failing tests, use `edit` to correct the logic in the `PROCEDURE DIVISION` until all tests pass.
09Review the unified diff of all changes proposed by Atlas, ensuring adherence to fixed-format column rules.
10Approve the changes and let Atlas stage and commit the fixes to your `git` repository.

Frequently asked questions

How does Atlas handle COBOL copybooks during a dependency upgrade?: Atlas reads your `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, including every `COPY` member it pulls in. When a dependency upgrade affects a `COPYLIB/MYCOPY.cpy` member, Atlas uses its `edit` tool to modify the relevant `PICTURE` clauses or data structures within that copybook, ensuring consistency with the new library version.
Can Atlas explain COBOL paragraphs before making changes?: Yes, Atlas can explain a `PROCEDURE DIVISION` paragraph in plain English before it touches it. This allows you to verify its understanding of `PIC` clauses, `CALL` statements, and batch logic, ensuring its proposed changes are accurate and align with your COBOL codebase's intent.
How does Atlas ensure COBOL code formatting is maintained after edits?: Atlas allows you to review the diff against the fixed-format column rules before you approve any changes. While Atlas focuses on functional fixes, you can integrate `Z Open Editor formatter` through a plugin or run it manually via `bash` after Atlas's edits to ensure formatting compliance.
What if the COBOL compiler output is very long during an upgrade?: If the output from `GnuCOBOL cobc` exceeds typical terminal limits, Atlas automatically saves it to a file. You can then use the `read` tool to inspect the full compiler output, ensuring no error messages or warnings are missed during the dependency upgrade process.
How does Atlas handle permissions for running COBOL commands?: Every Atlas tool call, including compiling with `cobc` under GnuCOBOL and running `COBOL Check` test cases, is permission-gated. Atlas will ask for your approval before executing these commands, giving you full control over what runs in your COBOL environment.
Can Atlas work with local COBOL code embeddings?: Yes, Atlas can build its code index with local Ollama embeddings, keeping your COBOL code, including `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, off third-party servers. This ensures your proprietary batch logic and `PIC` clauses remain secure and private during analysis.
How does Atlas help with reviewing COBOL changes before committing?: Atlas computes a unified diff for every file edit and surfaces it for approval before writing. It also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, providing a clear audit trail for all COBOL dependency upgrade fixes.

Try Atlas in your terminal

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

Install Atlas

Related guides

Upgrade a Dependency and Fix the Breakage with Atlas (2026 Workflow)

How to upgrade a dependency and fix the breakage with Atlas in 2026: bash drives the package manager, webfetch pulls the release notes, edit fixes each compiler error.

Atlas for COBOL: Copybooks, PIC Clauses, and GnuCOBOL in 2026

Atlas is a terminal-native AI coding agent for COBOL in 2026. It reads your divisions and copybooks, explains a paragraph before touching it, and compiles with cobc under GnuCOBOL.

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

Diagnose hanging COBOL commands in 2026 with Atlas. Identify if GnuCOBOL cobc builds or COBOL Check tests are slow or blocked on input, and unblock them using Atlas's AI agent.

Self-review your working diff before committing in COBOL with Atlas (2026)

Catch your own mistakes in COBOL code before they reach a reviewer or CI. Atlas helps COBOL developers in 2026 self-review uncommitted diffs, integrating with GnuCOBOL cobc, COBOL Check, and Z Open Editor formatter.

Plan a multi-file change before editing in COBOL with Atlas in 2026

Design and review multi-file COBOL changes before modifying a single line with Atlas. Leverage GnuCOBOL cobc and COBOL Check for safe, pre-approved modifications in 2026.

Run Atlas Headless in CI for COBOL in 2026

Automate COBOL development in CI with Atlas. Run Atlas headless to get machine-readable output, integrate with GnuCOBOL cobc and COBOL Check, and ensure safe code changes.

Document a COBOL Module with a README in 2026 using Atlas

In 2026, COBOL developers use Atlas to generate accurate READMEs directly from live code. Atlas integrates with GnuCOBOL cobc and COBOL Check, ensuring documentation reflects current behavior.

Migrate a Deprecated API Across Every Callsite in COBOL with Atlas in 2026

Migrate deprecated COBOL APIs across your entire codebase with Atlas. Ensure every callsite is updated, leveraging `GnuCOBOL cobc` and `COBOL Check` for a complete, verified transition in 2026.

Browse this resource hub