The document arrived on a Tuesday. Six thousand words. Nine analytical dimensions. A risk matrix across six categories, a Howey test grid, a competitive landscape table, a token distribution breakdown. Every cell populated. Every cell empty.
Not redacted. Not withheld. Empty in the way a mausoleum is empty — structurally complete, functionally dead.
The string “N/A — insufficient information” appeared eighty-one times. I counted, because counting is what I do when prose stops doing work. There was a section labeled “Core Judgment.” It read: because no information points were provided at the first stage, it is impossible to assess the essential impact, strategic significance, or investment value of the article. Below that, two more pages of the same sentence wearing different clothes.
A schema with no inputs is not analysis. It is a form that has learned to breathe.
The absurdity is not that someone produced it. The absurdity is that it was submitted as research — with tables, with bullet points, with a disclaimer. The machinery of rigor ran for six thousand words and produced zero bits of information.
I have spent ten years reading code and filings for a living. I have never once seen a vulnerability announce itself in a grid. But I have seen something worse than a bad audit. I have seen a document so fluent in the grammar of diligence that no one checks whether it contains a single verifiable claim.
Context: How Coverage Became a Product
Crypto research industrialized around a specific incentive. Coverage became a product before accuracy did.
In 2020, while classmates flipped JPEGs, I spent 300 hours dissecting Compound Finance’s interest rate model — the jump-rate curve, the utilization kink at 80%, the way incentive accrual interacted with oracle lag during volatility spikes. I found that during rapid deleveraging, the incentive distribution and the liquidation engine pulled in opposite directions. I wrote it up as “Liquidity Cascades in Volatile Markets.” It ran nineteen pages. Mainstream crypto media rejected it. Too dry.
Two years later, the structure I described played out. Nobody cited the paper. They cited a thread that summarized it in eleven bullet points and got the mechanism wrong.
That is the trade. The market pays for legibility, not for truth. It pays for the shape of analysis: the header, the table, the emoji, the risk rating with a color. The content is a rounding error in the business model.
By 2024 the industrialization was complete. Every major outlet ran a “research arm.” Every research arm published scheduled, uniform, comparable-looking pieces. Comparability is the point. If your output looks like everyone else’s output, you can be indexed, aggregated, and sold into a data feed. Format is a distribution strategy. Content is a liability, because content can be wrong.
The 2026 search environment made this worse. Algorithms now demand “information gain” — a measurable delta over existing coverage. The industry’s response was not to find more information. It was to add more structure. Nine dimensions instead of five. Twelve risk categories instead of six. A framework with more fields looks like it contains more information, in the same way a longer menu looks like a bigger meal.
I have no data on what fraction of published crypto research has an empty evidentiary core. I have a sample. My sample says the fraction is larger than the industry’s standard deviation of honesty can absorb.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;function stake(uint256 amount) external { require(balances[msg.sender] >= amount, "insufficient"); uint256 reward = calculateReward(msg.sender); balances[msg.sender] -= amount; // state updated after external consideration payable(msg.sender).transfer(reward); balances[msg.sender] += amount; } ```
In 2021 I spent 400 hours inside Luno’s staking contract. The marketing said “community-driven, audited, secure.” The code said something else. The order of operations above is the shape of the flaw — reward calculated and paid before the balance mutation settled, opening a window where a reentrant call could draw against state that had already been credited. Fifteen pages, raw function traces, a reproducible exploit vector. Their team asked me to sit on it. “Community sentiment,” they said.
I published. Mainnet launch halted for eleven days. Token down 40%.
The code spoke, but the logic was a lie. Not the logic of the contract — the logic of the narrative wrapped around it. Two different systems, one of which could be audited.
Core: The Anatomy of an Empty Schema
Let me take the empty document apart, because the failure is structural and it repeats.
The nine dimensions were: technical, token economics, market, ecosystem position, regulatory compliance, team and governance, risk, narrative and expectations, and supply-chain transmission. Nine fields. Each requiring inputs. Each producing output regardless of whether inputs existed.
Here is the first flaw: the framework cannot distinguish between “we found nothing” and “there was nothing to find.” Both render as “N/A.” A reader scanning the output sees nine completed sections. A reader who does not read closely concludes that nine dimensions were examined. They were not examined. They were formatted.
This is the same failure mode as an unaudited contract labeled “audited.” The label is the attack surface.
The second flaw is dimensional overload. Of those nine dimensions, at most four are independently informative. Technical, token economics, team, and regulatory. The rest are derivatives. Market behavior is a function of the other four plus sentiment. Ecosystem position is a function of technical and team. Narrative is sentiment wearing a suit. Risk is the union of everything else restated as pessimism.
When you proliferate dimensions, you do not add information. You add places to hide the absence of it. A nine-field table with one non-null value looks thorough. A one-field table with one non-null value looks thin. Same information. Different impression. The table is a laundering mechanism for empty inputs.
The third flaw is that the template is symmetric. It treats every project as though it deserves equal coverage across all dimensions. But crypto is not symmetric. Most projects have exactly one interesting thing about them, and it is usually either the token structure or the code. The rest is boilerplate. A framework that demands equal depth everywhere produces equal shallowness everywhere.
I learned this the hard way. In 2022, during the FTX collapse, I pulled off social media for six months and audited three major Layer-2 fraud proof mechanisms. Not the whitepapers. The actual dispute resolution paths in the code.
Two of the three claimed decentralized fault proofs. Two of the three routed those proofs through a permissioned set of actors that the foundation controlled. The decentralization narrative existed in the documentation. It did not exist in the deployment.
They built a palace on a fault line. Fifty pages, distributed privately to institutional contacts, because I did not trust the public channel to read past the executive summary. Not one of those three projects listed “centralized fault proof” as a risk in any public framework. Not one. The template had a field for centralization risk. The field was populated with “low.”
Now the math, because the math is where narrative goes to die.
ZK Rollup proving costs are the clearest example of an industry publishing a framework that cannot see its own cost structure. A recursive proof for a meaningful batch of transactions consumes anywhere from 10 to 40 seconds of prover time on commodity hardware, or fractions of that on GPU clusters. Prover infrastructure at scale is not cheap. It is a fixed cost that scales with throughput, not with fee revenue.
At current gas prices, the marginal revenue per transaction on most rollups does not cover the amortized proving cost. Operators are subsidizing the difference from token treasuries. That is not a business. That is a runway with a countdown nobody reads aloud.
Which is why I keep saying the same thing in different words: the math in a token model is auditable; the math used to skip over it is not.
The fourth flaw of the empty schema: it has no null hypothesis. Real analysis requires a claim that could be false. “The regulatory risk is moderate” is not a claim. “The Howey test fails on the fourth prong because the token has independent utility in the validator set” is a claim — falsifiable, checkable, and useful to someone deciding where to put capital.
The empty document had a Howey test table. Four prongs, four rows, all marked “N/A.” It performed the ritual of securities analysis without conducting securities analysis. The table was not there to answer the question. It was there to indicate that someone knew the question existed.
In 2024 I did the opposite. After the spot Bitcoin ETF approvals, I spent 200 hours comparing BlackRock’s and Fidelity’s custody architectures against Ethereum’s node distribution. The finding: roughly 60% of the underlying asset control concentration sat with three traditional banking custodians. The ETFs were structurally clean. The structure was also a re-centralization of the asset class, dressed in a ticker symbol.
I published it as “The Illusion of Decentralization in Institutional ETFs.” It started an argument. The argument was the point. Arguments are made of claims. The empty document makes no argument, because it makes no claim.
Contrarian: The Bulls Are Right About One Thing
Here is where I have to be honest, because clinical detachment cuts both ways.
The people producing template-driven research are not universally stupid. Some of them are responding correctly to a market that punishes depth. If you publish a nineteen-page forensic teardown, you reach four hundred people. If you publish a nine-dimension framework with clean tables, you reach forty thousand. The incentive is real.
And the empty document was, in one narrow sense, honest. It refused to fabricate. It did not invent a bull case for a project it had no data on. It did not assign a five-star risk rating to a void. In an industry where fabricated conviction is the default product, the refusal to fabricate looks almost like integrity.
Almost.
Because there is a difference between saying “I do not know” and building a nine-chamber machine that says “I do not know” eighty-one times with the production values of a bank research desk.
The first is a sentence. The second is a business model. Trust is a variable you cannot hardcode — and the schema pretends it can. It tries to encode the appearance of diligence as a substitute for diligence. It fails, but it fails slowly, which is the worst way to fail.
The bulls will tell you frameworks impose discipline, and that discipline beats improvisation. They are partly right. A framework forces you to check the same things every time. It prevents the analyst from skipping the boring dimension because the exciting one was there. That value is real. You do not need a nine-dimension cathedral to avoid forgetting to check the token vesting.
So the concession is this: the template is not the problem. The problem is when the template becomes the deliverable. When the filled-in form is shipped as the answer instead of used as the scaffolding for one.
Data does not lie, but it does not care. And a form with no data does not even have the decency to lie. It just sits there, symmetrical and mute, absorbing attention that should have gone to the code.
Takeaway: Ask What Was Actually Verified
The document did not mislead me. I read it closely enough to see it had nothing. Most readers will not. That is the asymmetry that matters, and it is now being industrialized at a scale I could not have imagined when I was spending nights inside Luno’s staking logic.
The next wave makes this worse. I have spent the last year auditing AI-agent protocols, and in 2025 I found something that should worry everyone who consumes automated research. I audited a protocol enabling autonomous AI wallets to interact with price oracles. The oracle feed validation had no cryptographic signature. Ten thousand simulated attack vectors later, I had a working manipulation path. The protocol paused its launch. The point was not the bug. The point was the trust model. The agents were going to make decisions on unauthenticated data, and every framework upstream of them had a field marked “oracle risk: low.”
When the producers of analysis become machines, and the consumers of analysis become machines, the empty schema stops being a document and becomes a protocol. Null inputs propagate at network speed. Nobody stops to count the “N/A”s because nobody reads.
So here is the only question worth asking of any piece of crypto research, human or machine: what, specifically, was verified, by whom, and what would falsify it?
If the answer is a table, you have been handed a form. If the answer is a claim with a falsification condition, you have been handed analysis.
Everything else is typography with a disclaimer.
I still count the “N/A”s. It is a cheap habit. It has never once failed me.