Hold It Loosely: What AI Is Teaching Me About Letting Go

There's a particular kind of pride that comes from building something nobody asked you to build.

A workflow that saves you twenty minutes a day. A clever little tool that does exactly the thing you needed, exactly the way you wanted it. You didn't find it on a shelf. You made it. And every time it works, there's a quiet hum of satisfaction — I built that.

I've been collecting that feeling for thirty years.

Thirty years of writing software is thirty years of accumulating attachment. To your code. To your patterns. To the architecture you'd defend in a meeting and the conventions you'd die on a hill for. The things you make stop feeling like output and start feeling like you. Your taste, your judgment, your fingerprints on the world.

Which is exactly why what's happening right now is so hard.

Because AI isn't just changing how I build software. It's quietly dismantling the thing my pride was standing on — and asking me to be okay with it.

The Half-Life of Cleverness

Here's what nobody prepared me for: the speed.

Something I built six months ago as a genuine edge — a workflow that didn't exist anywhere else, a real bit of innovation — is now a checkbox in a framework. Built into the box. Shipped to everyone. The clever thing I made isn't clever anymore. It's table stakes.

This isn't new in software. Frameworks have always absorbed the patterns that came before them. What's new is the interval. The gap between "I made something nobody else has" and "it ships by default" used to be measured in years. Then it was months. Now, sometimes, it's weeks — fast enough that if you blink, you miss the window where your clever thing was actually clever.

Cleverness has a half-life now. Whatever advantage you build, assume it decays — and assume it decays faster than you'd like. The thing you're proud of today is the default tomorrow.

That's not a tragedy. It's just the new physics. The trouble is that thirty years of instinct doesn't recalibrate on a dime.

My Workflows Got Absorbed (and I Still Won't Let Go)

Let me get specific, because this stopped being abstract for me a while ago.

I've spent the better part of a year building out custom Claude Code workflows — skills, tools, slash commands, the whole apparatus. Automation tuned to exactly how I work. I wrote about a lot of it on this blog. It was genuinely useful, and yes, I was proud of it.

Today, I'd estimate 90% of that custom workflow automation now ships out of the box. The features I painstakingly assembled are native. Better integrated than mine. Maintained by people whose full-time job is maintaining them.

By every rational measure, this is a gift. I should rip out my homegrown stuff, switch to the native features, and reclaim all the time I spent keeping my versions alive.

Here's my confession: I haven't.

I still run my own. I know the native versions work — I've watched them work. But some stubborn part of me won't pull the trigger, because I'm afraid of the regression. Afraid the thing I trust, the thing I've tuned to my exact muscle memory, will behave just differently enough to break my flow. So I keep maintaining a system I no longer need to maintain. I keep watering a plant that the greenhouse now grows for free.

And the irony isn't lost on me. I'm sitting here writing a blog post about letting go while actively refusing to let go of the most obvious thing on my list.

That's the gap, isn't it? Between knowing and doing. I can explain the half-life of cleverness all day long. Living it — actually opening my hand and releasing something that still works — is a different muscle entirely. One I apparently haven't built yet.

Months of Design, Replaced by a Session

The workflows at least faded gradually. The design work happened all at once, and that one stung in a different way.

I am not a designer. I've never pretended to be. For years, getting a UI from "functional" to "actually looks intentional" was a slow, iterative grind — mockups, revisions, second-guessing, the long tail of nudging padding by two pixels at a time. Months of accumulated effort across projects, much of it just me fighting my own lack of design instinct.

Then I sat down with Claude for design work and Google Stitch, and watched months of that grind compress into an afternoon.

Not "good enough" output. Good output. Coherent design systems, thoughtful layouts, the kind of polish I'd have hired for in another life. Generated in a session, refined in conversation, done before dinner.

I should have felt nothing but relief. Mostly I did. But there was a smaller, quieter feeling underneath it — the feeling of watching something I'd worked hard at become something you just... ask for. The struggle wasn't valuable in itself. Still, it was mine, and now it isn't.

When Software Becomes Nearly Disposable

Here's where it all points, and it took me a while to say it out loud: when building is this cheap, the thing you build matters less than the fact that you can build it.

Software is becoming nearly disposable.

I don't mean low-quality. I mean low-stakes. When you can spike an entire idea in an evening — wire it up, see it run, decide if it's any good — the artifact stops being precious. It becomes an experiment. A question you ask by building the answer, fully expecting to throw most of it away.

I've started doing things I'd never have justified before. Building three versions of a feature just to feel which one is right. Standing up a whole prototype to validate a hunch I'd previously have argued about in my head for a week. Treating code as something I try, not something I enshrine.

It's liberating. It's also disorienting, because every instinct I've trained for three decades says the thing you make is precious — protect it, maintain it, defend it. That instinct served me well when making things was expensive. It's actively in my way now that making things is cheap.

The lifespan of what I build is shorter than it's ever been. The right response isn't to build less. It's to build loosely — to create with the full expectation that this, too, will be absorbed, replaced, or thrown away. And to be okay with that going in.

The Hard Part Isn't Technical

None of this is a tooling problem. I can learn the new tools. Learning the tools is the easy part — it always has been.

The hard part is emotional. It's detaching my sense of worth from the artifacts I produce. It's separating I am good at this from the specific thing I made is valuable and permanent. Those two things felt like the same sentence for thirty years. They aren't, and AI is forcing me to learn the difference whether I like it or not.

Letting go doesn't mean caring less. That's the trap I keep almost falling into — the fear that if nothing I build is permanent, then nothing I build matters, so why care at all?

That's backwards. Holding something loosely isn't the same as not holding it. It means caring about the right thing. Not the artifact — the judgment behind it. Not the workflow I built — the taste that told me it was worth building. Not the design I labored over — the eye that knows good from "fine."

The output is disposable. The capability that produced it is not. That's the part worth keeping, and it turns out it's the only part the tools can't absorb.

The New Posture

So I'm trying to learn a new way of standing.

Keep experimenting — more than ever, actually, because experiments are nearly free now. Build the spike. Try the three versions. Chase the hunch. But hold all of it loosely, with the full knowledge that its lifespan is short and getting shorter. Build like you're sketching, not like you're carving in stone.

What endures isn't the code, the workflow, or the design. It's the taste that knows what good looks like. The judgment that knows what's worth building. The willingness to keep moving when the ground shifts under you again — and it will, probably next month.

I'm not all the way there. I told you — I still haven't deleted those custom workflows. They're sitting right there, working fine, native replacements waiting patiently for me to trust them. Maybe by the time you read this I'll have let them go. Maybe not. Letting go, it turns out, isn't a decision you make once. It's a practice. A thing you get a little better at each time the ground moves.

Thirty years taught me to hold on. I'm spending this next stretch learning to hold loosely.

Easier said than done. But I'm working on it.

–Jeremy