What changed?

I've done nothing on this project for weeks, and it feels like a lifetime. At work, I was whisked into a new team which is focused on pushing out a lot of new code using Claude, and I was too busy to find the energy after work for this project.

I've learned a lot about using LLMs to write code. My approach and attitude towards it have changed a lot. I have to admit that I was somewhat fearful of AI: fearful it was going to take our jobs, and fearful we'd lose the art of writing code. I was also cynical about how effective it would be. I thought I'd need to supervise it and treat it like an overly eager and naive junior developer.

How wrong I was. It writes better code than I can, and produces hardly any tech debt. Although we still do human code reviews at work, and still find things that need fixing, on the whole—even if we had not done those human reviews—the code quality has improved from that of human coders. (And I am comparing it to extremely good software developers.)

People still report AI generated code being low quality and causing lots of tech debt. Why aren't we experiencing that?

We gave it strict guidelines. Coding standards, use lint and prettier before every commit. Run multiple different types of AI code/security reviews during every TDD cycle. Strict instructions to minimise inline code comments—make the code more readable instead. The skills we developed are complex documents in and of themselves, checked into a repo, and are the intellectual property of the company.

I've also learned that the single worst bottleneck to development is the human code review. I split my TDD cycles into very small chunks via careful instructions to the LLM about how to divide up the work. This keeps the PRs small enough to be reviewable by a human, but it takes time, and even the fact that the LLM has to do things in smaller chunks actually increases the development time.

I can't use my work skills here in my home project, because they are the IP of my company. But I can do things differently in my home project, because I am a one man team, and I can take risks.

I will dispense with the human review entirely. I'll take an interest in the code, but won't be reviewing it.

I won't do pull requests. The AI reviews will be done on the unstaged changes, rather than the diffs between a branch and main.

I won't use "skills", but will write instructions into the AGENTS.md file. It will initially be quite simple, but will grow as I start using it and refining it. This is quite a different process to what I am using at work, and the AI DLC I developed at work took weeks to refine, and even now, still needs refining.

I'll replace the human review gate in the TDD process with an AI review comparing the spec to the skeletons and new (failing) tests.

I won't force it to do the work in tiny human-reviewable chunks. Instead, I'll get it to do things in logical chunks. This will make it easier for the LLM to review its own code in context.

My focus will be even more on the design/specification stage up front. If I were a member of a team, that is the thing I'd have others review.