Seven layers, and not one of them is impressive by itself. Voice in, reusable instructions, connectors, model routing, a second model checking the first, loops, and an approve button. I run all seven every day and honestly no single layer is where the speed comes from. It's the handoffs.
Two years in, 101 billion tokens, 96 projects, and the thing that actually changed my workday wasn't a smarter model. It was getting my hands out of the middle of the work. My mouth is the input now. A second model catches what the first one got wrong, 822 errors in 31 days. Loops run overnight against a check I wrote once and never touched again. What lands in front of me is a finished thing with a log attached.
People tell me AI is overrated, and almost every time they've got one or two of these running fine, alone. Overrated? I'd say under-connected.
Layer 1: voice in
I use speech to text full time. About 2,600 dictations, and I never go back and read it before I hit enter, which is why my messages to a model sometimes read like a guy talking while driving. That's fine. The model doesn't need clean input, it needs complete input, and my mouth gets a lot more of that out than my hands ever did.
The compounding part surprised me. Those 2,600 dictations became a voice pack. An AI drafts in my voice from them now, and it works because nobody cleaned them up into something presentable first.
Cheapest way in: install any dictation tool and talk your next prompt instead of typing it. You'll hate the first day.
Layer 2: skills, or the instructions you stop retyping
A skill is a file of reusable instructions the model loads so you stop re-explaining how you want things done. Mine cover stuff like how I want a page reviewed, how I want a commit written, what my house style bans.
Then I measured it. 15K tokens of skills were loading into every Claude Code session and 80% of them never got used. Every session paying rent on instructions that never fired. I built a usage dashboard, watched it for a while, cut the dead ones.
Cheapest way in: one text file called how-I-want-this-done. Paste it at the top of every serious request. When you catch yourself explaining the same preference a third time, it goes in the file.
Layer 3: connectors
Connectors let a model touch a real system instead of guessing about it. Calendar, inbox, database, repo, analytics. It's the difference between a model reasoning about your business and a model actually reading it.
I've got 98 plugged in right now. Five of them carry almost all the real work. The other 93 are inventory. I know that number's embarrassing, and that's exactly why I keep saying it out loud.
Cheapest way in: connect the one place your real work already lives. Not five. One. Then go two weeks and see if you reach for it.
Layer 4: model routing
Route by thinking density, not by task name. The expensive model plans, orchestrates, and reviews the risky work. Cheaper models execute from the plan it wrote. Before I route anything I ask one question: would a competent junior engineer get this step right from the plan as written? If yes, it's a typing problem, and typing problems go down the ladder.
The change that moved my costs the most was smaller than the routing. I started calling the planner with no tools, no repo access, none of the config preamble that normally rides along, just a self-contained packet with the paths and constraints it needs. One planning call went from $0.53 to $0.0022. About 240x, paid once instead of compounding across a session that keeps growing.
Cheapest way in: think the problem through in the expensive model, then hand the plan to the cheap one to carry out.
Layer 5: a second model checking the first
Models lie. Not on purpose, but they lie. They tell you it's done, they tell you it works, and it doesn't. Anybody building with them has hit this.
So one model writes and a different one reviews anything risky. Payments, auth, migrations, deletes, money math. What I've logged on my side: 822 caught errors in 31 days, a 74.9% catch rate. An earlier log had 88% of runs finding a real bug, across 53 runs. Claude stopped grading its own homework.
The detail that matters is decorrelation. Same model writing and reviewing, you didn't get a second opinion, you got the same opinion twice.
Cheapest way in: two chat windows from two different companies. Paste the first one's answer into the second and ask what's wrong with it. Try it once on something you already shipped. Uncomfortable morning.
Layer 6: loops
A loop is six things. A trigger, an objective, one change per round, the same check every round, a state file so it remembers, and a stop condition so it doesn't run forever.
On code the check is the tests. Green or not green, no argument. On a business task the check is a metric you picked before you started, which is the part people skip and then wonder why the loop wandered off.
One change per round is the rule I break, and I regret it every time. Change three things, learn nothing about which one worked.
Cheapest way in: pick one number you already track weekly. Make one change a week aimed at it. Write both down in the same file. That's a loop, and there isn't a single line of code in it.
Layer 7: the approve button
95 things run without me now. 54 scheduled jobs on my Mac, 19 Vercel crons, 14 GitHub Actions I wrote myself.
The one that shows it best lands at 7am. Research agents scan overnight, an editorial agent writes the thesis, a script agent drafts, a producer builds it, a fact-check pass runs, and a finished AI news video is sitting in my Telegram before I'm up. My job is the approve button.
That took me longer to accept than it should have. For a long time I wanted eyes on every step, and wanting eyes on every step is exactly what kept making me the bottleneck. So I stopped watching the middle and started demanding a log, so when something's wrong I can find where without having sat there.
I still catch things. That's the whole reason the button exists, and the day I stop catching things is probably the day I've stopped reading the logs.
The jet pack isn't any one of these seven. It's layer one handing off to layer two without me in between. Most people I talk to have one or two of them working fine, in isolation, and they decide the ceiling is low. I think the layers just aren't touching yet.
And I'm still the guy who changes three things in a loop and then can't tell which one worked.
