Most AI projects fail on the input, not the model

Most AI projects fail on the input, not the model. What the system has to work from is where it breaks, and that’s what this page is about, in the order I run it.

An audit and a build are different jobs, and running them together is how a business ends up with a tidy system full of the wrong decisions. So first I trace how the work actually happens, which is almost never how the written process says it does, and I run the same trace on your information: what’s here, what’s duplicated, which copy is real, and what everybody assumed existed and doesn’t.

That comes back as an operating map. How the work runs today, how it would run rebuilt, which one workflow is worth doing first, what a system should and shouldn’t be allowed to do, and what it’s worth in hours and risk. Nothing gets touched or deleted, and you keep the map whether or not you hire me again.

Here’s where my version departs from the textbook. Most frameworks start at the workflow and assume the information underneath is reachable. In practice it isn’t, and that’s usually the real blocker.

I ran this on my own operation before I sold it. 3.7GB of records, 804 files moved, nothing deleted, every move logged so I can walk it backward. The method reads everything first, does a dry run, then moves. When it hit folders that were code rather than documents, it stopped and used a lighter touch, because reaching for the heavy approach where a light one is right is the same mistake one level down. That judgment call is most of what you’re actually buying. The tangled mess became findable without ever handing an AI the power to lose anything.

A findable folder still can’t tell you which of two contradictory files is the one that counts, and that’s where the real pain usually sits. So the judgment goes into the files, not the prompt. Where the audit found two versions of the same thing, the ruling is written down. Which file governs, and why. State goes into the filenames, so a spreadsheet is named with its date and marked stale instead of being called “current” and lying to everyone for three months. Superseded copies stay on disk in a folder that can’t be cited, because deleting is how you lose the one copy that mattered. And the rule over all of it is that if there’s no source, you don’t get an answer.

That structure lives in your folders, on your machine. The harness is the swappable part. Point Claude Code at it, or Hermes, or Codex, or whatever your team runs, and the same questions come back with the same answers. You’re not buying my tooling. You’re keeping your own.

Nobody buys a filing cabinet for its own sake. The third layer is whatever the job needs, whether that’s internal tools, connections into software you already pay for, or agents that run while you sleep. Where the work repeats the same way every time, the folder does the routing, so the AI gets moved through the task instead of being asked to hold all of it at once.

Every step gets sorted into one of three buckets first. Plain code where the rule is fixed. The model where the goal is clear but the inputs vary, like reading a lease. A person wherever the call is ambiguous or hard to undo. Most bad AI builds are one of those three put in the wrong bucket. And this layer only works where the work is actually defined, so where it isn’t, we define it first or leave it alone.

See the jobs this most often takes over →

A demo proves a thing can happen once. That’s not the same as knowing it holds on a Tuesday when nobody’s watching. So every build gets graded against questions with known answers, written by hand before the system sees them, including the cases where the right move is to refuse. Then four things get scored. Did it answer right, cite right, take the right steps, and refuse when it should.

What comes back is a pass rate, the failure categories, and the measured cost per run, because that last number hits the bottom line. Deal analysis at sixty cents a run is a different decision than eight dollars. On the property build it was twelve for twelve against a hand-written key, and the two that count are the two it refused to answer. The thirty-case pass and the real cost on that one aren’t done yet, so I say that instead of implying otherwise.

After enough of these, the shapes stop varying. An umbrella is a whole operation with divisions under it. A pipeline is a process with stages. A record library is a set of things you hold and refer back to, clients or properties or matters. A knowledge bundle is a body of material somebody has to search and cite. A context map is an organization written down so an AI knows who does what and where decisions live. Which one you are usually decides which layer you need first, and it’s clear inside the first conversation.

I built a roofing company a complete system, estimates through payment, replacing $835 a month of software that didn’t talk to itself. It’s finished, deployed, and sitting there, because a structure nobody adopts is worth nothing, and adoption doesn’t happen because the thing is good. It happens because one person uses it in front of everyone else and somebody finally gets a week back. That’s most of what the first few months of ongoing work actually is.

After that, a structure rots if nobody tends it. A new document shows up with no home, a rule that was right in March is wrong by September, and left alone the tangled mess grows back. So the test of whether I’m doing this right is that it shrinks.

Start with the audit. Nothing moves, you get the operating map, and you own it either way.