Opacity Was the Moat

Cryptographers settled this fight in 1883, and the rest of us spent the next 140 years ignoring them. Auguste Kerckhoffs, writing about military ciphers, laid down a rule his whole field still runs on: a system must not depend on secrecy, and you should be able to hand it to the enemy without worry. Claude Shannon said it more bluntly in 1949, design as if the enemy knows the system. The people with the most to hide concluded, before there was a computer to run any of it on, that obscurity is not security.

The rest of software never believed them, and for a long time it did not have to. Not because our black boxes were sound the way a good cipher is, but because understanding a system you did not build was so expensive that the secret held anyway. Opacity worked not because it was strong but because the siege was slow. I spent three posts in this series walking out of platforms, and every exit stalled on the same thing: a layer nobody could afford to read. That cost just collapsed, so this is the post where I admit what that does to everything I argued before. Opacity was the moat, and it is gone.

The chase this series was running

Lay the three posts end to end and the pattern is a little embarrassing once you see it. Every time I tried to leave, the thing that pinned me was not the runtime and not the license. It was a layer I could not read.

Off MuleSoft, it was the DataWeave and the undocumented flows nobody on the team could still explain. Leaving nCino, it was the configured estate no one had re-read since go-live, and re-homing it slid the problem one floor down. Shrinking the Salesforce footprint, the lock-in had already fled to the darkest room in the house, the identity and control plane the vendor was happy to keep while it gave away everything legible. Three posts, one move. The lock-in always lived wherever understanding was still too expensive to attempt.

I kept calling cheap comprehension a quiet advantage I could use on my own estate. I undersold it badly. It is not quiet, and it is not only mine.

Understanding got cheap, and I can show the receipts

When I say understanding got cheap, I do not mean it as a mood. I can point at the bill.

Start with the hardest case, a binary with no source at all. There is an open decompiler called LLM4Decompile that takes stripped x86 and hands back C, and on its own benchmark it recompiles about 87 percent of what it reads and gets roughly a fifth of it running correctly on the first try, beating both Ghidra and a general GPT-4 at the job. A fifth sounds low until you remember the alternative was a specialist and a quarter of patience. Wrap that kind of capability in an agent that also drives Ghidra and the commercial disassemblers, which is what the REA project did before it rocketed up GitHub, and a compiled vendor agent or an app pulled off a phone stops being a wall and starts being a document.

Now the case closer to my actual work, source that exists but that nobody understands. The world still runs on COBOL. By the figures that get quoted most, there were around 220 billion lines of it in service as of 2017, sitting under something like 95 percent of card swipes. For decades the only way to know what a given program did was to find the person who remembered, and those people are retiring faster than anyone is replacing them. IBM now ships a tool that reads that COBOL and drafts the Java and the explanation beside it. GitHub shipped one that modernizes Java and .NET estates in days where it used to take months. And the spec-recovery crowd turned it into a method: point the AI Unified Process or a tool like Reversa at a codebase and it walks the schema, the entry points, and the auth, then writes back the requirements and use cases a greenfield team would have drawn up front.

Two ends of one move. One recovers behavior from things that never had readable source. The other recovers intent from source no one can read anymore. I do not have to talk you into the comprehension collapse. It has benchmarks and product pages now.

Opacity was never the wall I thought it was

Here is the part that reframed the whole series for me. None of this started with AI. Opacity was never the fortress we priced it as. It was a toll booth, and the toll was comprehension.

My field has known that at the level of both craft and law for forty years. When IBM’s PC BIOS was the one thing everyone needed and no one was allowed to copy, Phoenix built a clean version in 1984 using a clean room: one team read IBM’s manual and wrote a spec, a second team who had never seen IBM’s code built to that spec, and an audit trail proved nothing was copied. The entire PC-clone industry came out of that procedure. A decade later Andrew Tridgell pointed a packet sniffer at Microsoft’s undocumented file-sharing protocol and rebuilt it into Samba, which is why your network drive still talks to Windows. Opacity stopped neither of them. It only made them slow.

The courts kept agreeing that slow was the only protection obscurity ever earned. Sega v. Accolade in 1992 held that disassembling a program to reach the functional parts you need for interoperability is fair use. Sony v. Connectix in 2000 said the same about the copies you make getting there. And in 2021 the Supreme Court let Google reimplement about 11,500 lines of Oracle’s Java API, four tenths of one percent of it, and called that fair use too. Europe did not wait to be sued; its software directive writes a right to decompile for interoperability straight into the statute.

So when I say AI ended it, I do not mean it broke a wall. I mean it paid off a toll the law had already ruled was not much of a wall. The obscurity was always rented. AI drove the rent to zero.

It cuts both ways

If this were only a story about escaping vendors I would stop here and feel good about it. It is not, and the second half is the one an architect has to sit with. The same capability that lets me finally read a vendor’s black box lets anyone read mine.

A mobile app is a binary sitting on a device its maker does not control, and someone has already looked. A 2024 study pulled apart 59 Android banking apps and found one in five shipping hard-coded cryptographic keys, four in five using broken crypto, and about half failing to verify certificates properly, with ten of the flaws confirmed exploitable. That was with ordinary tools and patient people. Hand the same work to an agent and patience stops being the limit.

It reaches past apps into the models we started treating as secret sauce. Researchers showed they could lift a piece of a production language model straight through its public API, recovering a hidden layer of two of OpenAI’s models for under twenty dollars, on top of a decade of prior work that cloned commercial models through nothing but their prediction endpoints. The fraud score you think is proprietary, the client-side check you obfuscated, the model you serve behind an API, those were all leaning on the same obscurity that just got cheap to dissolve. Kerckhoffs would have told you in 1883 they were the weakest thing you owned.

So the end of opacity is a gift and a bill at once, and both arrive for the same reason. I do not get to keep only the half I like. The honest response is to stop depending on secrecy anywhere, as a buyer or a builder, because it is no longer a place where anything is safe.

What survives

Strip obscurity out of the picture and the useful question is what is left standing. Reverse-engineer my own three exits and the same three things survive, and not one of them is made of comprehension.

Data, and the meaning stacked on it. An agent can read my schema in an afternoon. It cannot read the data I hold and it was never handed. Watch how Bloomberg keeps its customers. Not with a secret file format, which has been reverse-engineered plenty, but with a terminal that runs around thirty-two thousand dollars a seat and that almost nobody cancels, because the data and the network of people on the other end of it are not in the binary. A credit bureau’s decades of labeled outcomes, the compiled meaning of what your numbers certify, understanding the container tells an outsider nothing about contents they were never given.

Identity, and the authority to act. This is Kerckhoffs’s real point, not the slogan version. The cipher can be public; the key cannot. Reversing the lock does not hand anyone the keys, and sound authentication does not care that you understand it perfectly. In the agent era the live fight is exactly here, over who an agent is and what it is allowed to do, the control plane everyone is scrambling to own, precisely because it is the one advantage transparency cannot touch. A thing everyone understands can still be a thing only the authorized can use.

Accountability. This is the one I feel in my bones from building in a regulated world. You can reverse a vendor’s platform down to the last function, rebuild its behavior exactly, and inherit none of what you were paying for. The regulators put it in writing in their 2023 third-party risk guidance: handing work to a vendor does not diminish the institution’s own responsibility for it. So the clone runs fine, and there is still no one on the contract when a lending decision is challenged, no one to answer the examiner, no one accountable at two in the morning. What a serious institution buys from a serious vendor was never the opaque code. It was someone to be responsible, and responsibility does not decompile.

What I do with this on Monday

None of this is theoretical for me, and the practical read is better than the anxious one.

I use it, inside the lines these tools draw for themselves and the ones the courts drew decades ago. REA says plainly that it is for lawful research, interoperability, preservation, and software you are authorized to examine, which is the same boundary Sega and Sony and Google won on. You may read a thing to understand it and to interoperate. You may not clone it wholesale and resell it. Inside that line, the closed vendor binary my risk team used to take on faith becomes evidence. The exit clause I kept drawing as a slide becomes something I can run against a black box, and the brownfield method even gives it a sequence: extract the specification, put it in front of a human who knows the domain, then let the validated baseline drive the rebuild.

Then I govern it, because cheap comprehension is a privileged capability now, not a free one. An agent that can reverse almost anything inside my perimeter is a power I scope and log like any other sharp instrument, not something I let wander.

And I keep the limits honest, because this is where the judgment lives. That one-fifth of decompiled functions that ran correctly is the whole point. AI lowered the cost of understanding. It did not lower the cost of being wrong about what I understood. Reversing a behavior does not prove it correct, and it does not inherit the liability. Can rebuild is not may rebuild. The capability went to commodity; the judgment about when to point it, and whether I am allowed to, did not. That gap is the job now.

The exit clause, concluded

Four posts in, this series was never really about leaving vendors. It was about refusing to pay for the dark. The renewal quote, the managed package, the platform footprint were each charging me, in part, for the fact that I could not see inside, and that charge is being refunded whether the vendors like it or not.

So I am done paying it. I build on the things cheap comprehension cannot reach, the data I hold, the identity plane I control, the accountability I cannot outsource, and I treat everything I can now understand completely as exactly as replaceable as it has become. The one thing worth keeping out of all of it is what the implementation never was: a validated, written account of what my systems are for. That is the asset worth owning rather than renting, the same lesson as owning the harness instead of renting the model. The code is the commodity; the understanding is mine. And the vendor worth keeping, after all of it, is the one whose value survives me understanding it down to the last function. That is not a weaker place for a vendor to stand. It is the only honest one left, and it beats selling the dark.

---

This is the last post in the Exit Clause series. If you have arrived here first, start at The Exit Clause Your Architecture Is Missing, where the argument was still about a single renewal and had not yet worked out that it was about opacity itself.

I write about AI-assisted development, enterprise architecture, and building in regulated environments. If you are pointing tools like this at your own estate, or you think I am too sanguine about what a bank can safely reverse, I would like to compare notes. Find me on X @orestesgarcia or LinkedIn /in/setsero.