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.
@GohilHardy Yes. Even when the code is good, someone has to know what changed and why. I let agents build, but I still read a review md of the merged change before it ships. graph-execution writes one after a fresh reviewer and a live tester check it. https://t.co/8PYag0u7qn
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.
@shubh19 Billing refactor + webhooks + tests in one prompt is exactly where mine used to drift. Now I split it into small tasks that each pass a validation check, then a fresh reviewer and a live tester go over the merged result. That's graph-execution. https://t.co/8PYag0u7qn
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.
@oanaolt We hit this too. A decision made in one person's session is invisible to every other agent. What helps me: write it into the spec in the repo so the next agent reads it. graph-execution runs every task off that one written spec. https://t.co/8PYag0u7qn
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.
Parallel coding agents break when one needs code another hasn't written yet. It guesses the interface, and you find out at merge.
In graph-execution, a task that depends on another waits until that one merges, so it starts from real code. Independent ones still run side by side.
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.
Since building graph-execution, I spend more time on the PRD and less time babysitting the agent.
A vague PRD gives a vague task graph. A clear one gives small, focused tasks that each agent can actually finish.
@AmbroseAbaasa The 70% is real. What fixed it for me: small tasks with a clear done, then one fresh-context reviewer plus a live tester on the merged result, and a review md so I know what changed. That's the loop I built into graph-execution. https://t.co/8PYag0u7qn
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.
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
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.
@nainasachdev11 Ha, same energy. What's worked better than good vibes for me: small tasks, each agent only gets what it needs, and a review of the merged result before I trust it. That's how I built graph-execution. Still say please though. https://t.co/8PYag0u7qn
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.
@pigol1 This matches what I see. Writing code got cheap, checking it didn't. In graph-execution, once every task merges, one fresh-context reviewer and a live tester check the whole thing against the spec. https://t.co/8PYag0u7qn
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.
@sufyanbuild Same lesson here. The more I scope a task up front (which files, what done looks like), the less context it burns finding its footing. In graph-execution I split the work into small tasks that each start fresh. https://t.co/8PYag0u7qn
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.
@AditSavani16 Same lesson here. A rules file plus a short spec per task cut most of the repeating for me. Agents still drift on long runs, so graph-execution keeps tasks small and checks the merged result once at the end. https://t.co/8PYag0u7qn
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.
@SeHozaifa Agree. AI review helps me catch things, but it doesn't replace knowing what the code should do. That's why the optional human review in graph-execution works from a review md, not just the diff. https://t.co/8PYag0u7qn
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.
@ivanfioravanti Fun comparison. Separate panes with isolated runs is the part I'd steal. I lean on the same idea in graph-execution: each task gets its own agent in its own worktree, all running in parallel. https://t.co/8PYag0u7qn
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.
@peterrhague Same here. Agents are great at reading code fast and narrowing down where a bug lives. Where they hurt me was loosely scoped changes. In graph-execution I keep tasks small, then one fresh-context reviewer and a live tester check the merged result. https://t.co/8PYag0u7qn
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.
@zwai_ndimba Agreed, the planning is most of the work. Once I have a solid PRD, the coding part gets boring in a good way. That's why I built graph-execution: it turns the PRD into a graph of small tasks and runs agents on them in parallel worktrees. https://t.co/8PYag0u7qn
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.
@ayesha_fatiima Same here on the half-finished outputs. Most of the missed instructions showed up once the context got long. What helped me: smaller tasks, each in a fresh session. That's how graph-execution splits the work: https://t.co/8PYag0u7qn
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.