How to Delegate Work to AI Coding Agents

You delegate to an AI coding agent by writing the ticket, not the idea — the agent picks up a scoped, described piece of work from your tracker and reports back in the thread. That is the whole shift. The agent is not a smarter autocomplete you talk to; it is a contributor you assign, and everything that makes delegation work with people makes it work here.

Weak Decisions create endless creation. Give an agent a vague ticket and you get vague work, faster and in volume.

The four steps

1. Put the work somewhere assignable. An agent can’t take a task that only exists in your head or a Slack thread. In Linear, agents join the workspace as first-class members: you assign them an issue, @mention them in a comment, or add them to a project, and the coding session starts from there. The human stays the primary assignee and the agent is added as a contributor — which is the correct default, because someone still owns the outcome.

2. Write the ticket like the agent has no context. It doesn’t. State the desired end state, the files or surface involved, the constraint that would make a plausible solution wrong, and how you’ll know it worked. Two extra sentences here save a rejected pull request later.

3. Match the agent to the autonomy the task deserves. The three in this stack are genuinely different shapes:

Agent	Shape	Give it
Devin	Hands-off delegation; parallel autonomous runs that open pull requests	Well-bounded tickets you’re willing to review async
Cursor	Synchronous, editor-native; you approve as it goes	Work where you want to steer mid-flight
Claude Code	Terminal-native agent, strong on long multi-file reasoning	Refactors, migrations, anything where the plan matters more than the diff
GitHub Copilot	Coding agent inside the GitHub workflow you already run	Small issues that should never leave the repo

4. Review the output, not the process. Read the diff. Run the tests. The agent’s explanation of what it did is a summary, not evidence.

The leash

Give the agent a leash — a scope it cannot exceed without you.

• One ticket, one agent. Parallel agents on overlapping files produce merge conflicts you’ll spend longer untangling than doing the work.
• Branch and pull request, never direct to main. The review gate is the leash.
• No credentials in the ticket. Anything an agent can read, it can quote into a summary.
• Cap the blast radius. Migrations, deletes, and anything touching billing or auth get a human plan first and an agent only for the mechanical part.

What this actually changes

Not your typing speed. Your queue shape.

When work is assignable to an agent, the bottleneck moves from doing the ticket to deciding which ticket — which is the Decisions layer doing its job. That’s why the tracker matters more than the model here. Triage Intelligence sorting an inbox of unsorted requests is worth more to a lean team than another point of benchmark score, because a sorted backlog is what makes delegation possible in the first place.

Start with one recurring, well-understood ticket type. Delegate that shape ten times before you delegate anything else. You are not testing the agent — you are learning how precisely you have to write.

Tools need jobs. So do agents, and the job is written on the ticket.