AI Is the 10%. The 60-30-10 Layer Framework, Audited Across Three Workflows.
AI is the smallest layer of any real workflow — most of the value lives in the infrastructure and the orchestration built around it.
Article 1 ended on a beat I left mostly unargued: Van Clief’s 60-30-10. The piece named it, applied one slice of it (the 10% boundary), and moved on. The point of this article is the rest of it.
The framework is small. It is also the single most useful tool I’ve found for figuring out where Claude actually belongs in a workflow, and where it doesn’t.
The framework, stated clean
Van Clief’s 60-30-10 (ICM) separates any real workflow into three layers, by share of value.
60% Infrastructure. Systems that already exist and shouldn’t be replaced. Databases, file storage, calendar systems, routing logic, approval chains, source-of-truth records. The boring middleware that runs the business. Examples: a CRM that holds client info, a folder structure that holds project files, an existing review-and-sign-off chain.
30% Orchestration. The connective tissue. Templates, rules, decision logic, structured checklists, format conventions. The layer that takes raw tools and makes them useful for a specific context. Examples: the report template that turns raw data into a deliverable, the decision tree that picks which client gets which sections, the QA checklist that runs before send.
10% AI. What a model handles well: summarize, extract, generate, compare against a standard. Examples: draft the narrative summary, extract trends from a data table, compare this week’s output to a defined standard and flag exceptions.
AI is the smallest layer. By share of value, by share of the work, by where the irreplaceable contribution lives. Most of any real workflow lives in the other two layers.
This is the framework that gets cited most and misframed most. The 60-30-10 numbers are about layer share of the workflow value, not about context-budget allocation or any kind of token split inside a session. Confusing those is the wrong cached read of it.
The failure mode
The failure mode is treating Claude as the whole stack.
You ask Claude to parse a source-of-truth file (that’s infrastructure work). To decide which template to use based on the task (that’s orchestration work). To generate the artifact (that’s AI work). The session does all three because nothing stopped it from doing all three. The bill is the price you pay for AI to do work that infrastructure and orchestration should be handling for free.
A smaller prompt does not fix this. A cheaper model does not fix this. Both are optimizations within the 10% layer. The cost lives in the 90% above it, doing work the model is the wrong tool for.
The fix is to push the 60% and the 30% to where they belong: existing systems and declarative rule files. What’s left is the AI layer, which is the only thing Claude is uniquely good at.
Audit 1 — a content team
A marketing agency producing weekly client reports.
60% Infrastructure. The CRM that holds client info. The intake form that captures the brief from the client. The asset library that stores brand guidelines, prior reports, approved logos. The review tool that routes drafts to the account lead. The send mechanism (email, portal, Slack channel). All of this exists. None of it needs Claude.
30% Orchestration. The report template (what sections every report contains, in what order, with what visual conventions). The routing rule that picks which sections are relevant for which client tier. The QA checklist that runs before the report goes out. The structured prompt format the team uses to brief whoever writes the actual prose. These are write-once, use-many. They live in files, in templates, in form schemas.
10% AI. Drafting the prose summary for each section. Extracting the three or four trends worth surfacing this week. Comparing this week’s metric movements against the prior week and flagging the anomalies. That’s the work AI is irreplaceable for in this workflow.
The agency that uses Claude for all three layers will run the most expensive content workflow on the team. The agency that pushes 60% to existing tools and 30% to templates, and uses Claude only for the 10%, will run the cheapest and the most consistent.
Audit 2 — a solo operator (mine, redacted)
60% Infrastructure. Calendar files in markdown that hold the publishing schedule. Sandbox folders that hold per-worker artifacts. Brief templates that define the shape of every dispatch. A simple state-tracking file that records active threads. Existing systems, each one a file.
30% Orchestration. Pre-flight checklists that run before any dispatch. Routing rules that decide which worker gets which job. Worker boundary rules that prevent the cross-sandbox leaks from Article 2. The structured brief format itself. These live as files I load on demand. They are not re-derived every session.
10% AI. The actual generation by workers: the prose, the visuals, the audits. Plus the orchestrator’s dispatch step, which is the small bit of model-in-the-loop reasoning that turns the calendar row into the worker prompt.
Honest note on where I am: my current setup still has Claude doing some 60% work (parsing the calendar file, when a script could) and some 30% work (re-deriving routing decisions, when a declarative rule file would do). The migration is ongoing. The improvement from where I started (Claude doing all three) to where I am now (Claude doing mostly 10% plus partial 60%/30%) is the bulk of the token reduction in Article 1. The remaining migration is smaller, but real.
Audit 3 — a data analyst at a small company
Building a recurring dashboard for a team that needs Monday-morning context.
60% Infrastructure. The data warehouse. The BI tool that renders charts. The share-link permissions that decide who sees the dashboard. The Monday-morning Slack message that posts the link. All existing.
30% Orchestration. The dashboard template (which charts, in what order, with which metrics). The metric definitions (so “revenue” means the same thing every week). The alert thresholds (so anomalies surface consistently). The week-over-week comparison rules. These are written down once and referenced, not re-decided each week.
10% AI. The weekly narrative summary that contextualizes the numbers. The anomaly callouts that explain why a number moved. The comparison against last quarter that flags emerging trends. The chart annotations that point a reader toward the meaning.
The analyst who hand-writes the summary every Monday is doing AI work manually. The analyst who has Claude generate the dashboard’s chart specs from scratch every week is using AI for orchestration work. The audit makes the seam clear.
The audit prompt
The whole point of this framework is that you can run the audit on your own workflow in about fifteen minutes. The prompt below is what to paste into Claude to do exactly that. Replace the bracketed values with your specifics.
I want to audit my current workflow using the 60/30/10 framework.
My role: [your role]
A process I do repeatedly that takes too much time: [describe one specific workflow end to end]
Break this workflow into the three layers:
60% Infrastructure — traditional systems, databases, file storage, routing, approval chains. What already exists and shouldn’t be replaced?
30% Orchestration — connecting things, deciding where data goes, structuring how outputs get formatted or routed. The logic layer.
10% AI — what a model handles well: summarization, extraction, generation, comparison against a standard.
For each layer, tell me: what already exists that I should keep; what’s missing or broken; what I’m currently doing manually that belongs in a different layer.
Be specific to my workflow. Don’t give me generic advice.
Source: Jake Van Clief / ICM. Run it, then commit to one move: take one item Claude is currently handling that actually belongs in 60% or 30%, and migrate it out of the model. One move. Real reduction.
What I’m giving you, and what I’m not
This article tilts more “give” than most in the series. You have: the framework, stated correctly (layer separation, not context-budget split).
Three workflow audits with concrete examples.
The audit prompt verbatim.
The migration cue (move one item per audit).
What I’m not giving you: my actual hook scripts that push 60% and 30% out of Claude in my own setup, my specific brief templates, my internal routing rules. Those are the starter-repo content.
The audit travels. The starter repo speeds up applying it. Without the audit, the starter repo is just code. With the audit, the code is finally pointed at the right layer.