How To Code Good With AI
Ok, so, sit down and ask yourself: "how would I do this here engineering task if I had an absurd amount of time to guarantee results? What would the project look like if I could do things correctly from the beginning and not optimize around throughput?" What are the parts of the system? How do they interact? What technology should you be using and why? What are the expected issues and which parts of the system make them non-mission-failures?
Write it down. (Call it a spec, it's basically just some architecture documents.)
See if you can understand how you would execute on it yourself. Consider the steps you would take. Where would you start? How would you organize the work? If you had to go through piece by piece, how would you build the system? How would you verify it? What rules would keep you on track and how would you stay productive? What levels of abstraction and proof-of-concept will you tolerate? Etc.
Write it down. (Call it CLAUDE.md, it's just how you work.)
Think like you would if you had, I dunno, ten little software Minions. They can't step on each other's toes. Figure out what they can do at the same time, and what needs to be done before other things can be begun. Organize a set of tasks that resemble your work stream, parallelized if necessary, and document how they should take on units of work.
Write it down. (Call it a Plan, it's basically just some JIRA Epics. Nasty, I know.)
Ok, go pick your harness. Turn it on. Watch it. Tell it to carry out the units of work you have arranged. You'll probably find it makes a lot of mistakes with your process. Figure out what it is doing wrong.
Write it down. (Call it a Skill, or a rule, or an MCP for your third-party integration. It's just some prompts reducing complexity for the agent as it navigates a context it can't contain or take on tasks with domain-knowledge.)
Ok, now go back to the beginning and figure out how you can automate these processes at large (i.e., agentic code review in CI, useful perpetual tasks that yield background timesaves, and so on).
Notice each time that you're doing the same thing. Once you are in this rhythm, you will find yourself repeating the same tasks, over and over.
Run it all in a loop that keeps track of its own state. (Call it whatever you'd like, as you won't be picky at this point as you see a sort of fool-proof means of materializing functional systems from your thoughts, so long as they are well-organized.)
Literally. Just start at the document you would start at if you were following your own process. Type in "/loop 10m ok do the work stuff in @doc.md plz and keep track of your progress in @task.md" -- you could really improve this, but I am trying to illustrate the simplest example. Complex flows should probably aware of the state of the world, rather than a document, in many ways-- but you'll realize that when your loop starts pushing to a stale branch and you are forced to go fix it.
Sounds like a lot of hard work? Yeah, actually, but, er, you don't have to write any code. Just rigorously verify it. No such thing as a free lunch etc.
You'll find that certain parts of your loops should be common between other loops and process, and suddenly, you'll realize the commonality between this world of loops and the world of process in a dev shop.
Something wrong? My advice is not working? Go back to Advice, Step 1, "How To Code Good With AI." If you can't understand how to do it yourself, you're betting on some oracular knowledge from the LLM.
Proof
https://github.com/oliver-io/personal-site-gen https://github.com/oliver-io/personal-site-gen/blob/main/README.md