The code is the boring part

The thing nobody tells you about AI agents: the code is the boring part.

I run PointAuctions.com, a loyalty-program auction aggregator, almost entirely through Claude Code, on a couple of hours a week. I've written about how the site got built by someone who can't read the code it runs on. This post is about what happened after it was built, because two recent incidents changed how I think about what these agents actually are.

Incident one: it caught an intruder

I asked Claude to look over my traffic. What came back was something genuinely off in Google Analytics: my apparent traffic had roughly doubled, and the growth wasn't people. At the time, real traffic on the site ran a couple hundred sessions a week. Sitting on top of it was a single visitor fingerprint out of Singapore that had racked up over 1,000 sessions in about six weeks.

The detection is the part worth slowing down on, because no single signal proved anything. It was the stack of them: every session on a fixed 1280x1200 viewport (a headless-browser default, not a real monitor), a fresh client ID on every visit, exactly one page per session, visits spread flat around the clock the way no human timezone behaves, all Direct channel, all claiming Chrome on Windows. It was walking my listing, blog, and category pages one page at a time, every day, peaking around 70 sessions a day. A scraper on a schedule. It even executed JavaScript, which is the only reason it showed up in analytics at all.

Then Claude fixed it. It drafted a firewall rule for my hosting platform and applied it through Vercel's API: traffic from Singapore with a Windows user agent now gets a JavaScript challenge before the site loads. Notice how much judgment is packed in there. A challenge rather than a hard block, so a real person in Singapore on a Windows laptop passes through without ever knowing. Conditions written so search-engine crawlers can never match the rule. Scoped to the actual fingerprint instead of "block the country." The rule went live that night, and the bot hasn't been seen since.

I didn't write a firewall rule. I didn't open a dashboard. The agent observed a live system, diagnosed the problem, and shipped a proportionate, reversible fix, end to end.

Incident two: a data consult I could never afford

The second incident was slower and, honestly, more valuable.

I gave Claude read access to my Google Search Console and Analytics data. The mechanics are unglamorous: a Google service account, which Claude queries by writing little scripts on the fly. No fancy integration existed for the shape of analysis I wanted, and it turned out not to matter. Access was enough.

Then we did what a search consultant would charge real money for: read the actual queries people type before they find the site, and hunt for the gaps. The finding that drove everything else: about 80% of my clicks come from ultra-long-tail queries landing on individual listing pages. Nobody searches for my category. They search for the specific, named thing, and the site that has a page about the specific named thing wins.

The data got specific in a way gut feel never could. "Hilton auction" was pulling impressions at position 38 with no page on my site built to answer it, while my own database held 83 closed Hilton auctions with verified prices. One listing was earning 94 impressions at position 7 and zero clicks. Every line like that is a content brief hiding in plain sight.

Out of that analysis came a backlog of 25 post topics mined from queries the site was almost ranking for. Then the same working thread wrote the posts and scheduled them out: as I write this, the queue has 36 posts scheduled for the next 7 months, spaced on a deliberately human cadence (three-to-seven-day gaps, never metronomic). Each post carries a future timestamp and goes live when its moment passes. No deploy, no cron job, nobody at a keyboard.

Strategy, build, and execution, one continuous thread of work. For a solo operator, that's not a productivity gain. That's a job function I didn't have.

What actually changed

I used to think of AI as something that writes code. It does, and it's genuinely good at it. But code generation is the smallest part of what made those two incidents possible. The leap is elsewhere: an agent that can observe your live systems and act on them.

Break down what that took, because it's less magic than it sounds:

• Eyes: read access to real operational data. For me that's a mix of MCP connectors (the open standard that lets a model operate other software) and a plain service account Claude queries with scripts when no connector exists.
• Hands: scoped write access where fixes happen, like the hosting platform's API and the site's own publishing pipeline.
• Judgment in the loop: the model deciding what's anomalous, what to investigate next, and what a proportionate fix looks like.

The access wiring is the unglamorous part, and it's most of the setup work. But once it exists, the same wiring serves every future task. The bot investigation and the content strategy used the same eyes.

One thing I'd say to anyone nervous about the "hands" part: you decide where the approval gates sit. My agents propose more than they execute, and anything irreversible or outward-facing still comes to me first. The point isn't removing the human. It's that the human stops being the one gathering, correlating, and typing.

The team-of-one math

I work on this project a couple of hours per week. With the right access, those hours feel like managing a small team: an analyst watching traffic, a security person handling abuse, an SEO consultant reading search data, a content operation shipping on schedule into January. None of those people exist. The site mostly doesn't notice.

If you run anything with real traffic and real infrastructure, the practical starting point is smaller than you'd think: wire up read-only access to your analytics, and ask an open-ended question like "look over my traffic and tell me what's odd." Let it earn the hands after you've seen the eyes work.

The code was never the point. The code is the boring part.