Lint Before You Fund: Why Compiled Knowledge Kills AI Projects Better Than It Chooses Them

Finding the best project is open search. Assessing the one in front of you is collision detection against every failure shape you have compiled. Package the teardown as a pre-mortem — and ship a falsifiable failure sequence, not a vague risk register.

Scott Farrell · LeverageAI · Search-space asymmetry as a commercial product

If you have spent years compressing hard-won project experience into named frameworks, you have probably noticed something slightly embarrassing.

Your knowledge system is ferocious at shredding a proposed AI project. Hand it a written brief, a vendor deck, a business case that already has budget smell on it, and the collisions arrive almost immediately: horse optimisation, stacked boss-fight constraints, live-path AI with no review surface, a single collapsed verdict nobody can inspect, governance postponed until after the demo has already sold the fantasy. The teardown feels unfair. Sometimes it feels almost superhuman.

Then someone asks the other question — what should we do instead? — and the same system becomes ordinary. Helpful, yes. Directionally interesting, sometimes. But not the same weapon.

Most people treat that asymmetry as incompleteness. The corpus is “not mature enough.” The retrieval is “not smart enough.” The missing piece must be a better opportunity-generation engine.

That diagnosis is wrong in an important way. The asymmetry is not primarily a content gap. It is a search-space collapse. Judging the proposal in front of you is a different computational task from inventing the globally best project — and the first task is the one a compiled framework corpus is structurally built to win.

A compiled knowledge base is asymmetrically better at demolishing a proposed project than at finding the optimal one — because assessing one concrete object collapses the search space to a single collision surface against every failure shape you have already paid to learn.

That is not a limitation to apologise for. It is a sellable entry product. This piece is about the mechanism, the lint pass, the failure sequence as a falsifiable prediction, and the AI Project Pre-Mortem as the commercial packaging of the half that already works.

Open search versus collision detection

To find the best AI opportunity for an organisation, a system must search an open space:

• every possible problem the firm might care about;
• every possible workflow that could be recomposed;
• every possible placement of humans, software and models;
• every possible buyer, economic consequence and political path.

That is combinatorial. It needs sensing, domain labels, live problem signals, and time. Weakness here is not surprising. Open search is hard for humans too; a knowledge base does not magically make it cheap.

Now put one proposed project on the table. Not “AI for the business.” A brief. A preferred solution. An architecture sketch. Expected benefits. Governance assumptions written by people who have already half-committed.

The search space has collapsed to one concrete object.

You are no longer hunting across possibility. You are asking whether this object collides with compiled priors: known failure modes, deployment lanes that work, boss-fight geometries that do not, authority patterns that survive contact with reality, and the sequences in which fragile AI projects actually degrade. The corpus is not inventing a world. It is acting as a collision sensor.

That is why the teardown feels so much stronger than the recommendation. You have changed the problem class. Recommendation remains closer to open search. Critique becomes static analysis.

There is a parent body of work on turning compiled experience into a simulation substrate — running frameworks and joined project history against a live plan to ask what fails first.¹ This article does not re-teach that substrate. It extends the commercial implication: the high-leverage entry offer is not “tell us the best project.” It is “run this project through the lint.”

Static analysis for AI projects

Software engineers already understand the move. In 1978, Stephen C. Johnson’s lint at Bell Labs performed static analysis on C programs — flagging suspicious constructs a compiler would cheerfully accept.² The verb stuck. You lint before you ship, not because lint invents the product, but because it cheaply finds structural defects in a proposed artefact.

An AI project brief is also a proposed artefact. Once it is written, it can be linted against a framework corpus the way a codebase is linted against rules. The point is not theatrical certainty. The point is named defects and sequences you can hold up later.

A practical lint checklist for AI initiatives looks like this:

1. Horse optimisation? Is the proposal accelerating an existing workflow that may itself be the problem — “help customers use our hard-to-use system” rather than changing the commercial interface?
2. Boss-fight stacking? Does it combine two or more hard constraints at once — real-time latency, high blast radius, weak evidence, customer-facing authority, thin unit economics — so mitigations fight each other?
3. Live-path AI unnecessarily? Is the model forced onto a sub-second conversational path when the valuable cognition could run in batch with receipts?
4. Single collapsed verdict? Does the system emit one giant answer — “here is the correct scope” — that cannot be partially accepted, corrected, or owned line by line?
5. No reviewable artefact? Is there an authority surface: evidence, uncertainty, disposition, and a clear effect of approval?
6. Authority gap? Who owns the consequence if the model is wrong — and is that person given a decision surface or a magic button?
7. Governance arriving late? Are controls scheduled after the demo has already sold automation rates that only exist in happy-path scripts?
8. Human advantage being erased? Is the design trying to replace the part of the work where human judgment is still the economic product?
9. Compounding asset? Does the project leave reusable structure — compiled knowledge, tested boundaries, receipts — or only a one-off prompt theatre?
10. Failure sequence? Not “risks.” What fails first, and in what order?

That last question is the one that upgrades lint from a scolding into an instrument. A risk register can be infinite. A failure sequence can be scored.

Worked lint pass: “AI support for our parts catalogue”

Consider a realistic brief drawn from a pattern that keeps recurring with industrial and e-commerce operators who sell many SKUs.

Proposed project (as the client frames it): Our online catalogue is the system of record for ordering. Customers struggle to find the right part. Support volume is high. We want an AI assistant — on the website and for the service desk — that helps customers navigate the catalogue faster, answers part questions in real time, and reduces handle time. Success means fewer tickets and higher online conversion. Governance will be “added once the pilot proves value.”

This is not a cartoon. It is the default shape of “where can AI help?” asked inside an incumbent process map. The organisation inventories current friction and nominates acceleration. That frame is almost designed to produce horses.

Lint results

None of this requires omniscience about the firm’s entire opportunity landscape. It requires one proposal and a set of compiled priors. That is the point of the asymmetry.

The valuable output is a failure sequence

Here is the distinction that separates a useful pre-mortem from a consultant’s risk slide.

The weak output:

“This project will fail.”

That claim is hard to audit in advance and easy to litigate afterward. Everyone invents a private story.

The strong output is a shape-of-failure prediction — a sequence you can hold against reality later:³

1. The demo works.
   Happy-path scripts hide empty catalogue fields, identity edge cases,
   and the lag of real retrieval.

2. Latency removes verification.
   To feel conversational, the system drops multi-step matching,
   evidence assembly, and second-pass challenge.

3. Prompting compensates.
   The team adds instructions, examples, and tool calls that paper over
   structural gaps without changing the interface contract.

4. Governance arrives late and consumes the saving.
   Review, escalation, logging, and duty-of-care requirements appear
   after the business case assumed high automation rates.

5. Scope contracts into batch preparation + human review.
   The viable product becomes intake, draft matching, and specialist
   disposition — useful, narrower, not the original story of a
   real-time catalogue brain.

Read that carefully. It is not a diagnosis of a project that has already died. It is a falsifiable prediction about a class of project that has not yet been funded — or has only just been. In twelve months you can score each step. Parts will match. Parts will not. The framework earns or loses credibility in public.

That is why shape beats outcome prophecy. You can run a Kill / Fix / Double-Down review against a shape. You cannot run one against a vibe.⁴

External evidence does not need to overclaim a single universal failure rate to support the commercial logic. RAND’s interviews with experienced practitioners keep returning to leadership and problem-framing failures — wrong problem, wrong metrics, technology chase, data and infrastructure gaps — more than “the model was not smart enough.”⁵ Gartner’s 2025 forecast that more than forty percent of agentic AI projects will be canceled by the end of 2027, citing cost, unclear value, and inadequate risk controls, is a market-level rhyme with sequences in which governance and value clarity arrive late.⁶ The point is not the exact percentage on any one press release. The point is that pre-funding structural lint is economically rational in a market that keeps paying for demos that cannot survive production counterplay.

The AI Project Pre-Mortem as entry product

Once you see the asymmetry, packaging becomes straightforward. You do not need to discover the perfect project to create value. You need a bounded contract that takes a proposed initiative and returns a structured teardown.

The A$500,000 framing in the source material is a shape-statement, not a published case series: if a pre-mortem prevents a single mid-size AI programme from entering a year of wrong-path spend, the diagnostic pays for itself many times over. Treat that as the economic logic of the product, not as a claimed track record. The honesty rule is the same as the proof rule for the worked example above — n=1 shapes, not invented portfolios.

Disposition language matters. Kill when continuation is not justified. Fix when the underlying opportunity may be real but a remediable constraint is wrong — wrong lane, wrong interface, collapsed verdict, missing artefact. Double-Down only when the proposal already sits in a viable geometry and evidence supports concentrated commitment. The kill registry — why rejected, how close, what would reopen it — turns stopped work into reusable learning rather than political shame.

What “Fix” often looks like

Return to the parts-catalogue brief. A Fix disposition is not “add a better system prompt.” It is a boundary redesign that changes the physics of the work.

BEFORE (horse frame)
Customer must navigate our catalogue
        ↓
Real-time AI coach on the website
        ↓
Support still absorbs exceptions
        ↓
Governance bolted on after pilot

AFTER (recomposition frame)
Customer submits PO / BOM / photo / free text
        ↓
Deterministic extraction of lines and known IDs
        ↓
Candidate retrieval from the catalogue
        ↓
AI proposes matches with evidence and uncertainty
        ↓
Human reviews high-consequence substitutions
        ↓
Approved lines compile into an order

The existing e-commerce platform can remain the transaction engine. It simply stops being the cognitive burden placed on the customer. That is not “better customer support for the website.” It is a different commercial interface: the customer no longer learns how to order from you; your system learns what the customer is trying to order.

A second recurring brief — complex RFQs and estimating for specialised field work, where the organisation asks which parts of the existing document process AI can automate — fails the same lint for the same reason. Faster document writing inside a broken scope-forming process is still horse optimisation. The recomposed object is an evidence-backed scope-forming system: atomise defects and constraints, match to remediation classes, propose line items with risks and information requests, engineer disposition, compile to RFQ/SOW. Again, the pre-mortem does not need to invent the firm’s entire roadmap. It needs to refuse the wrong project class with a sequence and a redesigned boundary.

Positive contrast: projects that survive the lint

Not every proposal fails. The useful contrast is a shape that already lives in the lane where AI is strong.

FDE BI — the forward-deployed data and BI workbench used as a specimen in related work — is almost a catalogue of lint passes cleared: internal rather than live customer-facing; batch and queued rather than conversational; read-only at the source; artefact-producing; evidence-bearing; reversible; human-reviewed; operating on an engagement latency budget measured in days, not two hundred milliseconds. One line of deep semantic work taking minutes is irrelevant when the relevant clock is the two-week engagement, not the browser interaction.

Batch the brain. Ship the artefacts. Govern like software.

That positive shape is not the product of this article. It is the existence proof that the lint is not pure negation. When a proposal already has reviewable line items, bounded authority, and time to think, the disposition may be Fix or Double-Down rather than Kill. The pre-mortem still earns its fee by making that judgment explicit and receipt-backed.

What this piece is not selling

Clarity about neighbours keeps the axis clean.

Not the full readiness-review product. A fixed-price evidence engagement that orients both parties before a statement of work is a larger commercial protocol — buy certainty first, compile the SOW as a receipt. That product is argued elsewhere; if you need the readiness story, start there rather than stretching a pre-mortem into a fake estate audit.⁷

Not a re-teaching of simulation substrate mechanics. How a compiled corpus becomes fuel for shape-of-failure simulation — landfill versus fuel versus refinery — is owned by the parent work on second-hand time travel. Cite it; do not rebuild it here.¹

Not the institutional linter at organisational scale. Continuous static analysis over policies, controls and assurance is a sibling discipline for the codified institution. The AI Project Pre-Mortem is the same intellectual family — lint the artefact before you fund it — applied to one initiative, not to the whole governance estate.

Not a claim that opportunity discovery is worthless. Open search still matters. Perturbation, sensing, and candidate generation are hard for reasons this article does not pretend to dissolve. The commercial error is refusing to sell the strong half until the weak half is solved.

How to run this on Monday

You do not need a perfect corpus to begin. You need enough named failure shapes to collide with, and the discipline to output a sequence rather than a mood.

1. Take one real proposal that already has political momentum.
2. Run the lint checklist without trying to invent a better company strategy in the same sitting.
3. Write the failure sequence as five ordered steps a skeptic could score later.
4. Force a disposition: Kill, Fix, or Double-Down — with reconsideration conditions if Kill.
5. If Fix, name one redesigned boundary, not ten feature ideas.
6. Stop. Do not smuggle open search into the same deliverable and dilute the product.

If you prompt an AI against accumulated judgment — frameworks, past post-mortems, lane rules, rejection records — you are already doing a soft version of this. The upgrade is contractual: treat the teardown as the deliverable, price it as uncertainty reduction on a single object, and refuse to let the client redefine success as “also invent our roadmap.”

Practitioners who have watched a compiled framework corpus tear a project to shreds already know the feeling. The commercial mistake is apologising for the half that works. The recommendation half is a different search problem. The kill half is collision detection. Collision detection is productisable.

The same asymmetry shows up when the “corpus” is not a formal system at all but a disciplined prompt against accumulated judgment: past post-mortems, lane rules, rejection notes, and hard-won maxims you refuse to re-derive every quarter. Paste a vendor proposal into that context and ask for collisions, not inspiration. You will still get a better kill pass than an open-ended “what should we build?” session — because you collapsed the search space on purpose. Formal compilation makes the lint reproducible and citable. The underlying geometry does not require a particular product brand. It requires priors dense enough to collide with, and an output contract that demands a sequence and a disposition.

Lint before you fund. Ship a failure sequence, not a risk poem. Preventing one wrong project is a complete outcome.

That is the takeaway you should be able to execute, not merely admire: run the next proposed AI initiative through a static-analysis pass against your compiled knowledge — horse, boss-fight, live path, collapsed verdict, missing artefact, late governance — and return a falsifiable shape of failure with a Kill / Fix / Double-Down disposition. The asymmetry was never your shame. It was the front door.