Cowboy Shit

This is not the kind of story that sounds impressive if you inflate it. It’s this site. tonyseets.com. No payments, no giant user base, no compliance team, no complicated org chart. Just content, some interactive bits, a contact flow, and a lot of opinionated details that I care about more than any rational person should.

Which is exactly why it feels worth writing down. Because this was also absolutely some cowboy shit.

Not reckless cowboy shit. More like: the tools are suddenly good enough that you can point them at a real project, give them a long enough leash, stay in the loop at the right moments, and watch an amount of work happen that would have felt fake not very long ago.

The setup#

The assignment was not tiny. Move this site from Astro 5 on Cloudflare Pages to Astro 6 beta on Cloudflare Workers. Keep the public site aligned. Keep feature-flagged sections dark in production. Rework the CSP setup. Deal with a patch that reached into Astro’s old router internals. Verify performance. Compare old Pages behavior to new Workers behavior. Do iOS navigation checks. Keep the plan and logs updated. Write the colophon afterward.

Not moon landing stuff, but also not “change one line and redeploy.” It’s the kind of work that normally gets scattered across a few focused sessions, a couple rabbit holes, a few regressions, and a bunch of “wait, why is that broken now?” moments. Which, to be clear, still happened.

The part that felt different#

The thing that hit me was the time compression. An agent got turned loose on this for hours. It did the migration work, adjusted to the repo’s quirks, updated plans, found breakages, fixed a lot of them, ran builds, ran audits, deployed preview Workers, compared outputs, and kept chewing through follow-up issues.

Then I stepped in for the human parts:

• Put the right secrets where they needed to go
• Clicked the Cloudflare domain handoff stuff
• Sanity-checked physical iOS behavior
• Reacted to edge cases and aesthetic nits

That sequence matters. I’ll be honest: I was eating lunch for part of it. But I wasn’t checked out. I was watching the loop, dipping in when something looked off, letting it run when it didn’t. The ratio just changed. The machine did an absurd amount of the legwork. I stayed in the loop for direction, taste, credentials, and the handful of decisions that actually deserved a human. That’s the part that feels new.

The timeline that would have sounded fake#

1. Site moved to a beta framework and a different runtime
2. Preview got stood up
3. Performance got measured against the old setup
4. Regressions got chased down
5. Tweet embeds broke and got rebuilt around a prebuild cache
6. Link previews broke and got fixed
7. Mermaid diagrams regressed and got fixed
8. Public domains got flipped from Pages to Workers
9. Site got massaged in production

If you describe all of that at once, it sounds like chaos. But it didn’t feel chaotic in the same old way. It felt like an unusually intense review loop with an extremely tireless pair programmer.

That might be the biggest change. Not that the tools never mess up, they absolutely do. It’s that the mess-ups are increasingly embedded inside a larger amount of useful motion.

Small potatoes, real work#

I want to be careful not to oversell this. This is not an enterprise transformation story. It’s not AGI. It’s not “one person replaces a whole engineering org.” It’s small potatoes.

But small potatoes are where a lot of real work lives. Personal sites. Consulting sites. Internal tools. Marketing sites with weird auth edges. Opinionated little systems that matter intensely to the person running them and not much to the rest of the planet.

That category is huge.

And if an agent can help push that kind of project through a migration, a platform change, a performance pass, a production cutover, and a stabilization loop with relatively little hands-on from me, that is already a pretty big deal. Not because it makes the work glamorous. Because it changes the threshold for what one person can reasonably attempt.

The human role didn’t disappear#

This only worked because I still had to do human things. I had to notice weird design failures, say “that copy sucks, fix it,” know what should stay dark in production, know which secrets mattered and where they belonged. I had to be the taste layer. I had to be the final judge of “is this actually right?”

The tool did not become me. It became an extremely capable system for chewing through implementation, investigation, repetition, and verification while I kept steering intent and standards. Maybe that sounds obvious. It did not feel obvious in practice.

Clay on the wheel#

Geoffrey Huntley has this concept he calls software is clay on the pottery wheel. If something isn’t right, you throw it back on the wheel and keep going.

That’s exactly what steering a long-running agent task feels like. The agent drifts, you jump in. It misinterprets a constraint, you correct it. It breaks something, you have it check its work, validate against docs, run the tests, get back on track. The cycle is fast enough now that it doesn’t feel like debugging someone else’s mess. It feels like shaping.

This is one of the first models where that loop actually works. Where you can give it enough context, let it run, steer when needed, and trust the output enough to ship it. The rate of acceleration is the part I keep coming back to. Each generation makes the loop tighter. Each tighter loop makes more ambitious work feel reasonable.

Why this qualifies as cowboy shit anyway#

Because we shipped a beta framework, changed runtimes, and moved production traffic on this site. Because a huge chunk of the execution came from an AI loop instead of the old pattern of me manually pecking through every step. Because the whole thing still sounds slightly unreasonable if you say it too fast. And because the end state was not a demo. The site actually moved.

That is cowboy shit to me. Not because it was sloppy. Because it involved enough trust in new tools, enough motion, and enough “well, I guess we’re doing this now” energy to feel like a frontier move, even if the project itself is small.

Presto bango#

That’s maybe the funniest part. From far enough away, the story almost compresses down into this: an agent worked for a long time, I set some secrets on a Worker, I clicked the domain handoff, we fixed a handful of regressions. Presto bango: the site moved from Pages to Workers, got a little better in a few places, got weird in a few places, and then got cleaned up.

That summary is both unfair and basically true. There was a lot of work in the middle. But the middle is getting easier to delegate into loops that are not purely human anymore.

This whole site is a running experiment in that. Every post, every migration, every feature pushed through an agent loop is part of figuring out what this way of working actually looks like over time. I wrote about the roughness of that process in Slop x Slop. This is the sequel: the roughness applied to real infrastructure, not just words.

My suspicion is that it only gets better from here. That’s the thing I can’t stop staring at. Not “AI can do everything now.” Just: this is the kind of thing you can do now. And that is already wild.