For organizations running critical COBOL, Assembler, PL/I or Natural applications, the question of who writes the code has changed. Senior developers are retiring, contractors and outsourcing partners carry more of the load, and AI coding assistants now generate and modify mainframe code at a pace no team could match a few years ago.

What has not changed is the requirement that code promoted to production meet organizational standards, not introduce security risk, and be maintainable by whoever or whatever inherits it next. In regulated industries, the organization must also be able to prove the above.

Code vetting processes are changing with the times. The most effective approach today combines a predictable, deterministic application of code checks based on a library of rules that pass the same verdict every time, with AI, which brings cost-effective judgment, explanation, and remediation to edge cases.

More Change, From More Authors

Traditional code review assumed a small, stable group of developers who knew the house standards. Peer review and a handful of senior reviewers could keep up. Outsourcing and AI-coding have changed the rules. Contractors bring their own habits with each new author another source of variation. AI assistants produce change at a dramatically accelerated pace. They also make different mistakes than do people. They may add needless complexity, or produce different output for the same prompt on different days.

Manual review cannot scale to keep pace. An automated gate is the only form of review and remediation that can accommodate the increased variability and rate of change.

The Limits of AI Review

Why not have AI simply review the code it writes? AI can read a program, explain what it does, and suggest improvements in plain language. For judgment calls, it does what a fixed rule cannot.

But AI review is probabilistic: the same code can get a different assessment on a different run, or after a model upgrade. Its reasoning can be hard to trace back to a written standard. As a result, every proposal must be cross-checked. Finally, many organizations cannot expose production source code to an external AI service at all. While useful, AI is not a referee whose call can be cited in an audit.

The Limits of Rules Alone

Static analysis rules check the same condition the same way every time. Results are repeatable, traceable to a written standard, and inexpensive to run across an entire application portfolio.

Rules, however, lack judgement. A rule can flag code that may pose a security risk, but it typically cannot decide whether that code translates into a real exposure. Using rules to scan code for potential security risks can generate very long lists that someone must work through in context for each flagged finding. This is expensive in terms of time and effort involved. On its own, a rules engine often produces a backlog of flags that never get resolved.

Detect, Triage, Explain and Fix, Re-Verify

The answer to today’s challenge is a combined workflow that assigns each step to the tool best suited to it:

  1. Detect. A deterministic rules engine checks every program against the organization’s standards, complexity limits and security-risk rules. Every author, whether developer, contractor or AI, is measured by the same rules and limits.
  2. Triage. A reviewer with the assistance of AI examines each flag and decides whether it is a real exposure. The decision is recorded.
  3. Explain and fix. For real issues, AI explains the problem in plain language and proposes a fix. A developer accepts, adjusts or rejects it.
  4. Re-verify. The rules engine checks the changed code again before promotion. Nothing moves forward on AI’s word alone.

The Right Fixer for Every Finding

Not every finding needs AI. A rules-based scan of large code portfolios will discover very large numbers of mechanical findings in layout, alignment and similar conventions.

Fixed transformation rules, designed to leave program behavior unchanged, can correct these in a single batch run across whole application systems. Because the same input always gets the same fix, a rule can be tested once and trusted everywhere, and its changes are far quicker to approve than AI-proposed edits.

Rule-based fixes handle mechanical findings. AI plus a developer handles judgment calls. A reviewer records policy decisions.

Context Before Change

AI assistants typically see one program at a time. Mainframe applications are not built that way.

Programs call other programs and share copybooks, and a change in one place can ripple across many.

A cross-reference map of the portfolio shows every program and copybook a change touches before anyone edits a line. It gives AI the context it needs to make effective, safe change proposals.

Proving Test Coverage

Static analysis grades code as written. It cannot show whether testing actually exercised the changed logic.

Branch-level test coverage closes that gap. Branch coverage checks every path of every decision, because a line can execute while one side of its IF never does.

Static grading plus branch coverage proves that code is sound, and that it has been thoroughly tested.

The Economics

The AI cost of reviewing or fixing a single finding is usually small. The larger costs sit elsewhere, and the combined approach addresses them:

  • Manual Review time is the big expense. Every AI suggestion is a proposal someone must read and approve. Moving mechanical findings to rule-based fixes removes much of that review load and reserves expert attention for the findings that need it.
  • Remediation can be budgeted. When findings are tied to estimated remediation hours and cost, cleanup becomes a line item that can be planned and justified. Running the estimate before and after automated fixes shows the return in hours removed.
  • Fewer late surprises. When developers are gated by the same rules in their own tools that the release gate enforces, problems are fixed before commit. Reviews are shorter and fewer builds are rejected.

Operational Benefits

A deterministic gate gives release managers a clear pass or fail. Results do not drift across runs or when an AI model is upgraded.

Analysis runs on the organization’s own systems, so source never has to leave the environment.

Portfolio-side quality grades show which applications need attention first.

Audit Benefits

Auditors ask a simple question: how do you know? A purely AI-driven process cannot answer this question, because the same code may not get the same verdict twice.

A combined approach gives answers supported by evidence. Every program has a repeatable grade against written standards. Every flagged security risk is traced to a recorded decision facilitated by AI-augmented analysis and remediation. Every fix is re-verified before promotion. This approach efficiently and effectively supports the expectations of internal audit and regulatory review.

Over time, as AI tools are able follow standards more reliably, the gate’s value shifts from catching errors to providing assurance, much like a financial audit of books that are usually correct.

Putting the Approach into Practice

AI is the best reviewer where judgment, explanation and case-specific remediation are needed. The deterministic engine is the referee whose call stands up in an audit. Organizations get the most from both when as a team each does the job it is suited for.

Log-On Code Auditor provides that referee for mainframe code. It applies over 1,000 selectable, tunable rules to COBOL and PL/I programs and whole application systems. It grades every program, flags code that may pose a security risk, estimates remediation hours and cost through Impact Analysis, and enforces pass/fail quality gates, all on the organization’s own systems. Code Auditor AutoFix applies rule-based fixes to mechanical findings, and Code Auditor Map cross-references the estate so every change is understood before it is made. Log-On Code Coverage completes the picture with branch-level test coverage for COBOL and PL/I.

To learn more, visit log-on.com or contact ask@log-on.com.