I want AI to help me deliver software and automate some part of the life cycle that i personally follow. The operating model I keep coming back to has 2 connected loops: a product loop and a development loop.
That split is deliberate. The product loop asks whether a piece of work deserves attention. The development loop asks how to turn selected work into a change I can trust. If I collapse them, an agent's ability to produce code quickly can look like evidence that the idea itself is good. Speed is useful, but it is not product judgement, it needs to take some time to iterate.
Product discovery and final judgement stay human-led, while agents help turn direction into checked, traceable work.
The product loop
Discovery starts with me. I pay attention to a problem, question assumptions, and decide whether there is enough signal to keep going. From there, I whiteboard and shape the idea. This is still human work because the hard part is choosing the problem boundary, the trade-offs I accept, and what I am prepared not to do.
The roadmap is collaborative. I bring intent and priorities; an agent can help turn them into structured, actionable work. Once I approve that direction, roadmap sync is agent work: keeping the agreed state aligned and carrying updates forward without requiring me to repeat the same clerical steps.
New work is collaborative again. I decide what moves next and why, while the agent helps prepare it for delivery. The result feeds discovery rather than closing it. What I learn from starting the work may change the shape, expose a weak assumption, or show that the priority was wrong. The loop keeps product direction open to evidence.
The build loop
Exploration is a joint activity. I set the questions and boundaries; the agent helps inspect the system and surface relevant context. Planning is joint for the same reason. The agent can assemble a path through the code, but I still judge whether that path matches the product intent and the risks I am willing to take.
Application is where I hand over most directly. The agent applies the agreed plan. Refinement then becomes collaborative: I respond to what the implementation revealed, and the agent adjusts the work. This separation helps me avoid improvising a new product decision inside a coding step.
At merge check, the agent and an explicit gate verify the work against the checks I have chosen. Passing that gate does not authorize the change. I review and merge it myself. The gate can catch defined failures; I still decide whether the change is understandable, proportionate, and actually solves the intended problem.
The retrospective is human work too. I look at what surprised me, where the plan was weak, and whether the process produced useful evidence. Those lessons feed the next exploration, so development improves from one piece of work to the next.
Where still need human
I keep human judgement at the points where context, taste, and accountability matter most: discovery, shaping, final review, merge, and retrospective. I use the agent heavily where the work benefits from speed, consistency, and traceability: synchronizing approved direction, applying plans, and running checks. Between those ends, we work together.
This is not a way that every team needs the same workflow. It is the model I use to keep steering separate from acceleration. The 2 loops let agents move work forward without quietly taking ownership of why the work exists or whether it is ready to become real. The practical version of this in my local macbook is a set of slash command i custom in Claude code and I usally visit them to ensure it up to date to my taste.