Coding agents still need your expertise and judgment

This past week I've been doing a lot of development with coding agents. Which is not new, but I've been doing more than usual.

And even though I'm using what is widely considered to be a cutting-edge and highly capable model...

I have to correct it a LOT.

I've been implementing a parade of new features, improvements and bugfixes on a moderately mature codebase. Like most of us, I rarely create new programs from scratch. Of course I do sometimes. But most of my development work is on a codebase that is not new.

What I have found is that I can often almost "one-shot" a new feature, in a cycle that goes like:

1. Create a branch in version control, and fire up the coding agent in that branch.

2. Write a detailed specification-style prompt, detailing everything I want for the new feature. Go into detail, doing my best to fully specify the changes in UI/UX, any considerations of architecture or code design I want it to follow, and just listing all the things I want it to do and not do.

3. Send that prompt to the coding agent in plan mode, forcing it to tell me how it will proceed. And also giving it a chance to ask me clarifying questions, or even alert me if I made a mistake.

4. Once it seems like it has a good plan, I tell it to work.

5. While I'm waiting, do pushups or mobility stretches (yes, that's what I will often do while the coding agent is working.) Or something else productive, though I find multitasking too much just does not work for me.

6. Once the agent is done, inspect its work.

And that step #6 is where the fun begins.

Because I often am simultaneously:

a. Impressed at how it solved what I consider the hardest parts of the feature, and

b. Kinda shocked at some of the brain-dead decisions it made along the way.

Yes, coding agents still make mistakes, even if you use the best LLM you can buy right now. Things like:

• over-engineers something, making the code way more complex than it needs to be

• pulls in some random new library dependency that is not remotely justified

• outright hallucinates (yes, that still happens) and uses that to make a bad decision

• writes unit tests that are just weird. I mean, I'm glad it is writing tests, but yeesh

• makes presentation-layer UI choices that are... let's say "adventurous"

• fails to follow blatant conventions in the codebase that you'd have to be a drooling idiot to miss

So then I go to the next step:

7. Do a sequence of smaller prompts and/or hand-editing the code, whichever is faster, until the shortcomings are fixed well enough

Just like with human-written code, it doesn't have to be perfect. But it does have to be acceptable.

Such is the state of AI-assisted coding, even now.

And notice I cannot do step #7 unless I have real software development skills, experience and expertise.

The quickest way to develop that expertise is NOT to invest a decade of your life hand-writing code.

That works, mind you. But a faster way is the software development foundations track of Boosted Code.

Quickly teaching you a "cracked engineer" level of knowledge in foundations like:

• object-oriented programming
• test-driven development and automated testing
• writing memory-efficient data-processing algorithms
• higher-order coding patterns (i.e. metaprogramming)
• practical engineering topics like logging, error management, module organization, and more
• carefully studying mature production codebases

This is the oldest part of the Boosted Code curriculum, refined and updated over years as I repeatedly taught it to literally thousands of tech professionals worldwide. So it's as solid and high-quality a training as you will find for these topics.

And these batteries are included in the Boosted Code curriculum. Plus it's integrated with the more modern strategies, techniques and practices you learn in the agentic coding track. Giving you both sides of the equation.

Quite a few of you have signed up already. If not, see what you get here: