The Deck Became Software: A 24-Hour Consulting Product with 45 Years of Source

FDE BI proves the executable-worldview claim in production. Twenty-four hours of build time compiled forty-five years of accumulated capability — because the frameworks were upstream source that generated the product, not post-hoc explanations. The strongest evidence of human authorship is the two corrections where working software was overruled for solving the wrong problem.

Scott Farrell · LeverageAI · August 2026 · Full case-study specimen (n=1)

Here is the question this piece answers, and the only one it is allowed to answer cleanly:

How does one person ship a governed, deployed consulting product in a day — and what did the AI actually contribute versus the human?

After you finish, you should be able to do two things without me in the room. First: distinguish compile-time from source — AI supplied Power BI's nouns, APIs, file formats and tools; I supplied the evaluation function. Second: name what a compiled career changes about project speed — not "typing faster," but starting at a different altitude because judgment, tests, rejected paths and commercial instinct are already callable.

This is explicitly n=1. One build. One specimen. Synthetic retained test runs. Live deployment, real architecture, honest limits. I will not pretend a portfolio study. The Tesla Service AI case study already showed that one instrumented mess can map a whole claim if you refuse both only-gloom and only-hype.¹ This piece sits on that shelf: production evidence for doctrines already written elsewhere, not a new framework mint.

The 24 hours were compile time

On 29 July 2026 the repository began as a factory for a disposable Windows Power BI environment. By 30–31 July it had also become an evidence and architecture-reconciliation workbench for a consulting engagement. The live application sits at fde-bi.leverageai.com.au; its health endpoint answers cleanly. That is the calendar fact.

The tempting story is that AI let someone who "didn't know Power BI yesterday" become a Power BI developer overnight. That story is false in a precise way.

I did not learn Power BI from scratch and somehow become a conventional platform specialist in one day. Power BI was the final local vocabulary needed by a system of thought that was already substantially assembled. I already knew how to recognise a commercially important problem, read a CFO as buyer, treat spreadsheets as undocumented applications, map baseline architecture against target architecture, separate observed fact from inferred conclusion, allocate probabilistic judgment versus deterministic control, manufacture a disposable technical environment, define evidence and acceptance tests, convert findings into scope, and package the result as something a consultancy could sell more than once.

AI filled in Power BI's nouns, APIs, file formats and tools. I supplied the evaluation function.

That distinction is the whole article in one sentence. Everything else is receipts.

Compounded Execution Capital already names the asset: experience converted from tenure and memory into a callable substrate that conditions live discovery and construction.² Orientation Capital already explains why the speed is misleading: you do not save a few hours of background paragraphs; you prepay the understanding so work begins oriented rather than cold. The prompt becomes a pointer into a compiled self.³ Executable Worldview already states the closed composition: archive as source, wiki as cognitive intermediate representation, agent as runtime, authority independent of the model, write-back from paths and outcomes.⁴

FDE BI is those claims running under load — not restated as theory, but left as working software you can health-check.

When I was building with the coding agent, it had access to the IP wiki and to prior source code. I did not have to repeat all the little things I had learned over time. They were self-evident to the agent. That is not better memory. That is inherited orientation.

There is even a historical rhyme. In 2009 I reused prior code to produce a WORM, CRC-checked, deduplicating Java attachment archiver in about four hours, and wrote: "If you are focussed you can pull off a lot of coding fast." The ability to make large interdisciplinary leaps quickly is not new. What is new is that the reusable knowledge is compiled, frontier cognition is available on demand, implementation is cheap, and agents can inherit prior work directly. The old version was an unusually productive person working from memory and prior code. The new version is that person plus a compiled self plus a software factory.

Milhouse, in The Simpsons, has a line about everything coming up Milhouse. For a stretch it felt like everything's coming up Scott: roughly forty-five years of capability — computers since childhood, accounting degree, systems work, architecture, running a consultancy, sales, six months of intensive AI research — landing on one pin-point. The line is fun. The mechanism is the point.

What the product actually is

FDE BI is not "AI that builds Power BI reports." It is an evidence-backed consulting transaction compiler:

observed estate
  → declared target (workbooks as specification)
  → interpreted comparison
  → human decisions
  → readiness position
  → scoped next engagement

Two centres of gravity share one doctrine: generated environments and generated knowledge are replaceable; locked inputs, evidence, prompts, decisions, tests and receipts are the assets.

Centre one — the VM as test instrument. Host scripts build a disposable Windows guest for Power BI discovery, pin external inputs in a versions lock file, and tear down exact targets rather than accepting broad destruction. The verified 29 July path used Microsoft's expired WinDev2407Eval appliance as an integration probe — not as the long-term base — and proved Power BI Desktop, Modeling MCP, Desktop Bridge, validation tools, SQL fixtures, Python and coding CLIs end to end. Discovery runs on two independent tracks: a deterministic inventory and DAX harness, and a project-scoped agent with a north-star brief. They are retained separately rather than forced into consensus.

Centre two — the engagement workbench. A FastAPI/Jinja application keeps three substrates: content-addressed bronze for exact workbooks, MCP reports, screenshots and decision receipts; SQLite for identities, queues, mappings and operational state; a generated gold wiki for navigable meaning that routes back to evidence. The core distinctions — observed current, declared target, interpreted target, agreed target, scoped transition — stop an audit miss, a model inference or a synthetic fixture decision from silently becoming client truth.

The central object on the deployed surface is not "AI found forty-five things." It is:

45 findings still need your call.

The human decision is the organising product. The report is downstream of that surface. That is Discussed Is Not Deployed made operational as application architecture rather than a status essay.⁵

Microsoft's own Power BI and Fabric tooling treats metadata scanning as a governance mechanism for inventorying items, lineage, tables, measures and sources without treating ordinary row-level business data as the primary product.⁶ FDE BI sits in that family of moves — read the estate, build a safe representation, force human disposition of what remains material — but with an engagement compiler around it: findings become decisions, decisions become scope, scope stays blocked until material findings are disposed.

The doctrine became organs

The important claim is not that the code "implements best practices." It is that prior frameworks generated product organs. They were upstream source, not labels applied after a lucky demo.

Read the table as a compiler map, not a marketing checklist. Prompt Is Source says the durable asset is the retained package above generated code — intent, design, prompts, tests, starting state, decisions regeneration must not re-guess.⁷ The VM factory is that doctrine made mechanical: tear down, rebuild, pin versions, improve the prompt until the agent stops fumbling. Keep the Bronze says deletion is the irreversible act; gold can be regenerated over territory that still exists.⁸ Hidden Gates says that when a capable worker sees the exact answer key, the measure becomes a target.⁹ That sentence is why the spreadsheet test had to be rebuilt.

Product of One says the product is the proposal only if the evidence package is part of the product — live endpoints, bills, operated transactions, confessions of what is not verified.¹⁰ FDE BI's deployment receipts and test ledger are not vanity. They are the offer's chain of custody.

Authorship is the two corrections

Not typing the code does not reduce authorship. In this build the strongest authorship evidence is where I overruled plausible, working implementations.

Correction one: the wiki is a brain, not a report

Before. The first implementation deterministically rendered a wiki from SQLite and used the LLM only for optional proposals. Functional. Polished enough to demo. Wrong problem.

The intended design was: observation and audit data in → LLM read → ingest to wiki. The wiki was meant to be the engagement's brain and scribe — where significance is judged, edges are typed, questions are raised — not a pretty report written after the real decisions had already been made by SQL.

After. A junior model receives a bounded map plus gold, silver and bronze readers. It has no write terminal. It must inspect and hand off an evidence bundle through request_review. Persuasive prose is stripped at the phase boundary; the tool trail remains. A senior continues that trail, may inspect further, and alone emits one complete save_review with pages, claims, typed edges and review flags. Deterministic code validates authority classes, evidence eligibility, edge endpoints and structure, stages files, applies relational state in a transaction and atomically promotes the build.

A retained live run produced ten pages, eighteen typed edges and seven review flags after forty-one junior tool calls. The important output is not the page count. It is the allocation: models own significance, synthesis and questions; code owns evidence identity, access boundaries, validation, caching and mutation.

Correction two: stop giving away the answer

Before. The original harness parsed a known spreadsheet contract and compared its derived target rows directly with SQLite. Useful as a parser regression test. Useless as proof that a model can understand an unfamiliar physical workbook and reconcile it with discovered Power BI knowledge. It was an answer key wearing a lab coat.

After. The path starts from XLSX bytes with no precomputed target breakdown. The XLSX.evidence v2 extractor renders literal text coordinates, formulas, sheet structure, tables and names, comments and links, validations, connection metadata and bounded indicators for Power Query, pivots, embedded models, VBA and package security. Ordinary numeric, date and Boolean values stay out of the model packet; secrets are masked; opaque binary bodies are fingerprinted rather than dumped. A blind comparison toolbelt exposes only current-gold pages — no prior target, mapping, decision or scope pages, no fixture names, no expected counts. The model must cite workbook coordinates and allowed current-gold pages in one terminal result. Code validates citations but does not decide the mapping. Only after result and transcript are saved does the harness reveal the fixture oracle.

The retained live comparison established the corrected contract:

• Matching workbook: 14 of 14 direct mappings
• Partial workbook: 10 direct and 3 not found
• Complete-miss workbook: 8 not found

Those numbers are not marketing. They are the acceptance contract for a different product claim. The first harness would have been easier to green. Green would have been a lie about what was being tested.

Do not soften this into "the AI got it right with a little guidance." The point is the opposite. Authorship without typing is proven where human judgment overrules machine fluency.

Career capabilities as compiled components

The joins are the rare part. A Power BI expert might have built an audit utility. An AI developer might have built a workbook demo. A TOGAF architect might have produced a current-to-target deck. A salesperson might have described a "two-week readiness assessment." A software firm might have built a generic SaaS scanner.

FDE BI joined those perspectives into a client-contained engagement vessel that observes an estate, understands spreadsheet intent, creates a governed decision surface and compiles the result into the next commercial transaction.

The spreadsheet insight is particularly load-bearing. Call it an application and it needs architecture, security, testing, ownership, funding and change control. Call it a spreadsheet and someone can build a small financial system before Friday's board meeting. On that multi-year programme, roughly two of three meetings were about reconciling those sheets to themselves or to the real world. The organisation accumulates databases disguised as cell ranges, integration pipelines disguised as copy-and-paste, business rules disguised as formulas, exceptions disguised as overwritten cells. The sheet is not simply rubbish. It is part application, part requirements document, part prototype, part historical receipt. FDE BI treats it as a declaration, not an oracle — and that is why the blind comparison matters.

Owning a consultancy taught a different lesson: SOWs were so costly and error-prone I wrote them myself. That bottleneck limits how much work you can even bother to write up. The Data Readiness Review shape — fixed-price evidence before implementation — is the commercial answer developed fully in Buy Certainty First. This piece only needs the specimen fact: the workbench stops at an evidence-backed scope and refuses to pretend implementation has begun.

Receipts, not vibes

Product of One is explicit: ten minutes of receipts convert a great story into a demonstrable one; without them you are selling vibes with a marketplace costume.¹⁰

What this specimen retains:

• Wiki authoring run: 10 pages, 18 typed edges, 7 review flags, 41 junior tool calls (implementation test ledger)
• Blind comparison: 14/14 direct; 10 direct + 3 not found; 8 not found on complete miss
• Deployment: live at fde-bi.leverageai.com.au; health endpoint reports ok
• Readiness report honesty: distinguishes found / partially supported / not found; carries zero consultant decisions and forty-five unreviewed model positions into scope preparation rather than erasing uncertainty
• Scope draft discipline: scope remains blocked until material findings are decided — even when a draft can be generated for inspection under explicit "working position" rules

What it does not claim:

• A real client engagement completed end to end
• Authenticated multi-user decision operations under client data policy
• Adversarial and prompt-injection evaluation complete
• Windows service packaging inside the disposable guest as production delivery
• Engagement-two proof that another consultant can operate the vessel with far less dependence on the original expert

Those are not buried footnotes. They are the product boundary. The next proof package should include a real estate and workbook, named consultant decisions, at least one model finding rejected or materially modified, a final accepted scope with a source-to-finding-to-decision-to-SOW trace, and ideally a legitimate "not ready" or "do not build" outcome. A rejection would strengthen the product more than another perfect fixture run, because it demonstrates that the consultant surface is real rather than ceremonial.

What AI contributed versus the human

Be concrete. Do not hide behind "collaboration."

AI contributed: Power BI domain vocabulary and tooling discovery; OOXML and workbook archaeology turned into extractors; large volumes of implementation under a north-star prompt; junior/senior synthesis over safe evidence; draft report language; the cheap assembly that made a day-scale build possible at all.

The human contributed: product thesis and commercial object; FDE framing; terminal-value reason to build; TOGAF-shaped state machine; deterministic versus probabilistic allocation; bronze/gold provenance rules; the two architectural corrections; acceptance of which tests count; decision that the wiki is a brain; decision that the spreadsheet test must be blind; career-shaped recognition of spreadsheets as shadow systems and SOWs as the bottleneck; refusal to ship a parser regression as an intelligence claim.

There is also a subtler split visible in the build: design-time AI wrote complicated deterministic sensors that crystallise into reviewable code; runtime AI operates only inside the safe representation those sensors manufacture. That separation is the privilege architecture developed in Separation of Powers for Cognition. Here it is enough to say the specimen uses it: AI in live form interprets; AI in solidified form extracts; humans dispose; deterministic compilers bind.

You productised the path to understanding, not the conclusion. You standardised the compilation pipeline, not the client's reality. That is why fixed-price readiness starts to become economically thinkable: breadth becomes machine work; human attention is reserved for material findings. The commercial packaging of that idea is owned by Buy Certainty First. The specimen that makes the packaging honest is this workbench.

What a compiled career changes about project speed

Most experienced people still use their careers through biological recall: I remember a project like this; I think I have an old architecture document; let me explain my general approach again. That is accumulated experience. It is real. It is a terrible runtime.

A compiled career changes the physics:

1. Starting altitude. The first serious token of work already sits inside a world — frameworks, rejected approaches, commercial instincts, prior code — not in a vacuum.
2. Prompt as pointer. You stop restating your worldview. You address it.
3. Doctrine as generator. Frameworks are not essays you publish after shipping. They are source that emits organs.
4. Corrections as the scarce surface. When assembly is cheap, the job that remains is recognising working software that solves the wrong problem.
5. Receipts as product. Speed without an evidence package is a LinkedIn story. Speed with ledgers, health endpoints and held-out tests is a consulting product.

That is what "twenty-four hours" means. It does not mean forty-five years were optional. It means the forty-five years finally became executable at the moment execution became cheap.

The deck explained the engagement shape. The workbench now performs the first commercially decisive part of that engagement: determining what is true, what is wanted, what remains undecided, and what can safely be sold next. The deck became software. The software still stops where a human must call the findings. That is not a bug in the demo. That is the product.