An AI rewrites a module in your PowerBuilder, Delphi, VB6, or VBA application. It compiles, the forms still work, and it writes the code the modern way, not the way this app has been built for twenty years. Enterprise desktop and line-of-business systems are full of conventions that live only in the code, and the developers who wrote them have moved on.
Step one · the map
doloop reads your call structure, the function and procedure calls and the unit and object references, and makes the app navigable. You get the load-bearing modules and shared units a change ripples out from, the data access layer, a triage list of code the static call graph never reaches, and the strata across the app's versions. It shows where the system is structured, not what it computes. The scan is free, and it reads none of your business logic.
A unit reached only through dynamic dispatch or an event binding shows up as a lead to review, not as a verdict that the code is dead.
Step two · the gate
Once the app is navigable, doloop gates the changes. Where your code keeps a convention, it infers that convention from your own code and flags an AI rewrite that breaks it, deterministically, with the rule, the line, and the rate behind every flag. The first scan measures, on your own code, where your conventions run tight enough for the gate to enforce, and runs the gate there.
The method reads a system's own conventions in any language. It works on code as different as modern Python and COBOL systems up to forty years old, where 525 of 525 held-out programs passed leave-one-out, verified three independent ways. Your application is next, read on your own code.
Your source never leaves your machine. Bring your own model. Request your first scan →
Routes you to a real doloop page, asks when your question is ambiguous, or tells you when there is no answer. No model runs on the answer path, so it cannot invent one.