Agents draft, humans own: a strategy for agentic engineering
Coding agents have improved to the point that non-engineers can now safely make small, well-scoped changes to production software. Product Managers, Designers, and other engineering-adjacent roles are eager to increase their impact by contributing to the codebase but the traditional software development lifecycle wasn't built for this. How do we rearchitect the system to reap the benefits of having these additional resources while also maintaining quality and preventing engineers from becoming "code janitors"? My product and design colleagues have been asking me this question and this is the solution I've devised in response.
Coding agents can now take a well-written issue and return a working pull request. Most teams adopt them ad hoc: a few engineers lean on them heavily, others don't, and the rules for what is acceptable live in people's heads. This is an operating model for adopting them deliberately, summed up in one rule: agents draft, humans own.
The strategy has three goals:
- Process automation. Shorten the inner loop of the SDLC through parallelization so no one starts from a blank branch.
- Safe integration. Give PMs and designers a real way to contribute with agents while protecting the quality of the system and without turning engineers into full-time reviewers.
- Documented guidance. Make it clear what is and isn't acceptable now that the inner loop and the set of contributors have changed.
Why now
The inner loop still starts cold and the tooling to fix that is now mature. Without a deliberate model, adoption happens ad hoc and unevenly.
- Cold starts. Engineers rebuild context from the issue tracker, Slack, and the codebase before writing a line of code.
- Untapped contributors. PMs and designers can describe small changes precisely, but their only path is a ticket in the queue.
- Mature tooling. Linear's coding sessions run Claude Code or Codex on a delegated issue and return a draft PR.
- Risk of drift. Without shared rules you get inconsistent quality, compliance gaps, and engineers sliding into review-only roles.
Principles
Five non-negotiables govern every decision in the strategy and the playbook that backs it:
- The person who merges owns the change, regardless of who or what wrote it.
- Agents start, humans finish. An agent draft is a starting point, never a finished product.
- Drafts are disposable. No one is obligated to rescue a bad agent PR. Discarding is a valid outcome.
- Risk decides who owns a change, not job title. Shapers can own green-tier work; yellow and red work is owned by Builders.
- Guardrails live in tooling. If a rule matters, CI, CODEOWNERS, or branch protection enforce it. Documents explain why.
The operating model
Every change follows one loop: a human writes the issue, an agent drafts and cleans up the PR, and a named owner takes the result through merge.
The loop is the same for every tier and every contributor. The tier only changes who can be the owner and the approver: a Shaper or Builder on green, a Builder on yellow and red.
Pillar 1: Process automation
Every agent-ready issue gets a draft PR before its owner starts, so owners begin from a working diff instead of a blank branch. The goal is faster finishing, not more PRs: drafts only exist for work the team already committed to in refinement, so the gain comes from skipping the cold start rather than adding to the review queue.
Make one agent the happy path
Linear Agent coding sessions are the default for delegated issues. That is the path you template, measure, and support.
Builders can keep using Claude, Codex, etc. directly when they prefer. The rules are the same whatever the tool: a linked issue and the same review gates.
Agent-ready issue standard
An issue is agent-ready when it states the outcome, scope, and constraints clearly. Linear notes that a clearer issue means less time spent exploring or inferring requirements. Ship an issue template and an agent-ready label with these required fields:
- Outcome: what is true when this is done
- Scope: what is in and what is explicitly out
- Constraints: files, patterns, feature flags, APIs to use or avoid
- Acceptance criteria: testable statements
- Test expectations: which tests must be added or updated
- Risk tier, set by the team in sprint refinement: green, yellow, or red (see Pillar 2)
Automatic delegation
When the team labels an issue agent-ready during sprint refinement, a Linear Loop delegates it to Linear Agent automatically. Drafts exist before anyone picks the issue up and no one delegates by hand. Issues arriving in Triage are never delegated automatically: their text can come from customers or outside integrations, and anything an agent reads can steer it. Once a teammate accepts a triage issue and rewrites it to the agent-ready standard, the label triggers the same Loop.
Ownership of the draft
Every agent PR is assigned to an owner, not a reviewer: a Builder or a Shaper on green-tier work. The owner has three options:
- Finish it: iterate with the agent or by hand until it meets the bar
- Redirect it: sharpen the issue and re-run the agent
- Discard it: close the PR and build it themselves
Preview environments
Per-PR preview environments are the one piece of infrastructure this model depends on. Builders can start without them and verify locally until they exist. Shaper self-verification and the green-tier gate depend on them, so they need to be live before Shapers start shipping.
Pillar 2: Safe integration
A change's risk tier decides who can own and approve it. Shapers get a real path to ship in low-risk areas and yellow and red work stays with Builders.
Builders and Shapers
Every contributor is a Builder or a Shaper. Builders write and own production code; Shapers define what gets built and ship directly in low-risk areas. The distinction is based on software-building expertise, not job title.
| Group | Who | Can originate | Held to |
|---|---|---|---|
| Builders | Engineers, plus PMs and designers their manager and team lead move to Builder | Green, yellow, and red changes | The full engineering review bar; they own what they merge and verify it in production |
| Shapers | PMs and designers | Green-tier PRs, yellow-tier proposals, and specs for red-tier work | A preview-env self-check; once a different Shaper or Builder approves, they merge and own green PRs and verify them in production; a Builder owns any yellow adoption |
Becoming a Builder
A PM or designer willing to work as a junior engineer becomes a Builder as soon as their manager and engineering team lead sign off. There is no track or completion step. They keep their PM or design role, but the move changes what they can ship.
Risk tiers
| Tier | What it covers | Shapers can | Required gate |
|---|---|---|---|
| Green | Copy, UI polish, read-only internal admin views | Originate a PR through an agent | CI and Copilot review pass, contributor verifies in a preview env, a different Shaper or Builder approves; the Shaper then merges, owns the change, and verifies it in production |
| Yellow | Non-regulated product functionality, UI logic, internal admin actions that change data, routine database schema updates | Open a proposal PR that a Builder adopts | A different Builder approves; the adopting Builder merges, owns the change, and verifies it in production |
| Red | Regulated product functionality, auth, billing, onboarding, third-party data integrations, PII handling, complex database changes, non-trivial architectural shifts | Write the spec only | Builders only; a different Builder approves; compliance sign-off where required; the Builder merges, owns the change, and verifies it in production |
The team assigns each issue's tier label together during sprint refinement, so anyone can raise a differing view and the tier is never one person's call. A GitHub Actions-run agent then checks each PR's actual change against its tier, using the owning team in CODEOWNERS as a guide rather than a rule. A copy fix in a payments file can stay green, while a logic change there is red. The agent can raise a tier but never lower it.
Automated review depth
Each tier gets a matching GitHub Copilot code review effort, requested automatically.
| Tier | Copilot review effort |
|---|---|
| Red | Max |
| Yellow | Balanced |
| Green | Lite |
The tier-check agent labels each PR with its tier, starting from the tier on the linked issue. It can raise the tier but never lower it and when it does, it also labels the PR as a tier mismatch and flags the issue. A GitHub Action then requests the Copilot review through the Copilot review API at the effort matching the PR's tier label. Copilot approvals never count as an independent approver on any tier.
Linear Agent then works through Copilot's comments automatically: it fixes what it agrees with, replies with its reasoning where it doesn't, and pushes until CI is green and no comments are open. After a set number of rounds, defined in the playbook, it stops and hands off. The owner is notified only when the PR is ready, so no one sits re-prompting the agent.
Separation of duties
An agent-authored change still needs a human author and an independent approver. The owner who merges the PR is its author of record. Approval must come from a different person: any other Shaper or Builder on green, a Builder on yellow and red. An agent never approves.
Keeping Builders building, not reviewing
More contributors must not turn Builders into a review queue. Five mechanisms prevent that:
- Everyone self-verifies. A verification checklist is required before review, done in a preview env or locally by Builders until preview envs exist. Incomplete PRs are bounced automatically.
- Machines review first. CI and a tier-matched Copilot review run before any human looks.
- Builders own the hard work. Yellow and red delivery and the agent platform itself stay with Builders.
- Review load is balanced. An agent assigns reviews by current load (see below) and you throttle intake rather than Builder time when load runs high.
- Expertise moves upstream. Builders spend more time in refinement adding implementation guidance to issues: patterns to follow, pitfalls to avoid, where the change belongs. They aren't cleaning up after agents; they're applying the same expertise earlier, where it shapes the draft. Junior engineers learn from agent implementations as they finish them.
Review assignment
An agent assigns reviewers by current load, replacing manual assignment from a dashboard or GitHub's simplistic auto-assignment.
- Reviews are Linear sub-issues. Each required review is a sub-issue under the story, assigned to the reviewer, so review load is tracked in Linear like any other work.
- Least-loaded eligible reviewer. The agent picks whoever has the fewest open review sub-issues among those eligible: any other Shaper or Builder on green, a Builder on yellow and red.
- Out-of-office people are skipped. The agent reads each person's GitHub status and skips anyone marked Busy. People set Busy on GitHub, with an end date, whenever they're out. It needs no new integration approvals and can be automated further later.
- Owners can choose. An owner can name a specific reviewer on the issue and the agent assigns that person instead.
Pillar 3: Documented guidance
Guidance lives in three layers, split by how often each changes. Anything that must hold is enforced in the repo; the playbook explains why.
| Layer | Contains | Changes | Owner |
|---|---|---|---|
| Strategy | Why, principles, operating model, rollout, metrics | Quarterly | Engineering leadership |
| Agentic engineering playbook | Rules, templates, how-tos, the acceptable and unacceptable list | As needed, reviewed monthly | A named principal engineer |
| Repo controls | CLAUDE.md/AGENTS.md, CODEOWNERS, CI checks, branch protection, the tier-based review workflow | With each change | Developer platform and team leads |
The playbook must cover:
- The tier-by-role matrix from Pillar 2
- The agent-ready issue template
- PR standards: a link to the issue and a human-written "how I verified this" section
- Data rules: no production data, PII, secrets, or customer financial data in prompts or issues
- A short "never do this" list
Rollout
Roll out in three phases, starting with Builders as soon as the agent tooling is in place. Build preview environments alongside Phase 1; each later phase opens only when its entry criteria are met.
Metrics
Measure throughput, quality, and morale together; a phase advances only when all three hold. A developer-experience platform such as DX can supply all of them from GitHub data, quarterly developer surveys, and tooling CSAT surveys. Baselines come from current repository data and targets are agreed in the first cycle of Phase 1.
| Metric | Kind | Source | Why it matters |
|---|---|---|---|
| Share of issues with an agent draft | Throughput | GitHub data | Shows the inner loop is actually changing |
| Issue-to-merge cycle time | Throughput | GitHub data | The core outcome of Pillar 1 |
| Agent PR discard rate | Quality | GitHub data | High rates point to weak specs or readiness gaps |
| Revert and incident rate, by tier and contributor group | Quality | GitHub data | Shaper changes must match the Builder baseline and each tier must hold steady as volume grows |
| Review hours per Builder per week | Morale | GitHub data | Guards against Builders becoming a review queue |
| Code review satisfaction | Morale | Quarterly developer survey | Shows whether review is becoming a burden as agent PR volume grows |
| Agent tooling satisfaction | Morale | Tooling CSAT survey | Shows whether the agent, Copilot review, and the workflow actually help |
None of this works without the first principle. Agents can draft, review, fix, and route work, but a person still decides what ships and answers for it.