I’ve been calling verbose “a language for code you can verify” for over a year. The phrase is convenient and I keep using it because it gets me to the next sentence. Honestly though it misses the thing.
The language is not where the work happens. The language is the tool that makes a particular kind of work visible. The work is upstream of the language, and the work is the part nobody wants to do.
The work is writing down what you actually meant.
In verbose this lives in a file called .intent. Numbered prose, loosely formal, written before any source code exists — the audit-able description of what the program is for, what it’s allowed to do, what it must refuse. The .verbose file (the one the compiler verifies, the one that becomes a binary) is a translation of the .intent. The compiler proves the binary doesn’t drift from the .verbose. It does not prove the .verbose is a faithful translation of the .intent. That last step is the human’s, and there’s no machine willing to take it from them.
I used to think of that gap as a flaw I’d close later. A failure of ambition. Some future verifier could parse the prose, hold the formal source against it, complain when they didn’t match. I spent real evenings sketching it.
I don’t think that anymore. The gap is the point.
Most of modern engineering points the other way
Most of modern engineering culture is about moving authorship out of the author and into something more comfortable. Frameworks. Runtimes. Compliance scanners. Cloud platforms whose marketing pages explain how they handle the hard part — encryption, retention, identity, audit trails — so you don’t have to.
This isn’t a complaint about those tools. They’re good tools, often the right tools, I use most of them every week. They reduce a real cognitive load that would otherwise crush small teams. Fine.
But every one of them carries the same trade. They lower the price of building and they raise the price of knowing what you built. The framework owns the request lifecycle, so when something goes wrong at the edges, the answer is “read the framework’s source.” The platform owns the audit trail, so when the regulator asks who decided to log this and not that, the answer is in someone else’s documentation. The author keeps their hands clean. The something-else carrying the responsibility is not the person who’ll be on the call when the regulator finally asks.
That arrangement works most of the time, because most of the time nothing goes wrong, and when something does the consequences are diffuse enough that no individual has to answer. It’s the dominant disposition in tech. The people inside it aren’t lazy or careless — they’re operating inside an industry that has, over twenty years, gotten very good at moving accountability away from the people who write code.
What verbose mechanically does is small
What verbose does, mechanically, is small. It accepts a .verbose file. It checks that every read, every external call, every byte the binary will touch is named in the source. It refuses to compile if the source claims something the AST contradicts. It emits a binary whose reachable surface is exactly what the source declared, with no room for hidden growth. That’s the local promise.
What verbose does culturally — and this took me a long time to articulate — is refuse to lift the burden. There’s no richer type system thinking for you, no runtime handling the things you forgot, no generous default assuming the obvious. If you didn’t declare the read, the program can’t read. If you didn’t declare the connection, it can’t connect. If you forgot to log a field an auditor will care about, the absence of the log is a fact anyone reading the source can see.
The author owns the intention. There is no other place for it to live. And that’s already a lot.
For someone who wants their intention to live with them, this feels like relief. For someone who has spent a career arranging for their intention to live somewhere else — in the platform, in the framework, in the compliance vendor — this is structurally an offer they have to actively accept. That offer cuts against the grain of most modern tooling.
The compliance regimes are downstream of this
A few people I’ve shown this to assume the audience is “compliance teams.” It’s not, or not exactly. Regimes like the AI Act, HIPAA, PCI-DSS, ISO 42001 are the contexts where the cultural gap becomes a legal one. They tell the author, in writing: you are responsible for what this system does. They don’t say “the framework you used is responsible.” They say you.
Verbose doesn’t invent that responsibility. The law invents it. Verbose makes it visible — an auditor reads the .intent, reads the .verbose, runs strings on the binary, the answers match. The author has nowhere to point.
Regulated industries are where the cost of pretending the responsibility lives elsewhere gets paid in fines and headlines. Elsewhere — embedded firmware, smart contracts, edge functions, code generated by AI and shipped without a careful human read — the same gap exists, just without the auditor at the door. The bug still ships. The author was just never asked to defend it.
The audience is a disposition, not a market
The audience for verbose is not an industry. It’s a disposition.
It’s the engineer who, when they hear “the framework handles this,” thinks but I’m the one who shipped it. It’s the cryptography person who has, structurally, never been allowed to delegate. It’s the embedded engineer whose binary is going on a device that won’t get a software update for ten years. It’s the AI-as-author developer who has lost the comforting fiction that the human in the loop is doing the careful read.
This isn’t the dominant disposition in software. The dominant move for the last fifteen years has been less authorship, more flow, and the products built around that move have been, by most measures, very successful. Verbose isn’t pitched against that direction. It’s pitched at the people who feel that direction in their stomach as a low-grade discomfort and never quite know what to call it.
I felt that discomfort for a long time before I started building. I built a thing that resolves it, for me, and the people who share that feeling may be the only audience the thing has. That’s already good.
Where this leaves the language itself
The language part of verbose is the easy half. Compilers are a known craft, people have been writing them for sixty years. The hard half was finding the right shape for the architectural commitment: where to put the wall between “the compiler will catch this” and “the author owes this.” Putting it too low makes the language a toy. Putting it too high turns the compiler into a bureaucracy.
The wall I settled on — compiler verifies the .verbose, human owns the .intent, the audit between them is a human reading two files — isn’t a clever line. It’s the only line that lets verbose be a tool instead of a moral apparatus. A compiler that judged the quality of your intention would be a compiler that owned your intention, which is the move I was trying to refuse in the first place.
The language is small. The intention is large. The work the language does for you is exactly the work a compiler can do. The work it does not do for you is exactly the work that has to stay with you — deciding, in writing, what the program is supposed to be.
If that sounds like the part of the job you came here to do, this is for you.