En 30 segundos
Untangle founder Ryan Carson uses a manager agent to coordinate roughly 20 coding agents through a ticket board, scheduled check-ins and limited review loops. A separate agent coordinates merges, while a human watches a recording of every feature before approving it. Carson also describes hiring from recordings of candidates working with agents, followed by a paid trial.
- 1One manager session coordinates about 20 buildersThe manager assigns ticketed work and handles routine questions; Carson says human attention limits how many agents he can oversee.
- 2A scheduled check keeps builders movingAn automation makes the manager inspect each child session every 15 minutes.
- 3Review loops stop after three roundsUnresolved important bugs are escalated, and a separate QA agent checks the work.
- 4A person watches the feature before shipmentAgents record tests and user-visible behavior; Carson reads the change summary and watches before approving.
- 5A merge manager coordinates shared changesThe extra agent helps prevent collisions, including database migration numbers.
- 6Hiring starts with a candidate’s working videoAn agent ranks recorded demonstrations; the top five are invited to a paid 16-hour project.
Conclusiones
- Schedule explicit check-ins instead of assuming a manager agent will inspect its children.
- Limit review loops and escalate unresolved bugs.
- Watch a feature recording before giving human approval to ship.
- Coordinate shared resources such as migration numbers through a merge manager.
- Assess agent operation on real work, then use a paid trial.
Lee el texto editado por capítulos
A human sets priorities for agent-led engineering
Carson explains Untangle’s product and the manager session that assigns work.
I founded Untangle to make divorce less painful. We started with a consumer application, then pivoted to selling an AI paralegal for family law firms. The work is personal: my parents and two sisters have been through divorce.
After building four companies and scaling the last to about 110 people, I found that lessons about managing people also apply to agents. At Untangle, people set priorities and talk to customers; agents do much of the implementation.
Our engineering runs in the cloud using Devin. Each engineering-manager agent is simply a persistent session: it does not write code, but coordinates child sessions and answers technical questions on my behalf.
I mostly use voice to communicate with the manager because I absorb audio more easily. A Linear ticket board is the source of truth for work, with one ticket per pull request; the manager picks tasks in dependency order.
Keep builders moving and cap review loops
A scheduled check-in and a three-round review limit coordinate parallel work.
One manager can oversee roughly 20 builders at once, sometimes five and sometimes as many as 25. The practical limit is my ability to understand what the manager tells me. If I push too hard, the operation becomes difficult to control.
I do not go into the builder sessions myself. The manager answers their questions and clears small blockers. A scheduled automation forces it to inspect every child session every 15 minutes; the slide says ten, but I now use 15 because an agent cannot be relied on to remember a nondeterministic check.
Each builder calls a review agent. We generally allow three rounds of review and fixes; if important bugs remain, they go to the manager and, if necessary, to me. This puts a limit on a review loop that could otherwise keep running.
Alongside code and tests, a separate QA agent is spawned by the builder to verify the work. Extra agent checks are cheap in my experience, but teams must balance them against a merge queue that slows down when every pull request receives endless scrutiny.
Watch the result and coordinate merges
A human approves each feature video, while a merge manager reduces conflicts.

Every builder also records a video showing the feature in use and the tests passing. For a user-facing change, a green result is useful, but the video lets a person see both whether the expected interaction occurred and whether it looks right.
The manager tells me when a video is ready. Before saying ship it, I read a summary of the pull request and watch closely. I was tempted to approve one on my phone before this talk, but could not see enough detail, so I waited until I could use my computer.
This human review is a bottleneck a product owner needs to engage with rather than skip. The process has gone through hundreds of iterations and works for us today; it will probably change again. I strongly favor cloud agents over local development for this style of work.
At team scale, each person typically has an engineering-manager session; I sometimes have two. Those sessions need to know about and message one another so they can share information and unblock work across the team.

A separate merge-queue manager coordinates the stream of pull requests. It can prevent collisions over things such as database migration numbers and help order the queue. This is another named agent session, alongside GitHub merge queues.
Hire by observing real agent work
Candidates submit recordings, then finalists complete a paid project.
Our hiring process starts without screening calls. I think early conversations can bias me toward a candidate’s hobbies or manner rather than the skill I want to assess: operating an agent.

Candidates submit an approximately 45-minute full-screen recording of themselves using an agent to ship a feature, usually a pull request, in an app they already maintain. We give no detailed instructions and do not pay for this initial submission.
We give the recordings and transcripts to an agent to rank the candidates. I initially distrusted its ranking because I disliked the result; in one case, I later concluded I should have hired the person it placed first.
A long recording can reveal the work, although some candidates do not think aloud or speak clearly enough to make their reasoning visible. A person can watch the submissions too; the ranking agent helps when there are too many hours to review.
We invite the top five to a paid project: a fixed fee for 16 hours, a Devin seat and a real pull request to prepare for merge. Candidates sign an NDA and record the work. We use Loom and ask an agent to compare the recordings.
In the last round I watched all 16 hours of video, which was demanding but helped me understand the candidates. Once we have finalists, I call them for a final human conversation rather than making that call the first filter.
This is a snapshot of a fast-changing process, but the pattern is consistent: delegate coordination and verification to agents while the person remains responsible for priorities, checking the product and making the hiring decision.
Más de este canal
38:50EN
12:57EN
28:00EN
19:41EN
52:08EN
22:01EN