Software quality assurance has so far been based predominantly on sampling: tests check individual cases, code reviews check the understanding of individual people.A report from the environment of Google DeepMind suggests that this relationship could shift.With a system called AlphaProof Code, the cryptographic core code of the messenger Signal was, according to the company, mathematically verified for the first time – in around four weeks instead of the usual years.
What distinguishes formal verification from tests
Formal verification is a method in which mathematical means are used to prove that a program fulfils a defined specification for all possible inputs.The difference from classic testing is fundamental: a test shows that an error does not occur in a concrete case.A proof shows that a certain class of errors cannot occur at all.
The price for this has so far been high.Proofs must be formulated in specialised languages and checked by machine, and the effort often exceeds the actual programming effort many times over.This is why formal verification has traditionally been limited to very small, very critical code components – for example in aviation, chip design or indeed cryptography.
What happened in the Signal case
According to the report, AI agents based on the Gemini Carbon model wrote over six million lines of proof code.Only about one percent of this was flagged for human follow-up review.The work concentrated on the cryptographic core of Signal, that is, the part that carries the encryption of communication.
What is remarkable here is less the volume of code than the ratio: the machine takes over the laborious, formally rigorous part, while humans concentrate on the places where the proof is uncertain or the specification is questionable.It is precisely this ratio that decides whether a method moves from the niche into the mainstream.
Critical infrastructures such as power grids or medical devices are named as the next fields of application.These are areas in which malfunction has immediate physical consequences and in which approval procedures anyway demand robust evidence.
What the result does not show
A proof is always valid only relative to a specification.If the specification is formulated incorrectly or incompletely, the proof is correct and the result is still not what was intended.The question of what a system is actually supposed to do remains a human and domain-specific task – and it becomes more rather than less important with powerful proof tools.
Likewise, a cryptography core cannot be used to draw conclusions about arbitrary application software.Cryptographic code is mathematically clearly describable, manageable in scope and stable in its requirements.A business application with interfaces, user interface, permission logic and constantly changing business rules is an entirely different subject.Transferability is an open question, not a promise already fulfilled.
The direction is nevertheless relevant
For practice, the actual message is a different one: AI systems are increasingly being used not only to generate code but to check code.From the perspective of quality assurance, this is the more interesting development.Generated code initially increases the amount of what must be checked.Tools that take over checking effort work in the opposite direction.
It is foreseeable that this approach will first take effect where clearly delineated properties can be checked:
- Security-relevant components such as authentication, signature and encryption routines or access checks
- Data-processing core logic, such as calculations in billing, tariffing or document checking
- Interface contracts in which input and output formats can be described unambiguously
- Migration logic in which it is to be demonstrated that the old and new versions calculate the same
What can already be prepared in projects now
Regardless of when such methods become generally available, projects benefit from preparatory work that is worthwhile anyway:
- Formulate requirements precisely. The more clearly it is described which property should apply, the more readily it can later be checked by machine – and the less room for interpretation remains in everyday work.
- Isolate critical logic. If security- or business-critical calculations are located in clearly delimited modules, they can be checked more rigorously in a targeted way than the surface around them.
- Treat testability as an architectural criterion. Interwoven responsibilities and hidden side effects make every form of verification more difficult, whether by humans, tests or tools.
- Redistribute review capacity. If routine checks increasingly run automatically, the remaining human attention should go where domain decisions are made.
Trust becomes demonstrable
In the medium term, this also shifts the argumentation towards clients, auditors and supervisory authorities.Today the statement is usually: it was developed, tested and reviewed carefully.In future, in some areas it could be possible to state that a certain property demonstrably applies.This is a qualitative difference, particularly in regulated industries.
For web and software projects, this means concretely: quality assurance remains necessary, but its focus shifts from fault-finding towards the clean description of what is correct.
Anyone who invests today in precise requirements, clearly defined architecture and traceable acceptance criteria is laying the foundation for being able to use such verification methods at all later on. And until then, the same measures already pay off by noticeably easing the burden on reviews, tests and maintenance.