Deal!

"brilliant for the right problems, absolute quicksand for the wrong ones"

May have to steal that line, sums it up perfectly :)

Indeed.

That's not to say there aren't times it works well, but there are also plenty of times when it really doesn't!

AI coding risks having us all spin around in circles doing more work than ever, while simultaneously failing to make progress towards our goals.

Hell, half the time we don't even know what those goals are!

Beware AI doesn't turn you into a busy fool.

Instead I needed to use the tools I already had, and run some experiments around building better habits.

Building stuff won't fix your habits, or your processes, however shiny the tools you use, or the solution you end up with.

Here's a more effective approach.

Spend time reflecting on the problem, your goals, and coming up with theories on how you could address those problems to meet your goals.

I've started doing this of late, and every time I've tried it, the answer wasn't to build software.

The cost of building is so low, thanks to AI, that we jump into that mode and start creating software.

Eventually, when the software doesn't actually fix the problem, we abandon it, or decide to start again and build a better solution this time,

There's a notable fail mode I see being amplified by AI right now.

Especially for developers.

We decide we want to build something, because we have a problem and feel like building something will help us fix it.

So, with AI, we can generate more code!

MOAR CODE!

Or... we can use it to help us think through what we're building, and why.

And question whether we need to build anything at all, or at least hold off until we've analysed the business problem first.

It works particularly well when you narrow the scope of what you task the AI to do in the first place too.

Anything that gives AI a way to check, and course-correct, just after it's made changes, seems to yield much better results.

I've found that effective feedback loops go a long way to balancing out the differences between the various models too.

The more I use AI for coding the more I realise feedback loops are vital now.

(side note, they always were)

Linters, compile checks, tests, extensions to test the UI in the browser, code quality reviews.

Experiment with the tools, different ways to prompt them to write code, add features to your app.

Not from fear, but with curiosity and a desire to use the leverage AI gives you, to build better things.

Other than to suggest stepping away from the keyboard every now and then.

Go for a walk, talk to people who aren't steeped in this stuff all day every day. Have 'normal' conversations.

Then, bring that energy back to your keyboard.

It means you're human (no not you, Mythos, if you're reading this).

You're trying to handle change, feed your family, and pay the bills in uncertain times.

Change is scary.

I don't have any magical advice for handling that anxiety, if you're feeling it.

It's OK to feel unmoored by the noise around AI right now.

If you're wondering how it impacts your role as a software engineer or manager, I got ya.

I'm feeling it too.

It's OK to feel curious, skeptical, excited, fearful, all at the same time.

Ha yeah, definitely done that too, it's like junk food in that regard, you know it's bad for you, but it's just so tempting :)

Yes it's more work up front, but by the time AI gets to work on the implementation it invariably produces better results.

AND it keeps me thinking, designing, in the loop.

Which means lots of careful planning for any given feature, getting clear on what I'm building, mapping the feature to modules in the codebase, breaking the work down into smaller tasks.

The best results I've experienced when coding with AI have come when I narrow the scope of what I'm asking it to do.

or, you know, spend a few weeks building your own screen capture/recording app and then only record one or two videos because you got distracted.

This also happens sometimes, apparently.

Getting into a habit of recording more videos and publishing them.

And I'm reminded that things like this are a great way to push past perfectionism, and ship the dodgy first 1, 2, 10 videos, knowing it's all part of the process.

If there's one thing I'm very glad to have tools like Claude Code help me with it's merge conflicts!

I've had a few to deal with recently and it's sorted them out every time.

Ten Months with Copilot Coding Agent in dotnet/runtime - .NET Blog After ten months using GitHub Copilot Coding Agent (CCA) in dotnet/runtime, the .NET team shares data-driven lessons on cloud-AI-assisted development.

"If there’s one lesson from this experience, it’s this: preparation matters more than the model."

100% this.

Matches my experience - get the scaffolding right and the model matters a lot less.

devblogs.microsoft.com/dotnet/ten-...

I increasingly find my main role with AI coding is to notice when it's guessing, and give it the tools to stop, look at the evidence, and go from there.

Even better when that can be done up front, to reduce the times when AI starts guessing in the first place.

I often think how different parenting in the era of social media would feel if we all started sharing the real stuff! The arguments, the stand-offs, the negotiations, basically all the other stuff that plugs the gaps between the shareable moments.

Never change Jeff!

I've been thinking about this ever since AI started gaining so much traction - that there could be a counter-reaction where people lean into human relationships more (and trust becomes increasingly more important and valuable)

It feels like good code architecture matters more now than ever.

Messy codebase? Messy AI results.

Clean boundaries, consistent boundaries? Generally better results (albeit you still have to remind it sometimes).

Something I've noticed using Claude Code.

When you give it guidance on coding standards, dos and don'ts etc. it will often violate those standards when it generates the code, but nearly always identifies those violations when you run the same guidance as a review step later.