- Blog
- Thought leadership
When AI can prove code correct in weeks, the specification becomes the hard part
DeepMind's AI agents formally verified Signal's messaging code in weeks. Here's why precise specifications are now the scarce skill for product teams.

When AI can prove code correct in weeks, the specification becomes the hard part.
That thought has stayed with me since this week's news from Google DeepMind. Its researchers showed AI agents formally verifying the code behind Signal's encrypted messaging. A team of five spent about four weeks on it, and the agents produced roughly 6.5 million lines of machine-checked proof. Those proofs cover forward secrecy, authentication and post-compromise security in the compiled code itself.
I don't want to overstate what was shown. But I build software for regulated industries, and this result points at something every product team should be thinking about: what happens to our work when proving code correct stops being the expensive part?
Formal methods used to be out of reach
For context, the landmark seL4 verification took around twenty person-years. That gap is the story. Formal methods have long been the gold standard that almost nobody could afford, so they've mostly lived in aerospace, chip design and a handful of research projects.
Most of us have made peace with that. We write tests, review code, run things in staging and watch the dashboards. Those habits catch a lot. What they can't do is tell you that a property holds in every case, only that it held in the cases you thought to try. Formal verification offers the stronger guarantee, and for a long time its cost kept it in a few specialist corners.
If a small team can now do in about a month what once took years, that cost starts to look very different. I wouldn't expect every startup to be shipping proofs next quarter. But the direction is worth taking seriously.
Where the humans spent their time
What stood out to me most is how the work was split. The experts decided what to prove, reviewed every specification and made the final calls. The proof checker handled the rest. The researchers say plainly that most of the human effort in verification now sits in engineering the specification.
That's a real shift in where skill matters. Writing the proof used to be the bottleneck. Now the bottleneck is writing down, precisely and completely, what the system is supposed to do. A machine can check code against a specification, but it can't tell you whether the specification describes what you actually meant.
Why this rings true in fintech
Anyone who has built software for regulated industries will recognise this. The expensive bugs in fintech usually trace back to a rule nobody wrote down properly. A few familiar examples:
- How does a refund interact with a partial settlement?
- What happens to a balance when two events land in the same millisecond?
- Which system wins when two of them disagree about the same transaction?
Teams often settle questions like these in a meeting, a chat thread or someone's head, and then the answer quietly drifts. When the code finally does something surprising, the post-mortem tends to find that everyone had a slightly different picture of "correct". That's exactly the gap a specification is meant to close, and it's a big part of how we approach fintech product work.

Precision about intent becomes the scarce skill
If proving code becomes cheap, being precise about intent becomes the scarce skill. Product, compliance and engineering teams will need to agree on what "correct" means in a form a machine can check.
You don't have to wait for these tools to reach your stack to start preparing. A few practical steps for founders and product teams:
- Write the rules down. Pick the parts of your product where a mistake costs money or trust, and list the rules they must always follow in plain language.
- Agree on them together. Product, compliance and engineering should settle those rules in the same room, rather than handing them from one team to the next.
- Hunt for the edge cases. Timing, partial failures and reversals are where vague rules tend to break first.
- Treat specifications as assets. Version them, review them and keep them close to the code, the same way you would your tests.
None of this needs AI. It simply makes your team ready for a world where checking software against a precise specification gets much cheaper, and it tends to surface misunderstandings long before they reach production.
The limits matter too
The work has clear limits. It covers one-to-one sessions only and assumes the underlying cryptography holds. That's a useful reminder that a proof is only as strong as its scope and its assumptions, which is the specification problem again in another form.
I keep wondering which of our own systems we'd struggle to specify at all, and what that says about how well we really understand them. If you're asking the same question about your product, we'd be glad to talk it through.
Frequently asked questions
What did Google DeepMind's AI agents verify?
AI agents formally verified the code behind Signal's encrypted messaging. A team of five spent about four weeks on it, and the agents produced roughly 6.5 million lines of machine-checked proof covering forward secrecy, authentication and post-compromise security in the compiled code.
Why does the specification become the hard part?
In this work the experts decided what to prove, reviewed every specification and made the final calls, while the proof checker handled the rest. The researchers say most of the human effort in verification now sits in engineering the specification.
What are the limits of the Signal verification?
It covers one-to-one sessions only and assumes the underlying cryptography holds. A proof is only as strong as its scope and assumptions.
- AI
- Formal Verification
- Fintech
- Software Engineering
- Security

