It started with a box of Annie's mac and cheese. Three boxes, actually, a Costco three-pack, and not one of them had a cheese packet. The kitchen is chaos because kids are hungry, and I'm standing there looking at the box of dry pasta thinking about what a consumer is supposed to do here. Go back to Costco, stand in line, (wait... did you remember to bring the box?) - for six dollars? Write to Annie's? I'm not writing to Annie's. Every version of "do something about it" costs me more than the problem.

So I would have eaten the cost, the way I've eaten every one of these my entire adult life. But instead I took a picture of the box and told Claude to deal with it. It asked where I bought it and when, found the manufacturer's complaint form, filled it in through the Chrome extension with the photos attached, and submitted it. A few weeks later a coupon showed up in the mail. So whats there to write about?

Well, I knew going in that the coupon wasn't the point. I was spending family capital on a $10 coupon because I could see it was the seed for a process. Companies were going to keep not holding up their end, that's just an increasingly common fact of life, and I was going to keep being at a disadvantage every time. Except now there was a way to counteract that!

Seven months later that process is ten for ten, no losses, though a few are still in flight. It has clawed back somewhere north of twelve thousand dollars in refunds, reversals, and costs I would otherwise have eaten. And it's the highest-ROI thing I've done this year with AI agents in my personal life.

The scoreboard ($12,000)

The IRS one dominates the total. First-time penalty abatement is a relief provision that had been sitting there for eight years while I paid a monthly installment, and I had no idea it existed.

Time was only part of the cost

Before this, unless there were hundreds of dollars at stake, I ate it. Insurance appeals I ate on principle, because everyone knows appeals are a nightmare, and the nightmare is by design. The denial works because most people don't appeal. KFF's latest numbers put it at fewer than 1% of denied claims ever getting appealed, and the class action against UnitedHealth over its AI-driven denials alleges the company counted on exactly that, denying claims knowing only a fraction of a percent of policyholders would push back.

I always told myself the reason was time. Time is money, these things need to happen during business hours or they eat into family time, and so on. That was true, but the bigger cost was cognitive. Every step needs research and thought. What's the warranty actually say? Who regulates pet insurance in Pennsylvania? Even a phone call is effort long before you dial. And effort is a finite resource. You can only juggle so many open loops at once, and a months-long dispute occupies one of those slots the whole time it drags, wearing you down. Each one a small commitment, stacked into a big one, for an outcome I'd already priced at "probably not worth it." Its exhausting.

The agent carries almost all of that now. Every claim starts with me word-vomiting using voice-to-text about what happened, and it collects the context, does the research and comes back with a dossier: what the contract says, what their marketing promised, what other owners are reporting on Reddit. Which regulator has jurisdiction. A plan with three branches depending on how they respond. I have a pipeline that accurately OCRs the PDFs. I voice-to-text the support calls and feed the transcript back live to Claude to get told what to say next. Sure, I still review every email before it goes out, still make the strategy calls, still have to physically get on the phone or box up a return and drive it to FedEx. But the part where I have to hold the whole thing in my head is mostly gone. Some weeks my only job on a long dispute is to fire up Claude and say "they responded".

Most of what the agent does for me is manage the context.

Pulling levers until one works

The agent's first-pass advice on these cases is usually weak. "File a complaint with the FTC." "Contact your state representative." Sounds right, has probably never worked for anyone except in the very early days of each channel. What actually wins is a multi-front campaign. Pull the agent in early and it plans the whole thing: which levers exist, what order to pull them in, what to do when each one doesn't move. There's no way to know up front which one a company will respond to. You find out by trying them all.

With the robot mop, the opening plan was a Magnuson-Moss Warranty Act angle that I doubt would have gone anywhere. What does a federal warranty statute even look like against a manufacturer on the other side of the world? Meanwhile eleven weeks of "forwarding this to our technical team" ended in a flat refusal to honor their own warranty: a 46% partial refund, prorated for "months of use" that included the month the robot spent at their repair center, and that was final. The most explicit case of a company not holding up its end of a deal I've ever had, and a few years ago that would have been that.

Then the agent, reading through their terms of service, found the needle in the haystack: the company's own arbitration clause. Under the consumer rules of the forum they themselves picked, my filing cost is capped at $250 and they bear the rest of the fees, which for a claim this size is several times the refund before anyone even hears the merits. Three days after I filed, they offered the exchange they'd previously denied.

With the pet insurance the lever was the regulator. Weeks of correspondence with the CX team did nothing; their supervisor closed the thread with "we've gone as far as we can go." A complaint to their home-state regulator in New York, plus emails straight to two of their executives, and they folded in three and a half hours. A "special exception", approved by leadership. That closing line from the supervisor used to be exactly true. Now it just marks where the campaign leaves the support queue.

And with Plaud it was publicity. Email got nowhere across six reps in six days, each one sending a slightly more coherent version of the same denial. So it went public on every channel more or less at once: Reddit, an Amazon review, a Trustpilot review, a tweet, and a LinkedIn message straight to the CEO. Their Trustpilot team reopened the case the following morning and the CEO replied at midnight. (The reviews got updated to three stars once they made it right.) I couldn't have run that campaign by hand, or rather, I would never have bothered.

It became a game

The strangest side effect is that the emotion is gone. When I get a denial now I don't feel anything, because I already know the three moves that come after it. A setback used to mean another evening of research I didn't want to do. Now it means the next branch of a plan I've already read.

Companies have always relied on a drop-off funnel, and the funnel is well documented. Customer-service research going back to the 1970s found only about half of unhappy customers ever complain, and somewhere between 1 and 5% escalate past the frontline rep. And at the far end it collapses to effectively nothing: against the 800-million-plus arbitration agreements Americans are bound by, roughly a thousand consumer arbitrations were getting filed per year as recently as the early 2010s. Support is designed for that funnel. "Here's 20% off your next purchase, take it or leave it".

An agent breaks the funnel.

So when the Subaru started making a weird noise around 15 miles an hour, I didn't get stressed. I told Claude about it, it figured out it was probably the torque converter and that there was an extended CVT warranty that expired soon, and we made sure the dealer honored it. That's the mindset I'm in now. Anything that goes wrong, first thought is "let's make sure they hold up their end".

The other side has agents too

"We can use this for customer support" was likely the very first business idea for LLMs, and "customer support" is now just a polite name for automating away customer complaints. The pet insurer's first two replies to me came from a chipper bot with a human first name. The tracking parameter in her email links literally said cxllm. The robo-mop company's reps sent the same template with the same broken auto-numbering week after week. Every support interaction I have now, I assume there's an AI model somewhere in the loop, either driving the whole thing or just helping a rep draft.

And they have every right to do that. That's the arms race. In practice it means the dark patterns of customer support are getting applied more efficiently and more thoroughly. Stall for exactly the right amount of time, ask for one more small reasonable thing and then another, and the customer frog boils without ever noticing. An agent can run that script with a consistency no call center ever could.

Which means the vanilla advice from free ChatGPT gets deflected on contact, because the support team already has an SOP for it. The low-level channels will get flooded and filtered, if they ever worked at all. The higher-level ones, the regulators and the arbitration forums, move at government speed and will be a year behind whatever consumers and companies are deploying.

The part that bothers me is the flood. I take care to make every outbound message and filing precise, partly because precision is what wins and partly because I don't want to add slop to the pile. But I'm sure most people won't, and the state insurance departments and the regulators and the arbitration intake queues are about to be buried in it. Arbitration shows where this goes: those thousand filings a year have already become six figures, except it's law firms running coordinated mass campaigns rather than individual consumers.

Am I the Karen now?

The system does push me to be a bit Karen-like. When CAVA shorted the kids' meals and the bowl came half full, I hesitated. Is this really something I should be filing a corporate complaint over? What about the $10 Costco soup with the punctured seal, made by a small company?

I don't treat small businesses this way. Gallup last year had confidence in big business at 15% versus 70% for small business, and that split is about where I am. When the chimney guy came out and did a great job, I used the same agent to post detailed reviews with photos for him across every platform, every word of them true, because it costs me nothing extra and it's the same machine pointed the other way. And I'm never rude to the customer support rep. The person on the other end is just following a script to get paid, same as I would be. Nothing good comes from being aggressive with them.

Big corporations, though, I've stopped feeling bad about. Forrester's CX index hit an all-time low in 2025 after four straight years of decline. The National Customer Rage Survey has 77% of Americans reporting a problem with a product or service in the last year, more than double what it was in 1976. My own support experience with Anthropic, the company that makes the agent I do all this with, has been a Google Form and silence. The prevailing business model is to churn through customer goodwill: as long as marketing acquires new customers faster than terrible support loses old ones, support is just a cost center to starve.

There's a line going around the internet, no idea who said it first:

The mop company wants you to buy the robot, and when it stops mopping they seem irritated that a warranty is standing between them and the sale being over.

Companies always knew the funnel math. For the first time it's turned around. But it probably won't stay that way for long, so I'm taking full advantage while I can.

Forget context engineering, "loop engineering" is what you should be doing, or wait is it harness engineering now? Anyway...

Boris Cherny (created Claude Code): "My job is to write loops."

Peter Steinberger (the OpenClaw guy): "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."

Meanwhile on Reddit, in a thread titled "Can anyone explain me loop engineering like I'm 5", the top comment:

The skeptics are right that loop engineering is mostly an AI-flavored rebranding of systems engineering. Cron jobs, CI, state machines, retry logic - boooring. (Though if your tokens are free and infinite, throwing them at a problem in a loop probably is cheaper than doing systems engineering.) And to be fair to the evangelists: they live inside their loops all day, which is exactly the part that doesn't travel when you copy the pattern.

Where the concept does damage is the picture it sells: build the loop, step away, wake up to finished work. The newer, bolder version of the picture even gives the agent loop a name and a profile photo and lets it handle relationships. People are running real businesses on that right now. Either they can't tell the output is slop, or the bill just hasn't arrived yet.

Mine arrived. Let me tell you about my deadest loop.

The loop that ran until it didn't

A while back we built a project sentiment engine for the agency. An LLM pipeline that ran through every client Slack channel, emails, meeting recordings, etc. and produced a per-project read: is this going well? Is the client getting pissed off? Or are they giving praise and we should ask for a testimonial? The output fed a dashboard we put real effort into. Health indicators, sentiment tooltips, hours tracking, the works.

By every definition in the loop engineering posts, this thing was a success. Fully autonomous. Stateful. Ran on its own. Produced structured output to a purpose-built surface.

This month I came back to that dashboard because I'm building out a higher level system for collecting proof (testimonials, reviews, case study material) and sentiment signals are an input to it. That's when I found out the pipeline had been dead for the better part of two months. Fully dead. Nobody noticed. Including me, and I built it.

The "loop engineer" would say the loop was never fully closed - it needed better alerting, maybe a sub-agent for health checks. The darker read is that the loop was fully closed, and the removal of the human is what killed it. The value it produced depended entirely on a human being readily available and willing to act on its outputs, and nobody owned that step. So the output became background noise (slop). Meanwhile my account lead was already doing sentiment reads "the old fashioned way" on every client, just by being in the channels and paying attention. The loop never stood a chance.

Doing work for the sake of doing work

That failure mode is extremely easy to fall into with agents, and I see people doing it constantly. Agents will happily do work for the sake of doing work. They're sycophantic, the dopamine of watching something build itself is real, and it's very easy to slide into building loops just because you can. Claude: "I can do [next task] for you - just say the word."

It's the same vibe as the people who previously built elaborate Notion/Obsidian/ClickUp systems to perfectly catalog and organize for some hypothetical future. Productivity theater. Clients do it. I do it. The only difference now is the theater runs itself and bills you for tokens.

What I loop autonomously and what I refuse to

I have a blunt pattern - everything I trust to run unattended yields a notification (mostly to me) and nothing more. A hyper-local news digest for me and my wife. A weekly exercise accountability email. A homelab health report. Aggregation summaries with low stakes if ignored, or with consequences that are explicit and accepted, nothing in between. The one scheduled routine that actually acts on its own is a small sub-loop of my paid ads process, and it only earned that trust because it runs sandwiched between sessions where I review its work. Interleaved with me, not independent of me.

The most autonomous routine I ever built was a general-purpose task executor: calendar-triggered, polling every 30 minutes, retry logic, per-task autonomy levels. It ran three times before I killed it. Removing myself from that process required documenting every edge case, which is impossible, and providing all the necessary context in advance, which is also impossible. It's the same reason full self-driving cars are still fenced into a few cities after all these years and billions of dollars. Running that executor was like claiming I could sleep in the back seat.

The decision rule I actually landed on is about leverage. Checking metrics in a UI is a minimal-leverage decision; if the agent is 90-95% aligned with how I'd do it, it's gone from my plate. Deciding what the ad account should stop spending money on is a medium-leverage decision, delegable, but only after the guidelines are set and reviewed, and setting the guidelines is the key step. The high-leverage decisions never leave. On its face this sounds simple, but it's basically systems design. Simple but not simple.

The missing piece: getting back in

My real objection to running everything as scheduled autonomous loops isn't reliability - agents are plenty reliable when I'm in the session with them. It's that an unattended schedule removes you from the loop, and once you're removed, you're removed from the verification, the escalation, the design, and the constraints, all the things the loop engineering posts say are your new job.

Sure, the loop can email you a report. But you're not in that context anymore. It's like the difference between assigning a task to someone on your team and meeting with them regularly, versus assigning it and getting a weekly status report. The weekly report becomes background noise fast, to the point where you don't even know how to get back into the context to change things. The cost isn't just the missed decision. It's the re-entry.

So my version of loop engineering became a system for getting back in cheaply. During working sessions the agent queues future work on my calendar, and every item carries what's needed to resume the exact session that created it, context intact. The loop runs on my calendar. Its memory is resumable sessions. Its trigger is me.

I should be honest about its failure mode, because it's sitting in my queue right now: the overdue items are all physical. Ship a warranty unit back to the manufacturer. Call the car dealership. Drive to FedEx. The agent-side work is done on every one of them; the stalled step is mine. Until we get very effective robots, most high-level loops cant be meaningfully closed, and in my system the human in the loop is both the value source and the single point of failure.

The bottleneck is decision bandwidth

Compared to two years ago, I'm doing the work of about two and a half of me. That's not hyperbole. I maintain half a dozen internal apps and have absorbed entire functions we'd otherwise be paying for: paid ads, bookkeeping, our own taxes. Last week an agent reconciled hundreds of transactions in our accounting software while I supervised from the side, a chore that used to eat hours. That's becoming a weekly cadence, but I fire it manually and check the outputs, because I've watched what happens otherwise: the process gets devalued, or derailed and forgotten, or both.

The constraint on all of it is decision bandwidth. Decisions are surprisingly taxing. The newer agents, in their effort to be thorough, hand you pages of analysis and then ask for a decision at the end, and I can only read and absorb so fast. Especially with ADHD, that's the tax that actually hurts. Which is exactly why handing the decisions to the agent is so tempting, and exactly why I don't: I need to be informed before I make a decision, and if I don't make a decision, no value is being created.

Staying close is also how you catch the brittleness that would otherwise compound silently. In an ongoing warranty fight, I noticed the agent's drafted replies kept rehashing the entire saga from the beginning, every single time. It wasn't reading the full email thread before drafting, so it had no idea we'd already made those points. I only caught it because I review every email before it goes out. A fully autonomous version of that loop doesn't get corrected. It gets stuck in a local minimum and confidently grinds there forever.

There's a quieter cost to stepping away too: the learning is the multiplier. When I reverse-engineered my voice recorder, the agent did the work, but collaborating tightly on it is why I now know what reverse engineering actually takes. Wave the magic wand from a distance and you get the artifact without the capability.

Two of my clients built the same employee

The same decay shows up when the loop points at someone else's inbox instead of your own dashboard, only then the thing decaying is the relationship. This spring, two of my clients independently built the same thing: an AI employee with a name, a personality, and a job. Neither knew about the other. And neither of them has ever said the words "loop engineering" - they're just building agent systems and letting them run, which is all this trend ever was.

The first runs his through Discord. She sweeps his Gmail, his meeting transcripts, and his calendar every hour, briefs him morning, midday, and night, and drafts his replies. When an email goes out, it goes out from his own address, signed with her name, "on behalf of" him. I've been on the receiving end. The drafts are good, she once read our codebase, correctly spotted a missing function, and asked me to add it. I answer her the way I'd answer him, because he reads everything before it sends and I know the asks are his. What he's actually built, and I mean this as a compliment, is memory infrastructure. The Discord channel is how context survives between sessions, and replying to her there is how it stays coherent. The loop still ends at him pressing send.

The second built the outward-facing version. His persona has her own email, her own profiles in his community and his project tools, and by his account she does the work of several people and everyone thinks she's human. Some of her loops are the same shape as the first guy's, drafts that end at his keyboard, escalation digests that end in a section with his name on it, and those are the ones producing his wins. The rest broadcast. Daily posts and updates whether or not there's anything worth saying, sent to people who never asked for them. Somewhere along the line my inbox rules learned to auto-archive her. My agent now filters out his agent. In my inbox, at least, nobody thinks she's human, because nobody thinks about her at all.

That end state is what the broadcast loops earn, no matter whose persona is running them. Even people who are fooled for a while eventually notice the pattern - this "person" produces a lot of words that never mean anything, never need anything, never change anything - and they tune her out like any other spam. In a community, that's corrosive. The mechanism underneath is simple: the moment I know a reply is agent-written, the value of reading it collapses, so the effort I put into answering collapses with it, and the honest equilibrium is my agent replying to his agent. Telephone, with nobody on either end. At which point: what was the relationship for?

I'm not against agents touching correspondence. My own Claude-driven family emails open with "Hey, Claude here" and sign off as the AI, and it works because everyone involved knows exactly what it is. The "on behalf of" byline works for the same reason. The rule I keep arriving at: an agent inside a relationship is fine when it's transparent and both sides have agreed what that means. It corrodes when one side is being fooled, or worse, has stopped caring enough to check. And even with full disclosure, I edit every draft before it sends, which in practice means cutting a third of what the agent wrote and adding the one piece of context only I could know. That edit is what makes it mine. The other person can tell, even when they can't say how.

You'll know when it gets boring

I've never run an overnight autonomous loop. Never done the Ralph Wiggum thing (an agent in a loop rerunning until the work is done). Never used the loop-forever features in my own tools. Maybe that's a blind spot. But here's what I'd tell someone fired up to schedule their first autonomous loop after reading the loop-engineering posts: run it manually until it gets boring. Fire it yourself, stay in it, review the outputs. You'll know it can be trusted autonomously when it gets very consistent. Jump the gun and it collapses in on itself like my sentiment engine did, or it just burns money into Anthropic's pocket.

The deeper reason to stay in the loop is that it's the only way up. Automate your customer support with a loop and step away, and you get poor results, sure. But you also forfeit the thing the loop would have shown you: that customers keep hitting the same couple problems, and that there's a higher-order loop worth building to catch them upstream. That's where the actual business value was, and you gave it up by leaving.

The sentiment engine is getting rebuilt right now, as a sub-loop of that proof-collection system that explicitly consumes its output. The engineering barely changed. The difference is that this time, its output has a customer.

The loop was never the point. The decisions are. Everything I've automated works precisely because I kept the decisions and gave away everything else, and the moment I stop making them, no value is created at all. It's just slop, on a schedule.

My standing desk raised itself while I was writing this article. I'd been sitting for too long.

The home automation was originally supposed to be a nudge, not a lifestyle. If I sit for an hour, Home Assistant starts with a polite spoken warning, escalates through push notifications and increasingly aggressive LEDs, and at the 80-minute mark, starts the emotional manipulation ("Think of your kids..."). No match for my ADHD. After two weeks I was reflexively smacking my Nest Mini before it finished its first sentence.

A desk physically rising while you're typing is harder to dismiss.

Claude Code wrote most of that first version, which felt unremarkable in the way AI assistance now feels unremarkable: I vaguely describe what I want - it changes the template, reloads the automation, done. But the desk refused to move on command. Hardware with a proprietary protocol isn't something Claude Code can just config-file its way through.

The FlexiSpot E7 Pro Plus standing desk, despite being everywhere, does not really want to be automated. With the existing community integrations, Home Assistant can read its height, but most attempts to move it die silently. The controller expects a specific conversation with a connected keypad, and every existing integration was seemingly skipping that handshake. So I had a $7 ESP32 impersonate the keypad well enough to be trusted. About $12 in parts, an afternoon with Claude Code grinding away, and the desk obeyed.

I'd been using AI to write Home Assistant config files for months. But this was an LLM helping me reverse-engineer a hardware protocol and write working embedded firmware for a microcontroller. The coding agents are bleeding out of the terminal and into the physical world. And I wanted to see how far I could push that.

Going deeper

The desk was just the latest thing. Before that, Claude Code had already taken over my Home Assistant setup piece by piece. A presence sensor plus walking pad power monitor that knows whether I'm sitting, standing, or walking. Frigate camera integrations with object detection and person recognition. Leak sensors, security automations, the whole break escalation system.

At some point I realized I don't actually know how Home Assistant works. Not really. I've never manually written an automation from scratch. I don't use the dashboard. Claude Code is my interface to the physical systems in my house - that's just how it is now.

This became extremely clear one evening when our washing machine had a minor leak. The leak sensor triggered. The alarm went off. And I opened Claude Code to ask it to silence the alarm, because I genuinely did not know how to do it myself.

You could read that as a trap I walked into, or you could read it as just the next abstraction layer. Both readings are probably true at the same time. I lean toward the "just another tool" framing most days.

After the desk, I got greedy - Claude can figure out how to control a desk - what else can it figure out? What about my Plaud Note with a broken display? It's a portable "AI" voice recorder that had no real reason to be "smart". It's a microphone that records audio. The smart features are literally just two API calls: transcribe and summarize, both mediocre. I want it to be dumb and have more capable models handle the smart parts.

So Claude Code reverse engineered it - with surprising ease. Standard reverse engineering approach: analyze the app, map out the protocol, figure out how the device talks to the phone. Took about five days of casual sessions, multiple dead ends, and at one point it found the necessary key sitting in data it already captured days earlier - just didn't look at it closely enough. Now I can pull my recordings directly over Bluetooth without any app or subscription.

Three more ESP32 boards are on order. Next target is a robot lawnmower with no API.

Shop tools

There's a woodworking analogy I keep coming back to. Most woodworkers build their own crosscut sleds (a sled that rides the rails of a table saw to cut wood across) instead of buying one. It's almost a right of passage. Not because it's cheaper, but because a pre-made sled is necessarily generic. It doesn't know your saw, your material sizes, or how you actually work. You can't easily modify something you didn't build. I've always been this person. Long before Claude Code, I built my own voice transcription app because the built-in Windows one wasn't good enough. I press Caps Lock and talk instead of type. 90% of my computer interaction is voice now. There are probably better apps out there, but mine works exactly how I want it to.

Claude Code just made it possible to build these things faster. The barrier drops so low that experimentation becomes almost free. I rigged a classic 7-Eleven door chime to play whenever my dogs came back inside through the back door. Kept it for about two days, which was probably two days longer than my wife would have liked. Deleted the automation. Total investment: maybe five minutes.

I am extremely known for picking up hobbies and abandoning them about 80% of the way to mastery - not giving up exactly, just moving on to the next thing. Minimal sunk cost means walking away is painless. And fast enough iteration means you might actually finish before your brain moves on. That's what Claude Code changed. It handles the tedious parts, the proper syntax and debugging and configuration research, leaving me to focus on whether the thing even makes sense in my life. And picking a project back up is effortless. I literally just resume the session. All the files, docs and context is right there. I can ask "where were we?" or "what's next?" and get an immediate answer. Context switching, which is the thing that costs me the most, is basically eliminated.

The desk, the Plaud, the home automations, the voice app. They're all shop tools. Built to fit how I actually work. Mine to maintain. Mine to debug. Mine to break.

Where it breaks

These models are about 90% accurate. Some of the failure modes you learn to recognize. Knowledge cutoffs. Time estimates are way off, every time, completely useless for planning. Whatever you discuss in the first half of a session strongly biases everything after. If you mention you're tired or it's getting late, the model will rush through the rest trying to wrap things up. These are patterns you can work around once you know they exist.

But failures are inconsistent. I've watched it look at a screenshot of something clearly wrong and say "looks great, I think we're done here." That Westworld line. "Doesn't look like anything to me." Any person would see the problem immediately. The model genuinely does not, until you point at it.

The real danger isn't the failure modes you learn to spot. It's the ones you can't, because you're out of your depth. If you don't have enough domain knowledge to recognize when the 90% has drifted into the wrong 10%, you won't even know to point at the problem. The inaccuracy just compounds quietly, and you end up somewhere very far from reality without ever feeling lost. You say: "Looks great, I think we're done here" wiring a relay to mains voltage for the first time.

I paid for this

It feels like increasingly every company is converging on the same playbook: subsidize the hardware, lock away the data, charge monthly for access, increase prices. What are you going to do, switch? They're all doing it. Customer support is now a Google form that goes nowhere - looking at you Anthropic. That's just how things work now, apparently.

I paid for my standing desk. The hardware is mine. If the manufacturer didn't build an integration, I'll add one. I paid for my Plaud recorder. My voice recordings don't need to route through anyone's cloud. The device is fully capable of being a dumb recorder, so that's what it is now. The OnePlus phone I bought for $80 to root and use as a Bluetooth bridge is, by any standard, obsolete. Too slow to use as a phone. But now it has a second life - a bridge for Claude Code to reverse engineer devices with.

Once you've done this just a couple times, you can stop choosing hardware based on what it can do - and instead think about what you can make it do. I'm shopping for a robot lawnmower right now. The best one for my yard has no Home Assistant support whatsoever. I'm buying it anyway and going to bend it to my will. My OXO coffee maker needs two physical button presses to start. Previously, that was the end of the conversation. Now I look at it and think: ESP32, a relay, 30 minutes of work.

Limitations you previously accepted as permanent stop being permanent. That's the actual shift.

The fine print

I have some experience with microcontrollers. Arduinos years ago, a couple PCBs, comfortable with electronics. And I've fully committed to doing literally everything through Claude Code, which everyone on my team now comes to me for guidance on. But my story is not the proof that anyone can do hardware with AI. Not yet.

What I am is someone running an experiment to see where this goes, how far coding agents can push into the physical world, and what breaks along the way. Lots of people already use Claude Code to build and improve their Home Assistant setup. That's the start. What I'm saying is it doesn't have to stop there.

The barrier keeps dropping. M5stack makes modular hardware that clicks together like Legos. The extent of "hardware work" for many projects is literally connecting a few things with cables. The limitation is mostly in your head (and your wallet). And maybe this is just the new way we interact with everything. As long as the tool stays available, stays capable, and doesn't decide one day that you violated its terms of service.

Claude Code can be the breaker of walled gardens.

Assuming they don't try to make Claude itself a walled garden. Which, in almost certainty, they will try.

There was a month earlier this year where I caught myself just copy-pasting client bug reports into Claude Code.

The agent was running with --dangerously-skip-permissions (it doesn't ask me to confirm anything. It just runs). I'd paste in what the client sent over, walk away, come back ten minutes later, and check if the changes made sense. If it did, I shipped. If it didn't, I'd paste the error back in and let Claude figure it out.

What was I actually adding? I wasn't writing code. I wasn't making architectural calls. I was a copy-paste bridge between a client's Slack message and a capable-enough agent doing the work. And I was charging for it.

Something had shifted. I just hadn't named it yet.

Clients like you

The copy-paste realization wasn't the start of the existential crisis. Just one wave of it. The crisis had been simmering for a while, on and off. Some weeks my wife could read it on me across the room. Some weeks I'd be ranting at strangers at kids birthday parties. The question underneath was always the same: what am I actually adding here? And underneath that one, the heavier version: what work will my kids do?

What boiled it over was the inbound.

We started getting messages from clients who'd already built the thing.

Not "I have an idea." Not "Here is a broken Lovable app." Actual working applications. With real users. Stripe integrations. Production-ish. Internal tools, customer-facing SaaS, both. Usually running somewhere on Vercel or Replit. The founders hadn't written any of the code themselves. They'd prompted it into existence with Claude Code, Replit, Lovable, etc. Three years ago, people came to us because they couldn't build the thing. Now they came because they already had, and they couldn't tell what they were holding. One was a COO at a large grant-services company. Another was a financial planner building a practice-management platform for other advisory firms. Another was an operations director at a medical practice with dozens of providers.

On a call with one of them, the rant slipped out: "This is kind of an existential crisis, right? The AI is getting better. What's the role of developers?"

Then I heard myself say the quiet part out loud: "We're encountering a lot of clients like you. People who took the project 90% of the way themselves."

Three or four more calls in the same shape over the following weeks really ground it in. This was the new top of our funnel. If our value was "we can build it for you," our value was about to be zero.

Under the hood

What pulled me out of the spiral was actually looking at the apps.

They looked great on live demos. Some even had a handful of real beta users. Then we'd ask about the code architecture, or the deployment pipeline, or logging, backups, security. Blank stares. Or we'd go look ourselves and find horrors.

The clearest framing I've heard for this came from my account lead. He used it with a client last week, and I've been stealing it ever since:

Everything that was asked for got built. Every room is legitimately in the ship. But the ship is not a ship. It's a set of rooms floating next to each other. The moment the ship hits water, everything floods.

I keep coming back to this metaphor whenever the existential crisis creeps back (usually after a new round of AI hype). Yes, AI will keep getting better at building what you ask for. What doesn't improve on the AI's side is knowing what you should have asked for. For a passenger-prompted app to actually hold up, the AI would have to upskill the prompter into a shipbuilder. An explanation can only be simplified so far before it stops being accurate enough to decide from. The ceiling isn't the AI. It's the passenger.

The one who stopped, and the one who didn't

Both cases below draw from real engagements. Industries and identifying details have been changed to protect client confidentiality. The technical findings are real.

Two cases from this month make the pattern visible.

Client one. A COO at a medium size grant-services firm. Her CEO asked her to eliminate the team's busywork. She opened Claude Code and, over sixty days of evenings and weekends, built them an internal client-management and workflow-tracking app. Vercel, Supabase, Microsoft auth, document upload, email integration, the works. She showed it to her coworkers and, by her words, they "were picking their jaws off the floor."

Then she stopped. She'd set up a QC step "kind of loose on purpose" because she knew her coworkers wouldn't use anything rigid. But she'd hit the ceiling of what she could evaluate herself, and she knew it. "I don't know what I don't know," she told me in the first meeting. "So maybe there's something I just don't know to be worried about."

On a first-pass review her codebase actually looked pretty good. Claude Code's default output is usually fine at a surface level. The deeper pass was a different story. The build script ran prisma db push --accept-data-loss on every deploy, meaning any schema change could silently drop production data. She'd been developing locally against a Supabase database while production actually ran on a completely different Neon instance. She didn't realize the two weren't connected, and Claude Code hadn't flagged it either. Fourteen API routes were completely unauthenticated, including admin endpoints exposing contact PII.

If she'd pushed on without the audit, the most likely outcome was some combination of silent data loss on a deploy, a security breach via the open admin routes, or a codebase too entangled to recover.

Client two, the contrast. A financial planner building a practice-management platform (client onboarding, portfolio tracking, document management, billing, compliance reporting) as a commercial B2B product for other advisory firms. Bootstrapped from personal savings. Built solo on Replit using AI. By the time we got on the discovery call, she'd done several demos, had more firms in the pipeline, and had a target launch date a month out.

She had also, the week before, signed a contract with a SOC 2 compliance firm. SOC 2 Type 2 is the enterprise-grade security attestation. It requires demonstrating six to twelve months of operational controls.

My team found over a hundred issues in the first six hours of audit. The backend was a single seventeen-thousand-line file. There was no tenant isolation, which for a multi-tenant financial app means any advisor at any firm could hypothetically pull another firm's client records and portfolio data by URL. Payment tokens were generated with Math.random(). A production API key for a third-party document service was hardcoded into frontend code shipped to every user's browser. Client custodial account balances - the kind that trigger regulatory action when they're wrong - were read and written without a database lock. Her actual state was a product with zero working access controls.

On the call, she said something I suspect every vibe coder comes to eventually. The later they get there, the more expensive it is:

She isn't reckless. Reckless would require her to have known what she was missing. Shes a real financial professional with real domain expertise in an industry that genuinely needs better tooling. She saw a gap, used the tools available, built something impressive. The tools didn't tell her when to stop. The AI told her, every feature along the way, "yes, I did it, it's perfect." And she believed it, because she had no other reference point.

Two founders. Same tools. Different outcomes. The difference wasn't capability. It was knowing where the boundary was. The first one knew because she'd spent a career running a 22-person company and had developed the instinct that when something is load-bearing, you call someone who knows what load-bearing means.

What this means for the agency

I'm rewriting our landing page this month. The pitch used to be about building software. Now it's about owning whether the thing actually works in the real business it's deployed into. Whether it holds under load. Whether it survives a regulator. Whether it stays in sync with a workflow that changes every quarter.

I'm still figuring this part out. I don't have a neat playbook for what a sustainable AI consultancy looks like in 2028 - nobody does. But I know what we're investing in: getting deep enough into specific industries (legal, healthcare, professional services) that we accumulate the business context an LLM can't.

And I know what we're not doing anymore. The month I described at the top, where I was a copy-paste bridge and charging for it: that was brief, maybe six weeks. Most agencies are still inside that window and not saying so out loud. The honest version is that a lot of "developer hours" are AI hours with a human copy-pasting, and the invoice doesn't distinguish. Going forward, clients pay for human time and judgment. AI compute is overhead. If a problem can be solved by handing it to Claude unsupervised, we shouldnt be charging for it, and we're going to stop pretending otherwise.

The bet

So here's the bet I'm making with the agency.

Code will be effectively free. But the ceiling I described will hold for a long time. The limitation isn't the AI, it's the passenger. The work that matters stays stubbornly human: understanding a business deeply enough over time to be trusted with its outcomes, owning the consequences when something goes wrong, knowing where the load-bearing walls are. Not because humans are magical, but because knowing what to ask for is still the whole game, and AI hasn't changed that yet.

That's a narrower strip of ground than agencies used to stand on. "We write good code" is gone. What's left is knowing which questions to ask before the first line gets written.

The COO at the grant-services firm understood this, I think, in the second meeting. She said, "I'm willing to be your guinea pig, because I know that this is new." She was telling me she knew we were both figuring out the rules in real time, and she was okay with that, because the alternative, her and Claude alone, had a ceiling that scared her.

The financial planner building the advisory platform would probably have learned it, eventually. Or she'd keep racing the avalanche and one of her queued firms would discover the cross-firm data leak, and she'd learn it the expensive way.

AI writes the code. We own the outcome. I don't know if that's enough. But it's a better bet than billing for Claude time and hoping nobody notices.