The Leash Got Longer

Human in the loop is non-negotiable. I'll die on that hill. I'm writing this as a CTO, because that's the seat I sit in, but hold the thought, because the pattern applies just as much to the CMO and the COO.

Here's what people keep getting wrong in both directions. The skeptics think nothing has changed. The hype guys think the company runs itself next quarter. What's actually happening is narrower and more useful than either: the leash on AI is getting longer. It is still a leash.

Why the leash stays on

AI is terrible at judgment. Not mediocre. Terrible. It is confident, fast, and fully capable of walking you off a cliff while explaining why the cliff is the correct direction.

I'm not speaking theoretically. One of my own agents decided the right fix for a networking problem was to expose my Mac mini to the public internet. Private data, open door, best intentions. That is the kind of mistake a model makes: not a typo, a judgment call it was never qualified to make, made instantly and with total confidence. A company is a long sequence of exactly those calls. Which client to take, what to build first, when the elegant answer is wrong for a reason nobody wrote down. That's the hill, and anyone selling you otherwise is selling you something.

What it's genuinely great at

Now the other half, because this is where the leash gets longer every quarter. The low-level, tedious, repetitive work. The stuff that used to eat my week.

• UI testing. Does the button do the thing, did the event land in the database.
• Integration testing. Does the calendar sync, does the OAuth flow complete, does the API return what the docs claim.
• Minor bug fixes. The off-by-one, the null check, the thing a senior engineer fixes in four minutes and resents for forty.
• Browser automation and AppleScript. Clicking through the real app on the real desktop, over and over, without getting bored on the fortieth pass.
• Repetitive execution of any kind. The hundredth form, the Lighthouse audit, the boilerplate.

None of that is judgment. It's patience and precision, and a model has more of both than I do at 11pm. I let it test the whole app while I went to the gym, and it's writing most of the HyppoCRM mobile app right now.

The CTO job just changed shape

I used to live in the weeds. Writing the specs, then writing the code, then debugging the code, then building the next thing from scratch. That was the job. The best engineer in the building, doing the hardest engineering.

Now the job is architect and observer. I set the direction. I write the high-level architecture spec: how the system is shaped, what the data model is, where the walls go, what "done" means. Then the agents execute, and I watch. I review what comes back, skeptically, with the whole architecture in my head, and I step in for the judgment calls. The edge case. The flow that's technically correct and practically wrong for a cabinet shop at 4pm on a Friday. The thing the machine was confident about and shouldn't have been.

Here's the real reason this matters, and it's not about saving hours. It's about brainpower. A founder gets a finite amount of good judgment per day, and every hour I spend clicking through a form or hunting a null pointer is an hour of that budget spent on something that didn't need me. The whole point of the longer leash is to preserve the good thinking for the decisions that can make or break the company, and hand everything else to something that doesn't get tired. I wrote that the CTO seat just became the most valuable one in the building. This is why. Not because the CTO writes more code. Because the CTO is the one who can turn what the experts know into systems, and then correct the systems when they drift.

Same pattern, different seat

I'm describing the CTO because it's mine. But swap the nouns and it's the CMO: set the positioning, write the brief, let agents draft the forty ad variations and run the tests, step in on the one creative call that actually matters. Or the COO: design the process, let the agents run the checklists and chase the follow-ups, step in when a customer situation needs a human spine. The seat holding the compass gets more valuable in every function for the same reason: direction and judgment are the scarce thing now. Execution isn't.

I used to hesitate. I hesitate less now.

Giving an AI AppleScript control of my actual machine was a line I didn't want to cross for a long time. I'm more comfortable now, and I want to be precise about why, because "I got comfortable" is how people get burned.

It's not that I decided to trust it. It's that I've used it enough to know its shape. Where it's reliable, where it invents things, where it needs a human to log in, where it'll quietly do something dumb. That's what a guardrail is. A known limit with a scoped permission and a report you actually read. Extend the leash where you've measured it. Nowhere else. And make sure that when it fails, it fails loudly.

Six months of CRM, and what it'd be today

Concrete version. I built our CRM. About six months of real work, and it's the thing the whole company runs on.

With today's tools I'd cut a month off that, maybe more. Not because the architecture gets written for me, I'd make every one of those calls the same way, but because the tedious middle compresses hard. What doesn't compress is the end. The edge cases are still mine. A model can find a broken button. It can't tell you the flow itself is wrong.

What this replaces, and what it doesn't

Let me be blunt about the thing nobody wants to say plainly. AI won't replace your experts. It replaces the lower-level execution roles underneath them. The junior tester, the person who clicked through the flows, the one who ran the checklist. That work is moving to agents, and it's moving fast.

That has real social implications and I'm not covering them here. This post is about what's true on my desk this week, not what it means for the labor market. Someone should write that one. It isn't this one.

The takeaway

The leash is longer. It's still a leash. AI is bad at judgment and great at grunt work, so give it the grunt work and keep the judgment. If you're a CTO, your job is now architect and observer: set direction, write the spec, let it run, review hard, step in when it matters. If you're a CMO or a COO, same move, different nouns.

I'm building the machine so I can step away from everything except the decisions that need me. Preserve the brainpower. Spend it where it counts. Hand the rest to the thing that never gets tired.

Want this built the sane way?

Guardrails, a human on the judgment calls, AI on the tedious part. That's how we ship at HyppoAI.

Let's build it