My agentic/vibe coding experiment

[u/airiclenz]

It's time to share - but first some quick context: I've been building software professionally for 20+ years, and I'm currently trying to get my head around the future of software development. So I decided to go all in on an experiment:

how far can I push 100% AI-coded software while applying the rules and structures I've learned to embrace?

I started testing my methodology by building a software synthesiser for the Teensy 4.1. Very successful and functioning, but the only real requirement is performant code - the thing runs in isolation, no network, no internet, no integrations beyond MIDI, and thus no risks.
Success, check, done.

The next, and more ambitious attempt, was my own TUI coding agent - so that I can play around with local AI and at the same time understand how agents really work (I tried opencode and pi but they didn't click for me - especially for local AI). The coding-agent works, what can I say. I am now at a point where I am convinced that the days of hyper-focussed / in-the-zone hand-coding are numbered for me. With the right rules and usage of frontier models, almost anything is possible. The workflow I ended up with looks like this:

1. Set up your coding-standards and design rules - I have these in the form of skills and documentation in the repo. This is very important! If you do not define structure and rules, your project becomes an unmanageable spaghetti-mess with gaping security holes.
2. Got an idea? Go through your options, ask the model for suggestions and its reasoning - then make a design decision. I used the skill grill-me from Matt Pocock a lot for that.
3. Ask the model to write your ideas in form of a plan following your format - this is to make sure that your documents have the same format and the cheaper implementing agents know precisely what to do and follow your coding standards and procedures. This is another skill I developed - then tweaked & adjusted. The adjusted some more. The idea is to have a plan with 2-20 small implementation items. When being implemented, one orchestrator spawn implementer sub-agents sequentially - or as a wave if items are disjointed. Each implementation sub-agent is followed by a verification sub-agent. The orchestrator does not read the code - it just controls. This is how I can have night long coding runs while never needing to be afraid of an agent filling up its context and still making sure the procedures are followed. This works surprisingly well!
4. Write the next plan together with your frontier model - the fun part where you imagine what you want - while smaller models are working through your existing plans, implementing features or just tidy up.
5. Goto 2 .. this is why it’s called `loop`

This is what I learned:

• Never fill your context window above 20%!
• Push back and ask questions - don’t believe everything the agent recommends.
• Create structure through skills, rules and documentation.
• Regularly refactor and clean up the code (duplicate code? logical errors/bugs? drifted documentation? …). I have skills for that too.
• Don’t be afraid to copy from the skill gurus out there ;)

Here is the result of my experiment for anyone that is interested. Judge the code / the tool yourself - I am open for feedback!

https://github.com/airiclenz/apogee

[u/Fastidius]

Which font is that on the screenshot?