Maybe you should try Extreme Programming (again)
In the team I've been in for the last couple of years, Extreme Programming is the core way of working. Fast feedback, short iterations, deploy early and often, Red/Green/Refactor (TDD), pair programming, all of it, and it's been great.
AI-Assisted engineering, GPT-driven-development, vibecoding, whatever you call it, it's here to stay. With the rise of these tools comes the question: "How can we get the best use out of them?". Everyone is trying things, from whole swarms of agents to copy-pasta-coding with your LLM of choice and I've not seen something rise up that really cracks the case yet. What I do have is lots of experience pair progamming and when I'm working with a coding agent/assistant, it really closely resembles how I approach programming with a real human person.
The driver and the navigator
One of ways to do pair programming is Driver-Navigator. Person A is the driver, they are in control of the keyboard and mouse (they drive the computer), person B is the navigator and instructs and helps the driver find their way. Together they are in charge of finding the best approach to solving the task at hand. If you've ever watched a World Rally Championship race you'll know exactly what I mean.
Before you go "oh come on, pair programming is wasteful, both people could be working individually to get more done!", that's not the point here.
You and the LLM are doing something very similar to pair programming, you might even say it IS pair programming. The LLM is clearly the driver writing all the code, and you, the navigator are in charging of providing instructions and correcting course if needed.
Test-driven development
Another practice from Extreme Programming is Test-driven development (also a topic of lots of debate, as with pair programming) and this one is not really a new idea with it comes to working with LLMs. People are seeing success when practicing TDD with their LLM to write software. Specifically the Red/Green/Refactor style of TDD. Write failing tests (red), implement the actual code to make them pass (green). The refactor bit is important here (and often overlooked), once the tests are passing you get to play with the implementation and improve it if needed, as long as your tests stay green you are good to go.
You'll have to be strict here with the Red/Green part though. Write failing tests that will assert specific behavior, and only then are you allowed to proceed to make the tests pass. You can even put two different LLMs at work for this, one writing the tests per your instruction, then the other implementing against the tests.
Sustainable pace
Another one from the Extreme programming practice! And a really important one as well. Your digital coding buddy will allow you iterate very (extremely! badum-tss) quickly, so fast in fact that you are prone to working at an unsustainable velocity which could end up burning you out, making all velocity meaningless.
The same applies to "real" pair programming (with another actual human person), it can be pretty exhausting when you spend all day with someone else working together. Same goes for the work you do with agents and LLMs.
Find a rythm that you can sustain for long periods so you stay healthy and productive. Just because we can reach very high outputs doesn't mean that we should.
Anyway...
As you can see, quite some things that are covered by Extreme Programming seem like a good fit for AI Assisted programming. At the same time, while we can speed up the coding part of our software developer jobs, we're still bound by the speed at which output can be validated by the rest of the stakeholders. All that speed is useless when you build the wrong thing at the wrong time.
So to cap it off, try Red/Green TDD with your coding agent, get in the role of navigator and keep an eye on what your driver is producing and most importantly, don't burn yourself out by trying to build the whole world at once. Maybe even pick up that Extreme Programming book and see what it's all about, there's good stuff in there for going fast without breaking stuff.