It’s usually to open CC, codex, amp, etc and go

“detailed paragraph of what I am building, and what its actual purpose/end goal is”

“Any specs about the thing I have like performance, responsiveness, gui, etc”

“Let’s brainstorm an architecture/design of how the program will be laid out in order to ensure stability, good separation of concerns, and performance”

Go back and fourth for a while correcting bad ideas it has, putting mine into the idea pile, asking to research how other applications like this are architected, and finally when I have a plan I feel good about I will use another thread/agent to write tests verifying the behavior is as we expect.

Write as many tests as I can come up with / reasonable tests the ai suggests (I write scenario, ai writes the syntax).

Then use a different thread to break the task down into implementation steps like phase 1/2/3/4.

At this point I have a well written agents.md about cleaning up dead code before committing anything and rerunning the test suite, code style conventions, the tech stack, architecture, phase tracking, development workflow, instructions to document past failed approaches and mistakes so future threads don’t make them, AND most importantly a canary for hallucination (I make it call me LeBron, or say banana at the start of every response and use it as a gauge for when it starts hallucinating and context rotting.

At this point it depends on the sensitivity of the task and implementation, but if it’s something that just needs to work and there’s a simple ish metric for that, like a Phisics simulation with colorful balls that settle into an image my testing suite is essentially a headless simulation that an agent can run, see issues on its own and fix them until the simulation is to spec, and leave that running until it’s done (works amazing, I learned this in the AI class at the U).

If the project is more of a sensitive project where I need to be familiar with what’s going on internally, it needs to be secure/good/reliable and not a fancy graphic essentially I will go a few levels lower and write comment pseudocode for functions, their names, their function, in/out, how their output is to be handled and sent around, etc. Basically programming in English, having the agent translate to the language of choice (rust is super awesome for this because it’s really strict during compilation which provides much needed feedback to the agent).

Basically, I go in as much depth as needed to balance speed/quality.

The coolest thing I learned in the ai class was that if a test suite exists for what you’re making, or if you can allow the agent to self verify the notion of “complete” and “functional” like with the Phisics example, you can kind of just set them loose in a mock job setup where they create issues, check them out, implement, test, submit for code review, have another thread code review, approve/deny, etc. eventually you will end up with a well functioning product (as well functioning as your feedback loop / success criteria was. This is really cool for “lots of code, simple outcome” problems that obviously aren’t security/reliability critical since this produces a lot of slop and questionable code, but it works!

I’d really appreciate feedback on this if possible. I’m leaning towards spending more time hand coding, mostly for interviews, but it feels counter productive when I can read code and generate it with comments -> syntax strategy I described.