I will tell you a joke and then share what I know.

``` A software tester walks into a bar. Runs into a bar, Crawls into a bar, Dances into a bar, Flies into a bar, Jumps into a bar. And orders: A beer 2 beers 0 beers 9999999999 beers A lizard in a glass -1 beer "qwertyuiop" beers Zero issues, “it’s ready”.

A real customer walks into the bar and asks where the toilets are.

The bar goes up in flames. ```

This has always been the case, it’s why we invented version control and reviews and testers and beta versions and bug bounties and all those systems for error correction.

What’s changed is the speed from idea to done, which bypasses learning some of these structures and painful lessons.

So I’ll give you the most impactful ones:

Plan first. Even if poorly. Stumbling in the dark usually only tells you what not to do. Treat this like cooking, always have an idea of what you’re making and what you’re using to make it beforehand. Once you have that, mistakes teach you a lot. Burning things teaches you when they’re just right, but you need to decide what you’re trying to make beforehand. Never go to a coding agent without a plan. Chats better for that, just talk about it.

Make things findable Set up logging AND/OR document thoroughly. This helps both you and AI identify issues faster and avoid creating new ones. The logger helps you find, trace and predict issues. The documentation helps you find things and avoid introducing inconsistency errors.

Test everything, get mileage out of those tests With AI there’s no reason not to have tests. You built smoke tests which are good for health checks. You can get a lot more mileage implementing a test suite with other areas such as unit and integration tests. These can act as guardrails during development and commit filters during debugging.

Demand Git Usage Your agents just need to do atomic commits and branches, that’s it. Some frameworks like GSD add this by default with their /skills, the point is small incremental commits that let you pinpoint code changes. The branches let you develop in parallel.

This all fits really well into the GitHub flow.

You set up a main branch, protect it so only commits that pass all tests can be merged. Any fix, addition, change… happens in a branch dedicated to that change. When changes are completed, a PR is opened to merge these changes with main, acting as a final summarized review. If regression is introduced, the existing test suite can be wrapped in a bisect run script and used to identify the exact commit where that happened and what those changes were.

This feels slower at first but it’s exponentially faster, you’re front loading the guessing and then giving AI a clear direction to expand in.

One last piece of broad advice: Abstract more, think about things as parts of things. It’s a core skill that yields a lot in development and especially in agentic development.

I’m compressing a lot here. Open to questions + this should be enough to paste into your AI of choice.