Mechanical software is over. The next kind learns, adapts and repairs itself

For fifty years we built software the way you build a machine: fixed parts, fixed answers. You configure it once, and every time the company changes, someone opens a change request.

It was the only software we knew how to build. A machine can count, but it cannot read. It can execute a rule, but it cannot learn one. So the gap between what the program did and what the company actually needed to do was filled, quietly, by people: the consultant who installs it, the export to Excel, the admin office doing by hand the work the system was supposed to do.

That era is ending. The software replacing it is not a better machine. It is closer to an organism: it learns, adapts, repairs itself, and grows together with the company it serves.

The age of machines

The ERP is mechanical thinking in its purest form. It models the factory, models the flow of materials from raw goods to finished product, and wires the path between the two. It was born for post-war industry, when production was growing before everyone’s eyes, and for that world it was a real achievement: a car factory really did need one place to plan every shift, every part, every sale.

Machines are formidable at repetition and terrible with the unexpected. So the ERP came with its own manual for the unexpected: the implementation project, the consultant, the change request, the upgrade window. Nothing in the software could change on its own, because nothing in a machine changes on its own. Every adaptation had to be done on top, from outside, by someone who invoiced for it.

Then came the patches. One piece became the CRM, another the HR system. What remained was a shell, and on top of it grew dozens of point applications: collections, payments, expenses, deadlines, closes. Anyone who works in administration knows the result: ten systems to keep alive, and data that belongs to nobody.

Organic software

Something has shifted under our feet. Software today can read, infer, generalise. It means it can finally do the thing machines never could: get better at its job without being rebuilt. It is what we call organic software, and it has three properties a machine cannot fake.

It learns. Every correction is a lesson. When the person keeping the books re-categorises an invoice, fixes a match or changes a rule, the system takes it as an instruction, not as an exception to log. The hundredth invoice from a supplier should not demand the same attention as the first. In mechanical software it always did, because the machine had no memory of you: only a table of rules someone had to maintain.

It adapts. A new company, a new bank account, a tax rule changed in March: an organism responds to its environment. Organic software reshapes itself around the company as it is today, not as it was on the day of the kickoff meeting. Growing stops being a project with a quote and fifteen months of work, and becomes something the software absorbs.

It repairs itself. Living things spend most of their energy on repairs. Administration is full of small wounds: a duplicate invoice, a bank match that slips, a balance that drifts, a category that at some point no longer adds up. Mechanical software’s answer is to stop and wait for a person. Organic software’s answer is to notice, repair what it can, and bring to a person only what really needs judgement. Month end should not be the moment you discover what silently broke on the twelfth.

Numbers are only half of accounting

Accounting is not a numerical discipline that occasionally involves documents. It is a discipline of judgement, and its evidence is text: the contract, the invoice, the email confirming the discount, the rule that says what can be reimbursed, the note explaining an accrual, the reasoning behind a choice. The ledger keeps the conclusions. The text keeps the reasons.

Mechanical software could only hold the conclusions. The text ended up in an attachments field, out of the system’s reach, and the reasons stayed in people’s heads and in email threads. That is why every review, every audit, every handover starts with an archaeological dig. Numbers separated from their reasons are why so much administrative work is done twice.

Organic software marries the two. When the same system reads the contract and records the transaction, a figure can explain itself in words and a sentence can trace back to the entries that support it. Ask why the margin changed and you get an answer about prices and supplier terms, with the invoices attached. A report becomes a note with the accounts underneath, and the audit trail starts answering the why, not just the what.

To the people who build administration

There is a myth that people in administration merely use systems, while the IT people build them. Anyone who has worked in an admin office knows it is not so. The administrator who built a consolidation spreadsheet that actually balances. The bookkeeper who carries in their head a categorisation rule finer than any rules engine. The analyst whose model became the way the company understands itself. The accountant who wrote a reconciliation macro over a weekend because the vendor had quoted six months. They are builders, and the age of machines called them end users and told them to wait for the next release.

Organic software hands them the pen. When the system takes instructions in plain language and learns from how the work is really done, shaping it stops being a technical act. It becomes simply doing your job well, and the software keeps what you taught it.

What we build

Ditta is our attempt at organic software for the administration of Italian companies. It reads invoices from the tax mailbox, transactions from the banks, documents from email. It matches, categorises and files on its own, and learns from every correction. It keeps the text next to the numbers, so every figure can explain itself. And it answers in chat, from the web or from WhatsApp, as a colleague who knows the accounts would.

Opening a second account, changing bank, adding a company: it should not take a project. Saying it should be enough.

Mechanical software is over. The next kind learns.