Something hit me the other day. I was staring at a Claude Code session — half-built feature, three CLAUDE.md files tuned just right, a custom slash command I’d spent an hour writing — and I thought: this is incredible, and also… are we there yet?

The honest answer is no. But we’re close enough that the shape of “there” is visible, and that’s the part worth writing about.

The joy is realLink to heading

I can’t overstate how much AI has changed the way I work. I went from writing every line by hand to orchestrating features through conversation. I build things in hours that used to take days. I ship side projects that would’ve died in my head.

That first time Claude Code scaffolded an entire Supabase schema, wrote the RLS policies, and wired up the frontend — I just sat there. It felt like cheating. It felt like the future arriving on a Tuesday afternoon.

And it keeps compounding. The more I invest in my setup — rules files, PRDs, slash commands, modular context — the better the output gets. Week over week, I’m faster. That feedback loop is addictive.

The stress nobody talks aboutLink to heading

But there’s a weight that comes with it.

Every week there’s a new tool, a new mode, a new way to configure your agent. Claude Code Remote just dropped and my first thought wasn’t excitement — it was great, another thing I need to learn and set up before I fall behind.

The configuration tax is real. I spend serious time tuning CLAUDE.md files, writing commands, structuring context, resetting conversations at the right moment. It works — but it’s a second job on top of the actual job. And if you skip it, the output quality drops fast.

There’s also this low-grade anxiety that the way I’m working right now will be obsolete in three months. I built a whole workflow around context resets and plan-then-execute cycles. What happens when the next model just… doesn’t need that?

The confusionLink to heading

Here’s the part I don’t see enough people admit: it’s confusing.

Not the tools themselves — those I can learn. The confusion is about identity. I’ve spent years getting good at writing code. Reading a stack trace, refactoring a gnarly function, knowing when an abstraction is worth it — that was the craft. That was what made me me as a developer.

Now the craft is shifting. Writing code by hand is starting to feel like a deprecated art. Not gone — not yet — but the center of gravity is moving. The skill that matters most isn’t writing the code anymore. It’s knowing what to ask for, how to structure the context, and when to intervene.

Managing agents to build a feature is becoming the job. And I think that’s the future. But it’s a weird grief to carry — being excited about where things are going while mourning the thing you spent years learning.

It’s still not thereLink to heading

Even with all the progress, the cracks show up constantly.

The AI drifts. It hallucinates file paths. It “fixes” things that weren’t broken. You hand it a well-structured plan and it still invents abstractions you didn’t ask for. You configure everything perfectly and it still surprises you in ways that cost an hour.

Claude Code Remote feels like a glimpse of what’s coming — agents running autonomously, executing plans while you sleep. But right now it’s early. You configure, you babysit, you iterate on the config. The promise is set it and forget it. The reality is set it and watch it carefully.

I keep pulling off impressive things. But each one requires more setup than I expected. The gap between “this is possible” and “this is easy” is still wide.

Where I think this landsLink to heading

Despite all that, I’m betting on this direction. Here’s why.

Every month, the configuration tax gets a little lower. The models get smarter. The tooling gets better. The patterns stabilize. I’m already doing things that were impossible a year ago — and not just possible now, but routine.

Writing code isn’t going away tomorrow. But the ratio is shifting.

I used to spend 80% of my time writing code and 20% planning. Now it’s closer to the inverse — and that 20% is shrinking.

The developers who thrive in this next phase won’t be the ones who write the fastest code. They’ll be the ones who give the clearest instructions, build the best context systems, and know when to let the agent run versus when to take the wheel.

That’s a different skill set. It’s one I’m still building. And some days it’s thrilling and some days it’s exhausting and most days it’s both.

What I keep coming back toLink to heading

AI has changed everything about how I build software. The speed, the ambition, the scale of what one person can ship — none of that existed a year ago.

But nothing feels finished. The tools outpace the workflows. The workflows outpace the habits. And the habits haven’t caught up to the identity shift.

I’m not complaining. I’m just being honest about what it feels like to live through a transition that everyone says is the future while you’re still configuring your way through the present.

We’ll get there. We’re just not there yet.