On this page
Two weeks on how we build software, and not a word on how we run the company. A new series on how much authority we actually hand AI inside our own business, one rung at a time.
Skip: Two weeks on the part people already expected
The last two pieces here were about how we build. Chuck and I spent Sep 15 lining CRAFT up against Anthropic's AI-native SDLC playbook, and last week I spent a whole piece on what breaks when that playbook has to run inside companies you don't own.
Both were about delivery, which is what people expect from a software firm. When someone asks about our work with AI, they ask about code.
Neither piece touched the part of our operation that surprises people most when they see it, which is how much of the company itself runs on AI now. Our main phone line gets answered by an agent. Our time off gets requested and approved from inside Claude. A good share of what we write starts as a draft. Our pipeline gets updated after calls without anyone opening the CRM.
Anthropic's playbook stops at the edge of the codebase, and so did we.
Most businesses don't live there. They live in the inbox, the phone, the calendar, the spreadsheet somebody keeps current by hand. So this series is about AI in the business, past the codebase, and it's organized around a question most companies skip on the way to buying a tool.
Skip: The question that comes before the tool
The question is how much you let it do without you.
We've circled this before. In June, Chuck and I wrote about customer service and split support work into three tiers: automate, augment, and leave alone. You sorted each kind of interaction by how clear the right answer is and how much a wrong answer costs. That framework still holds, and I'd hand it to anyone standing up a support bot tomorrow.
What it didn't say is that the sort moves. Something you kept on augment in March might earn its way to automate by September, and something you automated can get pulled back the first time it does real damage. Authority over work isn't set once. It gets granted, tested, extended and sometimes revoked, the same way it does with a new hire.
We also owe you a reconciliation. In April, Chuck wrote a piece titled "We Stopped Letting AI Make Decisions. We Started Letting It Capture Them." That was true of how we build software, and it's still true there. It isn't true of every part of our company anymore. There are things at InTech today that run with nobody approving them in the moment. We're going to name them, explain why we let them, and show what holds them in place.
To do that we need a shared vocabulary. Chuck built it.
Chuck: Four rungs
Every piece of AI work in a business sits on one of four rungs, and the rung is set by what the system is allowed to do without a person in the loop at that moment.
Reads. The system sees things and changes nothing. It pulls meeting notes, searches the company's records, answers a question about what was decided last month. Nothing leaves and nothing changes. This rung looks harmless, and it's where most businesses stall, because the failure is invisible. A system that reads partial context answers with full confidence. In August we ran the exit test on our own stack and found the question that mattered more than what we possess: when was the record last written to.
Reading a stale record fluently is still reading a stale record.
Drafts. The system writes something a person sends. An email, a proposal section, a status update, a summary. A human reads it and decides whether it goes. The surprise at this rung is that facts are rarely what fails. The draft gets every detail right and still doesn't sound like the person whose name is on it, or it answers in the wrong place, or it says the right thing to the wrong audience.
Acts. The system changes something, inside limits. It updates a record, files a request, moves a deal forward, grants an approval that someone configured it to grant. The gate for this rung is reversibility. If the action can be undone cleanly and every change leaves a trail, it can live here. When we built the connection that lets Claude work inside our own internal systems, the rule was that it goes through the same permission check and the same audit trail as a person clicking in the interface. It runs through the same code path, with no side door.
Decides. The system acts with nobody approving in the moment. It takes the call, makes the routing choice, commits to the next step. The only things governing it are what someone wrote down ahead of time about what it may do alone, and the record of what it did afterward.
Two things about these rungs trip people up.
The first is that they're per task. The same model sits on all four in a single afternoon at our company. The unit you assign a rung to is a specific job: summarize this meeting, update this record, answer this line. The rung does not belong to the tool.
The second is that they're different from the rungs Skip laid out in August. Those measured how far along you are in owning the coordination layer. These measure how much authority you hand the system once you have one. You can own the whole layer and keep every task on reads. Plenty of companies should, for a while.
Skip: Where we actually are
Here's our own inventory, in the same order. I'm leaving numbers out here, because they belong in the pieces that go deep on each rung.
On reads, the company has a memory. Meetings get captured, decisions get recorded, and when I ask what we agreed with someone two months ago, the answer comes back with where it came from. It's the most useful thing we run and also the one that's burned us, because coverage that stops partway through a story looks exactly like coverage that's complete.
On drafts, a lot of our writing starts here. Follow-ups, proposal sections, internal updates, and first passes on pieces like this one. Nothing goes out without one of us reading it and deciding. Most of what we've learned at this rung is about voice, and we've written a surprising number of rules about it.
On acts, InTech Time is the one you've already met. When we wrote about it in July, the point was that the team requests and approves time off from inside Claude instead of opening another app. It's also the cleanest example of this rung: bounded, reversible, and logged. Pipeline updates after calls live here too.
On decides, there's the phone. When you call InTech's main line, an AI agent answers. It greets the caller, figures out whether this is billing, support, something urgent or a new conversation, routes it, captures what it needs, and hands off to the right person with a summary already written. Nobody approves what it says in the moment. It's on its second version now, and the difference between the first and the second is one of the better lessons we've had about this whole ladder. It gets its own piece.
That's the thing we said in April we don't do. We do it now, in one place, on purpose.
The reason we're comfortable with it is the same reason we wrote the April piece in the first place: every call still gets captured.
Chuck: How something earns the next rung
The part that matters most is the promotion rule, because the ladder is only useful if you know when to move something up it.
We move a task up one rung when three things are true. We know how it fails at the current rung, and it fails rarely enough that a person reviewing it is mostly confirming instead of correcting. The step up is either reversible or tightly bounded, so a bad call costs a correction instead of a customer. And somebody has written down, in plain language, what the system may do alone at the new rung and what it may not.
That third condition is the one-paragraph test from earlier this month. If you can't write the paragraph that says what a system may decide without you, you don't have a boundary. You have a feature list. Every task on our decides rung has that paragraph behind it, and the paragraph is what we check against when something goes wrong.
Demotion works the same way in reverse, and it has to be just as normal. A task that surprises us drops a rung until we understand why. Nobody treats that as failure. It's the ladder working. In June we said the boundary is what makes the speed safe, and this is the same idea stretched over time.
You can only afford to promote aggressively if you're willing to demote without a meeting about it.
The companies that get hurt skip rungs. They buy a tool whose demo sits on decides and turn it on for a task nobody ever watched at reads or drafts. There's no failure history, no written boundary, and no rung to fall back to. When it goes wrong they don't demote it. They turn it off and decide AI doesn't work for them.
Skip: This is what a Blueprint is
When companies ask us where to start with AI in the business, this ladder is the answer, and it's the work we do in a Business OS Blueprint.
A Blueprint takes one business function at a time and maps it. Who does what, what each role produces, what it waits on and what it redoes. Then it answers the ladder's questions for that function. What does the organization know that an agent would need, where does that knowledge live, and what shape is it in. Which roles get an agent, what that agent does, what stays human, and what gets no agent at all. Where a person reviews before anything goes out. What the current numbers are, so there's something to measure against. And the order things move up the ladder, starting with the one that's safest to promote and most worth promoting.
The client keeps every piece of that whether they build with us or not. That's the exit test from August applied to the start of an engagement instead of the end.
If the plan only works with us attached to it, it isn't much of a plan.
Skip: What comes next
Over the next several weeks we'll take the ladder one rung at a time. Reads next week, starting with the company memory and why coverage that looks complete is the dangerous kind. Then drafts, then acts, then decides, including what changed between the first and second versions of the phone agent and why. We'll close with a version of the ladder you can run on your own business in an afternoon.
The mistakes we show will be our own, from our own systems.
In the meantime, pick one AI task running in your business right now and put it on a rung. Then answer a harder question: did someone decide it belongs there, or did it drift there because that's where the tool started? Leave a comment with what you find. The drift answers are the ones I want to read.