Right, languages can help us provide a lot of guard rails, and Go is a pretty good candidate being a fairly simple language with types keeping the code on track. I've played a bit with LLMs writing it, and results seem pretty decent overall. But then there's the whole architecture layer on top of that, and that seems to be an area that's largely unexplored right now.

I think the key is focusing on the contract. The human has to be able to tell that the code is doing what's intended, and the agent needs clear requirements and fixed context to work in. Breaking the program up into small isolated steps seems like a good approach for getting both these things. You can review the overall logic of the application by examining the graph visually, and then you can check the logic of each step independently without needing a lot of context for what's happening around it.

I've actually been playing a bit with the idea a bit. Here's an example of what this looks like in practice. The graph is just a data structure showing how different steps connect to each other:

and each node is a small bit of code with a spec around its input/output that the LLM has to follow:

It's been a fun experiment to play with so far.