Source: frameworks/the-nuance-gap/the-nuance-gap.md

type: reference status: active created: 2026-06-06 owner: Reid also: delivery frame + positioning angle related:

decisions/2026-05-17-practice-builders-membership-model.md
decisions/2026-05-19-tpc-pbos-tax-evolution.md
prospects/martin-eisenstein/profile.md ---

The Nuance Gap

The commodity is the agent. The value — and the hard part — is the owner's nuance: the judgment they make on the fly and have never encoded. You can't buy that off the shelf. You surface it by building and testing, and that iterative loop is the engagement.

A reusable delivery + positioning frame for custom AI build work. Pull this up before any engagement where you're building something specific to one owner's business.

The core insight

Every expert owner runs their delivery on tacit judgment — "it depends" calls made on the fly, exceptions handled by instinct, sequencing they don't even notice they do.
They experience this as "I have a system/process." They don't. They are the system. It runs fine because they're the judgment layer.
They treat AI like an assistant — feed it a prompt, supply the judgment live — so the gaps stay invisible (they fill them in real time without noticing).
A delegated agent requires that judgment to be encoded — which makes every gap visible and blocking.
⟹ The distance between what's in their head and what an agent can actually run is The Nuance Gap. Closing it is the work, the value, and the moat.

Commodity vs. nuance — what you're really selling

Commodity (what they think they're buying)	"An agent that onboards advisory clients." "An agent that produces the tax-planning deliverable." Generic, sounds DIY-able, runs on predetermined criteria with little encoded data.
Nuance (what actually makes it work)	Their criteria, their exceptions, their voice, their sequencing — encoded and tested against their real cases.

The sale isn't the agent. It's turning their tacit process into an owned, repeatable, runnable asset. The agent is the artifact; the externalization is the value. Sell that, and it stops competing with "I'll just figure it out myself."

Why it's necessarily iterative (the part clients don't get)

You can't buy an agent off the shelf and have it work your way. v1 runs on predetermined criteria + thin encoded data → it will be wrong in places only real cases reveal.
The build is a forcing function: it stalls or guesses exactly where the process was never specified. That failure is the map of what was never a system.
You close the gap by: deploy → run real cases → see what breaks → encode the missing judgment → re-run.
The owner discovers their own gaps by watching it run — they couldn't have told you upfront, because it was tacit. Realization, not building, is the long pole.

Maturity-model anchor

You cannot build Level 2/3 (AI assists / AI runs) without Level 1 (the process is documented). The Nuance Gap is the distance to a real Level 1 — and most owners are further from it than they think. (See the maturity model in decisions/2026-05-17 and 2026-05-19.)

The timeline truth

Build: days. A working v1 can exist by session 1–2.
The engagement is iteration + the owner's realization/acceptance speed — NOT build time.
Realistic: ~1 month; up to 6 weeks if the internal mechanics of how the business runs are genuinely tangled.
Compresses for a responsive owner. The rate-limiter is how fast they confront and accept their gaps, not the code.

The live weekly session IS the compression mechanism (not the delay)

The instinct is that weekly sessions slow it down ("six weeks!"). Backwards.

The weekly live session is sacred time on the calendar — a guaranteed block to do the work, present it, get feedback live, and work snags in real time.
Async is the enemy. "Send it over, he'll review and reply" is where the lag and the drop-off live — most owners (Martin especially) won't reliably do async homework/review. That's where weeks evaporate.
The live session closes the loop in the room: present → react → fix the snag together → move on. No inbox wait. That is where time actually compresses.
It converts the owner's biggest weakness (won't do async review) into a non-issue — the review is the session, not homework.
And it's the highest-value use of 1:1 face time — not a status update, but building together. (Ties to the leveraged-business principle: concentrate live time where it's worth the most.)
The split that makes it work: builder builds async, owner judges sync. Heads-down building between sessions is fast and is where the speed comes from; the live block is reserved for react-and-encode. The owner's async is the enemy — not the builder's. Walk into each session with a runnable thing that just produced real output on real data, so the time goes to reacting to what it did, never to talking about what you'll build.

The change-management half (where the advisor, not the builder, earns the seat)

When the build hits a constraint — "we can't do it the way you pictured, because X" — the owner has to be on board with the why, or it reads as "the tool failed."
Frame every surfaced gap as "here's how we make it real," not a failure. This is why the work is done with them, and why trust/relationship lets you say "your process has a hole here" without them bailing.
Craft: deliberately sequence which gaps to let them discover by watching it run (creates buy-in) vs. which to flag-and-decide (saves a cycle). Discovery teaches; too much discovery is slow.

How to use this frame

In the sale: sell the externalization (an owned, runnable asset), not the commodity agent. Set the expectation up front: "You can't buy this off the shelf. We'll have a v1 fast, then we test it against your real cases and encode what only shows up when it runs. Plan about a month."
In scoping: narrow to ONE process first (the commodity shell); the nuance is what the engagement encodes.
In delivery: treat failures as the map; sequence gap-discovery for buy-in; keep the owner's review cadence as the real schedule driver.
In forecasting a specific owner: weight their participation + realization speed, not the build. (E.g., Martin: high deferral / under-participation → budget realization as the long pole.)

Evidence / exemplars (to deepen)

Martin Eisenstein Sprint — tax-planning delivery agent. The commodity ("an agent that does your tax planning deliverable") vs. the nuance (his strategy library, exceptions, voice, Pro Connect path). See prospects/martin-eisenstein/profile.md.
TPC Q2 Retreat (2026-06-04) — ran the advisory-onboarding cascade live; the per-firm nuance surfaced in the room. The cascade is the commodity shell; each firm's encoding is the nuance.
Jenn Barr calls (2026-06-05, ×2) — [mine for concrete examples of the gap surfacing].
TPC-vertical advisory-onboarding agent (Arden + Kathryn, upcoming) — productized cascade: commodity shell, nuance encoded per owner, still requires the test loop.

Why this is also a positioning angle

The market doesn't know it doesn't have a system. "Buy an AI agent" sounds like a commodity they could DIY. The Nuance Gap reframes it: what's in your head isn't a system until it's encoded and tested — that's what I do, and you can't shortcut it. It justifies the engagement, the price, and the iterative timeline in one move.