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:

  1. Process automation. Shorten the inner loop of the SDLC through parallelization so no one starts from a blank branch.
  2. 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.
  3. 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:

  1. The person who merges owns the change, regardless of who or what wrote it.
  2. Agents start, humans finish. An agent draft is a starting point, never a finished product.
  3. Drafts are disposable. No one is obligated to rescue a bad agent PR. Discarding is a valid outcome.
  4. Risk decides who owns a change, not job title. Shapers can own green-tier work; yellow and red work is owned by Builders.
  5. 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.

Agents draft and clean up;a human owner takes it from thereLinear issueWritten, refined, andtiered by the teamAgent-ready?Agent drafts PRLinear Agent codingsession opens a PRAutomated gatesCI and tier-matchedCopilot reviewOwnerFinishes, redirects,or discards the draftEnvironment checkPer-PR previewenv and app buildApprove and mergePeer approves; ownermerges, checks prodno: sharpenthe specyesagent fixescommentsuntil clean

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.

GroupWhoCan originateHeld to
BuildersEngineers, plus PMs and designers their manager and team lead move to BuilderGreen, yellow, and red changesThe full engineering review bar; they own what they merge and verify it in production
ShapersPMs and designersGreen-tier PRs, yellow-tier proposals, and specs for red-tier workA 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

TierWhat it coversShapers canRequired gate
GreenCopy, UI polish, read-only internal admin viewsOriginate a PR through an agentCI 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
YellowNon-regulated product functionality, UI logic, internal admin actions that change data, routine database schema updatesOpen a proposal PR that a Builder adoptsA different Builder approves; the adopting Builder merges, owns the change, and verifies it in production
RedRegulated product functionality, auth, billing, onboarding, third-party data integrations, PII handling, complex database changes, non-trivial architectural shiftsWrite the spec onlyBuilders 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.

TierCopilot review effort
RedMax
YellowBalanced
GreenLite

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.

LayerContainsChangesOwner
StrategyWhy, principles, operating model, rollout, metricsQuarterlyEngineering leadership
Agentic engineering playbookRules, templates, how-tos, the acceptable and unacceptable listAs needed, reviewed monthlyA named principal engineer
Repo controlsCLAUDE.md/AGENTS.md, CODEOWNERS, CI checks, branch protection, the tier-based review workflowWith each changeDeveloper 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.

Builders start first; Shapers joinonce preview envs are livePhase 1Builders delegateAgent-ready issues aredelegated to Linear AgentOpens: agent tooling andtier automation in placePhase 2Shapers ship greenGreen-tier PRs with apreview-env self-checkOpens: preview envs liveand Phase 1 quality holdsPhase 3Yellow proposalsShapers open proposal PRs;Builders adopt and own themOpens: Shaper changesmatch the Builder baselineIn parallel: build preview envsGo/no-go review against the entry criteria

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.

MetricKindSourceWhy it matters
Share of issues with an agent draftThroughputGitHub dataShows the inner loop is actually changing
Issue-to-merge cycle timeThroughputGitHub dataThe core outcome of Pillar 1
Agent PR discard rateQualityGitHub dataHigh rates point to weak specs or readiness gaps
Revert and incident rate, by tier and contributor groupQualityGitHub dataShaper changes must match the Builder baseline and each tier must hold steady as volume grows
Review hours per Builder per weekMoraleGitHub dataGuards against Builders becoming a review queue
Code review satisfactionMoraleQuarterly developer surveyShows whether review is becoming a burden as agent PR volume grows
Agent tooling satisfactionMoraleTooling CSAT surveyShows 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.