Funny shift since I started running my coding agents off a task graph: I barely watch them anymore. Most of my time now goes into the PRD.
Turns out the agent was rarely the problem. My vague specs were.
@0utloop Same here. Once "done" is written down per task, the agent has something to check against instead of guessing. Swapping models never got me that.
The tool I built for this is graph-execution: it turns a PRD into a task graph and runs the agents in parallel, then reviews and tests the merged result. Open source: https://t.co/yEggKMAmQ5
@jul1anodev Makes sense. In a task graph I've started treating two tasks that touch the same file as a hint they shouldn't run in parallel at all, just add a dependency between them. Your propose-then-review split is a nice middle ground though, might steal it.
Question for anyone running more than one AI coding agent on the same codebase:
How do you split the work and keep them from stepping on each other? And who checks that the merged result actually does what you asked?
Curious what's working for people.
Biggest thing I got wrong building with coding agents: I kept making the agent smarter when the problem was the task
Smaller tasks, fresh context each time, and one real review at the end beat any prompt trick I tried
@jul1anodev Pretty close to where I ended up. Separate worktrees per task, and once everything merges, one fresh-context reviewer plus a live tester check it against the request. The one-owner-for-shared-files rule is smart though. How do you decide who owns what?
Most of graph-execution's new features are now built by graph-execution.
I write the PRD, it splits it into tasks, agents build them in parallel worktrees, and a reviewer and live tester check the merged result.
Since I started working this way, I trust the results a lot more.
Running coding agents in parallel was never the hard part. Keeping them out of each other's way was.
So I built graph-execution: it turns PRD into a task graph, runs each task with its own agent in its own worktree, then does one review and one test pass after everything merges
@miguelgbandeira Same instinct here. In graph-execution the reviewer never sees the coding sessions: after all tasks merge, one fresh-context reviewer and a live tester judge the whole result against the PRD. Short demo: https://t.co/UK92TJx2v2
My coding agent kept drifting on big tasks, so I built this: it splits the work into a task graph, runs agents in parallel, then reviews and tests the result before it becomes a PR.
Open source.
@NoCoSaL Agree, writing got cheap and reviewing didn't. So I built review into the run in graph-execution: after all tasks merge, one reviewer and a live tester check the whole result against the spec. Demo: https://t.co/UK92TJwuFu
My coding agent kept drifting on big tasks, so I built this: it splits the work into a task graph, runs agents in parallel, then reviews and tests the result before it becomes a PR.
Open source.
@ashleywolf Agree, the missing step is someone reading the whole change. In graph-execution, once every task has merged, one fresh-context reviewer and a live tester check the full result against the PRD. Short demo: https://t.co/UK92TJwuFu
My coding agent kept drifting on big tasks, so I built this: it splits the work into a task graph, runs agents in parallel, then reviews and tests the result before it becomes a PR.
Open source.
@SebastianRoehl@t3dotcodes Same, the sidebar turns into a graveyard fast. That's part of why I built graph-execution: each task runs with its own agent in its own worktree and merges back when it's done. Short demo: https://t.co/UK92TJwuFu
My coding agent kept drifting on big tasks, so I built this: it splits the work into a task graph, runs agents in parallel, then reviews and tests the result before it becomes a PR.
Open source.
@silic2023 Agree, a quiet assumption is the worst outcome. I put most of the effort into the graph up front so dependencies are explicit before any agent starts. Curious how you'd handle it: pause just that branch and re-plan, or something lighter?
My coding agent kept drifting on big tasks, so I built this: it splits the work into a task graph, runs agents in parallel, then reviews and tests the result before it becomes a PR.
Open source.