There is a habit of thinking AI is about the new. New projects, a fresh stack, React startups. The clearest effect I see is the opposite: in 1C configurations that are ten to fifteen years old.
(1C, for the reader outside the CIS, is the ERP and accounting platform most businesses here run on.) A production-management config no one officially maintains anymore. A trade-management build dragged across three platform versions. Custom code where half the modules were written by contractors you can no longer find. That is exactly where a neural net turns out to be more useful than on a clean new project. Sounds backwards — here is why.
Old code is code without a map
An ancient configuration is, first of all, code with no documentation. There are no comments, and the ones that exist lie, because they were written for a different version of the logic. The author is gone. Meanwhile the business runs on it every single day and asks you to “just add one field to that report.”
A developer opens a two-thousand-line module and spends the first half-day just reading. Not writing — reading, trying to work out what happens here and what must not be touched. AI takes almost all of that away. Hand it a procedure and in a minute it walks you through the logic, shows where a value comes from, warns what breaks if you touch a given variable. Not always right. But what took half a day now takes twenty minutes.
Same with someone else’s style. In an old base every contractor had their own handwriting — English names here, transliteration there, single-letter variables somewhere else. AI chews through the mess without complaint. A human is tired of it by lunch.
Where it lies with a straight face
Now the unpleasant part the excited posts tend to skip.
AI knows modern 1C syntax well and old syntax badly. It will happily suggest a construct that simply does not exist on platform 8.1. It will recommend an object method that appeared five releases after yours. And it does this with total confidence — so if you do not check, you drop code into a live system that will not compile there. Or, worse, will compile and quietly do the wrong thing.
It also does not know your specific base. It has no idea that this register is overridden and that field is used for something other than its name suggests — that is just how history worked out. It understands 1C in general; the specifics of your particular mess, no. And it will improvise convincingly.
Hence the simple rule: AI reads and explains — trust it; AI writes into a legacy config — check every line. On a new project the ratio is different. On an old one, it is this.
What it actually changes
The sum is not obvious. AI does not make a 1C developer faster at writing code — on old systems you write carefully and little. It makes you faster at understanding. And on legacy, understanding is the expensive part. Figuring out what a decade-old configuration does has always cost more than making the edit itself.
We see it in our 1C integration work: usually the hard part is not writing the exchange, it is understanding how the client’s accounting is wired and where data sits somewhere you would not expect. That is the stage where AI saves days.
So when someone tells you neural nets are only for trendy startups, show them a live legacy 1C. They pull more weight there.