DEV Community

Hesham Karam
Hesham Karam

Posted on AI-assisted

Ask your coding agent. Let the lead handle the handoffs.

When I want an independent review, I want to ask for it in the terminal the same way I ask my coding agent for other work. I want the lead to arrange the review, follow it, evaluate the answer, and bring the result back into our conversation.

Disclosure: I maintain Delegate, the open-source tool discussed here.

Here is an illustrative interaction:

You: Ask Codex and Claude to review this change independently. Bring me the findings and any decisions you need from me.

Lead: I'll prepare the reviews, follow both tasks, and compare the findings.

This is a workflow illustration, not a transcript or a claim that this exact request has just run. It shows the interface I wanted: ordinary language in a coding-agent session, with the lead responsible for coordination.

Illustrative natural-language conversation with a lead coding agent; not a live execution transcript.

After setup, the person asking should not need to manage each worker separately. The interesting engineering question is what has to happen behind that short exchange.

This existing animation shows the same idea in a desktop chat interface. It is an illustrative example, not a live recording or the terminal interface shown above.

The conversation is the entry point

The lead already has context about the change, the constraints, and the outcome the user wants. It can turn that into focused assignments for the selected reviewers.

It decides what each reviewer needs to know, what the review should cover, and what evidence should come back. It follows the admitted work and reads the complete answers. Then it checks the findings against the change before responding to the user.

If a finding requires more authorized work, the lead can handle that next step. If the next action changes scope or needs approval, it brings that decision back to the user.

This is the interaction supported by Delegate's integration skill. Delegate supplies the execution lifecycle and validated result evidence; the lead uses those capabilities to carry out the request.

Natural language still needs a precise handoff

A short request can contain several requirements. “Independently” means the lead should prepare separate reviews rather than ask one reviewer to repeat the other's conclusion. “This change” needs a concrete scope. “Bring me the findings” requires reading and evaluating the results, not forwarding a completion notice.

The lead makes those details explicit in each bounded assignment. That gives the worker a clear stopping point and gives the lead something concrete to evaluate afterward.

The benefit of a conversational interface is not that those details disappear. It is that the lead handles them using the context the user has already provided.

Keep execution evidence behind the conversation

For the lead to coordinate reliably, it needs durable references to the work and a trustworthy way to return to the same assignments.

Delegate records an immutable request for each task and permits at most one provider launch attempt for that task. Observation follows the existing work. If creation is uncertain, the lead stops and reports it. It does not launch a replacement while that uncertainty remains.

Three facts remain separate: whether the request was admitted, whether execution is still running, and whether a validated terminal result is available. A process ending does not establish that a usable answer exists.

Waiting has its own boundary too. A finite observation window can end while work continues within its execution budget. The lead needs to interpret that correctly and keep following the existing work when appropriate.

These are responsibilities of the coordination layer and its integration. They should not become a sequence of manual steps for the user.

Bring back findings, not a stack of worker answers

The lead must read the full result, including limitations, and check the requested deliverable before saying the work is complete. Delegate validates terminal evidence and payload integrity; that validation does not prove that a review conclusion is correct.

A real fix in Delegate's terminal UI illustrates why this matters. Page navigation could be dropped during a background refresh. The correction needed navigation to take priority while preserving selection on a failed load.

The recorded regression failed on the first candidate and passed after the correction. Sol and Claude Opus independently approved the final change. That combined a concrete failure, a correction, a regression check, and independent review.

The useful response to the user connects those pieces: what failed, what changed, what was checked, and what remains uncertain. Agreement between reviewers supports that explanation; it is not a replacement for it.

Extend what the lead can coordinate

The same interaction can use optional capabilities without making the user operate a separate interface for each one.

Teams gives the lead a saved roster of members, roles, and model defaults. The integration discovers configured teams before work-allocation decisions, so the user need not name one every time. The lead can select a suitable member or keep work local. Teams is optional; role descriptions guide the lead rather than execute routing rules themselves.

SSH lets the lead assign work to a selected prepared machine and follow the result from the originating conversation. The destination needs its installation, provider account, and connectivity ready. Execution evidence belongs to that destination; losing the connection does not establish that execution never began.

Schedules lets the lead save recurring work and inspect its runs. Recurring runs require an independently started scheduler host to stay available. A saved definition and a successful occurrence remain different facts.

Gateway provides an MCP entry point to explicitly approved workspaces through a self-hosted service and device connector. Deployment, enrollment, workspace approval, and provider readiness remain prerequisites. A particular client still needs a compatibility check.

CPU and memory admission checks can refuse new tasks or continuations under confirmed pressure. They do not silently pick another machine. That choice belongs with the lead and the user's instructions.

Keep the user's decisions visible

“Let the lead handle it” means routine delegation, follow-up, collection, and evaluation stay with the lead after setup. It does not remove access decisions or approval boundaries.

The user supplies the goal and constraints. The lead coordinates within that authority and returns results, blockers, and decisions that need the user. The provider retains its native accounts and permission mechanisms; Delegate is not an independent OS sandbox.

That division keeps the interaction natural without making the execution vague. The user asks for work. The lead handles the handoffs and explains the outcome in the same conversation.

The behavior described here is grounded in the versioned integration skill, result-handling guide, and Teams guide.

Top comments (0)