<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Ian Walter</title>
        <link>https://iangineering.com</link>
        <description>Writing on software engineering, leadership, product design, and more.</description>
        <lastBuildDate>Sun, 15 Nov 2026 16:11:44 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <image>
            <title>Ian Walter</title>
            <url>https://iangineering.com/favicon.ico</url>
            <link>https://iangineering.com</link>
        </image>
        <copyright>All rights reserved 2026</copyright>
        <item>
            <title><![CDATA[Agents draft, humans own: a strategy for agentic engineering]]></title>
            <link>https://iangineering.com/articles/agents-draft-humans-own</link>
            <guid isPermaLink="false">https://iangineering.com/articles/agents-draft-humans-own</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <content:encoded><![CDATA[<blockquote>
<p>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.</p>
</blockquote>
<p>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: <strong>agents draft, humans own</strong>.</p>
<p>The strategy has three goals:</p>
<ol>
<li><strong>Process automation.</strong> Shorten the inner loop of the SDLC through parallelization so no one starts from a blank branch.</li>
<li><strong>Safe integration.</strong> 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.</li>
<li><strong>Documented guidance.</strong> Make it clear what is and isn't acceptable now that the inner loop and the set of contributors have changed.</li>
</ol>
<h2>Why now</h2>
<p>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.</p>
<ul>
<li><strong>Cold starts.</strong> Engineers rebuild context from the issue tracker, Slack, and the codebase before writing a line of code.</li>
<li><strong>Untapped contributors.</strong> PMs and designers can describe small changes precisely, but their only path is a ticket in the queue.</li>
<li><strong>Mature tooling.</strong> Linear's <a href="https://linear.app/docs/coding-sessions">coding sessions</a> run Claude Code or Codex on a delegated issue and return a draft PR.</li>
<li><strong>Risk of drift.</strong> Without shared rules you get inconsistent quality, compliance gaps, and engineers sliding into review-only roles.</li>
</ul>
<h2>Principles</h2>
<p>Five non-negotiables govern every decision in the strategy and the playbook that backs it:</p>
<ol>
<li><strong>The person who merges owns the change</strong>, regardless of who or what wrote it.</li>
<li><strong>Agents start, humans finish.</strong> An agent draft is a starting point, never a finished product.</li>
<li><strong>Drafts are disposable.</strong> No one is obligated to rescue a bad agent PR. Discarding is a valid outcome.</li>
<li><strong>Risk decides who owns a change, not job title.</strong> Shapers can own green-tier work; yellow and red work is owned by Builders.</li>
<li><strong>Guardrails live in tooling.</strong> If a rule matters, CI, CODEOWNERS, or branch protection enforce it. Documents explain why.</li>
</ol>
<h2>The operating model</h2>
<p>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.</p>
<figure class="not-prose my-10 [--diagram-accent:var(--color-teal-500)] [--diagram-edge:var(--color-zinc-400)] [--diagram-ink:var(--color-zinc-800)] [--diagram-quiet:var(--color-zinc-500)] [--diagram-rule:var(--color-zinc-200)] dark:[--diagram-accent:var(--color-teal-400)] dark:[--diagram-edge:var(--color-zinc-500)] dark:[--diagram-ink:var(--color-zinc-100)] dark:[--diagram-quiet:var(--color-zinc-400)] dark:[--diagram-rule:var(--color-zinc-700)]"><svg viewBox="0 0 760 310" role="img" aria-label="The inner loop: a Linear issue is written, refined, and tiered by the team. If it isn't agent-ready, the spec is sharpened. If it is, an agent drafts a PR, then CI and a tier-matched Copilot review run while the agent fixes comments until the PR is clean. The owner then finishes, redirects, or discards the draft, checks it in a preview or local environment, and a peer approves before the owner merges and checks production." font-size="13" class="hidden h-auto w-full md:block"><defs><marker id="loop-arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="var(--diagram-edge)"></path></marker></defs><text x="24" y="30" font-size="15" font-weight="600" fill="var(--diagram-ink)">Agents draft and clean up; a human owner takes it from there</text><g fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"><path d="M184 130H212" marker-end="url(#loop-arrow)"></path><path d="M332 130H368" marker-end="url(#loop-arrow)"></path><path d="M528 130H560" marker-end="url(#loop-arrow)"></path><path d="M640 166V214" marker-end="url(#loop-arrow)"></path><path d="M560 250H528" marker-end="url(#loop-arrow)"></path><path d="M368 250H184" marker-end="url(#loop-arrow)"></path><path d="M272 90V66H104V94" marker-end="url(#loop-arrow)"></path><path d="M640 94V66H448V94" marker-end="url(#loop-arrow)"></path></g><g><rect x="24" y="94" width="160" height="72" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="104" y="118" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Linear issue</text><text x="104" y="134" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">Written, refined, and</text><text x="104" y="150" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">tiered by the team</text></g><g><polygon points="212,130 272,90 332,130 272,170" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></polygon><text x="272" y="134" text-anchor="middle" fill="var(--diagram-ink)">Agent-ready?</text></g><g><rect x="368" y="94" width="160" height="72" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="448" y="118" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Agent drafts PR</text><text x="448" y="134" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">Linear Agent coding</text><text x="448" y="150" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">session opens a PR</text></g><g><rect x="560" y="94" width="160" height="72" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="640" y="118" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Automated gates</text><text x="640" y="134" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">CI and tier-matched</text><text x="640" y="150" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">Copilot review</text></g><g><rect x="560" y="214" width="160" height="72" rx="8" fill="var(--diagram-accent)" fill-opacity="0.12" stroke="var(--diagram-accent)" stroke-width="2"></rect><text x="640" y="238" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Owner</text><text x="640" y="254" text-anchor="middle" font-size="11.5" fill="var(--diagram-ink)">Finishes, redirects,</text><text x="640" y="270" text-anchor="middle" font-size="11.5" fill="var(--diagram-ink)">or discards the draft</text></g><g><rect x="368" y="214" width="160" height="72" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="448" y="238" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Environment check</text><text x="448" y="254" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">Per-PR preview</text><text x="448" y="270" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">env and app build</text></g><g><rect x="24" y="214" width="160" height="72" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="104" y="238" text-anchor="middle" font-weight="600" fill="var(--diagram-ink)">Approve and merge</text><text x="104" y="254" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">Peer approves; owner</text><text x="104" y="270" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">merges, checks prod</text></g><text x="188" y="58" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">no: sharpen the spec</text><text x="350" y="122" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">yes</text><text x="544" y="58" text-anchor="middle" font-size="11.5" fill="var(--diagram-quiet)">agent fixes comments until clean</text></svg><svg viewBox="0 0 340 740" role="img" aria-label="The inner loop: a Linear issue is written, refined, and tiered by the team. If it isn't agent-ready, the spec is sharpened. If it is, an agent drafts a PR, then CI and a tier-matched Copilot review run while the agent fixes comments until the PR is clean. The owner then finishes, redirects, or discards the draft, checks it in a preview or local environment, and a peer approves before the owner merges and checks production." class="block h-auto w-full md:hidden"><defs><marker id="loop-arrow-narrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="var(--diagram-edge)"></path></marker></defs><text x="0" y="18" font-size="15" font-weight="600" fill="var(--diagram-ink)">Agents draft and clean up;</text><text x="0" y="38" font-size="15" font-weight="600" fill="var(--diagram-ink)">a human owner takes it from there</text><g fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"><path d="M120 128V164" marker-end="url(#loop-arrow-narrow)"></path><path d="M120 228V264" marker-end="url(#loop-arrow-narrow)"></path><path d="M120 328V364" marker-end="url(#loop-arrow-narrow)"></path><path d="M120 428V464" marker-end="url(#loop-arrow-narrow)"></path><path d="M120 528V564" marker-end="url(#loop-arrow-narrow)"></path><path d="M120 628V664" marker-end="url(#loop-arrow-narrow)"></path><path d="M200 196H250V96H220" marker-end="url(#loop-arrow-narrow)"></path><path d="M220 396H250V296H220" marker-end="url(#loop-arrow-narrow)"></path></g><g><rect x="20" y="64" width="200" height="64" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="120" y="86" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Linear issue</text><text x="120" y="103" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">Written, refined, and</text><text x="120" y="118" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">tiered by the team</text></g><g><polygon points="40,196 120,164 200,196 120,228" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></polygon><text x="120" y="201" text-anchor="middle" font-size="14" fill="var(--diagram-ink)">Agent-ready?</text></g><g><rect x="20" y="264" width="200" height="64" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="120" y="286" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Agent drafts PR</text><text x="120" y="303" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">Linear Agent coding</text><text x="120" y="318" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">session opens a PR</text></g><g><rect x="20" y="364" width="200" height="64" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="120" y="386" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Automated gates</text><text x="120" y="403" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">CI and tier-matched</text><text x="120" y="418" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">Copilot review</text></g><g><rect x="20" y="464" width="200" height="64" rx="8" fill="var(--diagram-accent)" fill-opacity="0.12" stroke="var(--diagram-accent)" stroke-width="2"></rect><text x="120" y="486" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Owner</text><text x="120" y="503" text-anchor="middle" font-size="12" fill="var(--diagram-ink)">Finishes, redirects,</text><text x="120" y="518" text-anchor="middle" font-size="12" fill="var(--diagram-ink)">or discards the draft</text></g><g><rect x="20" y="564" width="200" height="64" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="120" y="586" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Environment check</text><text x="120" y="603" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">Per-PR preview</text><text x="120" y="618" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">env and app build</text></g><g><rect x="20" y="664" width="200" height="64" rx="8" fill="none" fill-opacity="1" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><text x="120" y="686" text-anchor="middle" font-size="14" font-weight="600" fill="var(--diagram-ink)">Approve and merge</text><text x="120" y="703" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">Peer approves; owner</text><text x="120" y="718" text-anchor="middle" font-size="12" fill="var(--diagram-quiet)">merges, checks prod</text></g><g font-size="12" fill="var(--diagram-quiet)"><text x="258" y="142">no: sharpen</text><text x="258" y="158">the spec</text><text x="128" y="250">yes</text><text x="258" y="334">agent fixes</text><text x="258" y="350">comments</text><text x="258" y="366">until clean</text></g></svg></figure>
<p>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.</p>
<h2>Pillar 1: Process automation</h2>
<p>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.</p>
<h3>Make one agent the happy path</h3>
<p><a href="https://linear.app/docs/agents-in-linear">Linear Agent</a> <a href="https://linear.app/docs/coding-sessions">coding sessions</a> are the default for <a href="https://linear.app/docs/assigning-issues">delegated issues</a>. That is the path you template, measure, and support.</p>
<p>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.</p>
<h3>Agent-ready issue standard</h3>
<p>An issue is agent-ready when it states the outcome, scope, and constraints clearly. Linear notes that a clearer issue means <a href="https://linear.app/docs/coding-sessions">less time spent exploring or inferring requirements</a>. Ship an issue template and an <code>agent-ready</code> label with these required fields:</p>
<ul>
<li><strong>Outcome:</strong> what is true when this is done</li>
<li><strong>Scope:</strong> what is in and what is explicitly out</li>
<li><strong>Constraints:</strong> files, patterns, feature flags, APIs to use or avoid</li>
<li><strong>Acceptance criteria:</strong> testable statements</li>
<li><strong>Test expectations:</strong> which tests must be added or updated</li>
<li><strong>Risk tier, set by the team in sprint refinement:</strong> green, yellow, or red (see Pillar 2)</li>
</ul>
<h3>Automatic delegation</h3>
<p>When the team labels an issue <code>agent-ready</code> during sprint refinement, a <a href="https://linear.app/docs/loops">Linear Loop</a> delegates it to Linear Agent automatically. Drafts exist before anyone picks the issue up and no one delegates by hand. Issues arriving in <a href="https://linear.app/docs/triage">Triage</a> 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.</p>
<h3>Ownership of the draft</h3>
<p>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:</p>
<ul>
<li><strong>Finish it:</strong> iterate with the agent or by hand until it meets the bar</li>
<li><strong>Redirect it:</strong> sharpen the issue and re-run the agent</li>
<li><strong>Discard it:</strong> close the PR and build it themselves</li>
</ul>
<h3>Preview environments</h3>
<p>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.</p>
<h2>Pillar 2: Safe integration</h2>
<p>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.</p>
<h3>Builders and Shapers</h3>
<p>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.</p>
<div class="overflow-x-auto"><table><thead><tr><th>Group</th><th>Who</th><th>Can originate</th><th>Held to</th></tr></thead><tbody><tr><td>Builders</td><td>Engineers, plus PMs and designers their manager and team lead move to Builder</td><td>Green, yellow, and red changes</td><td>The full engineering review bar; they own what they merge and verify it in production</td></tr><tr><td>Shapers</td><td>PMs and designers</td><td>Green-tier PRs, yellow-tier proposals, and specs for red-tier work</td><td>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</td></tr></tbody></table></div>
<h3>Becoming a Builder</h3>
<p>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.</p>
<h3>Risk tiers</h3>
<div class="overflow-x-auto"><table><thead><tr><th>Tier</th><th>What it covers</th><th>Shapers can</th><th>Required gate</th></tr></thead><tbody><tr><td>Green</td><td>Copy, UI polish, read-only internal admin views</td><td>Originate a PR through an agent</td><td>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</td></tr><tr><td>Yellow</td><td>Non-regulated product functionality, UI logic, internal admin actions that change data, routine database schema updates</td><td>Open a proposal PR that a Builder adopts</td><td>A different Builder approves; the adopting Builder merges, owns the change, and verifies it in production</td></tr><tr><td>Red</td><td>Regulated product functionality, auth, billing, onboarding, third-party data integrations, PII handling, complex database changes, non-trivial architectural shifts</td><td>Write the spec only</td><td>Builders only; a different Builder approves; compliance sign-off where required; the Builder merges, owns the change, and verifies it in production</td></tr></tbody></table></div>
<p>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.</p>
<h3>Automated review depth</h3>
<p>Each tier gets a matching <a href="https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-code-review">GitHub Copilot code review effort</a>, requested automatically.</p>
<div class="overflow-x-auto"><table><thead><tr><th>Tier</th><th>Copilot review effort</th></tr></thead><tbody><tr><td>Red</td><td>Max</td></tr><tr><td>Yellow</td><td>Balanced</td></tr><tr><td>Green</td><td>Lite</td></tr></tbody></table></div>
<p>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.</p>
<p><a href="https://linear.app/docs/coding-sessions">Linear Agent</a> 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.</p>
<h3>Separation of duties</h3>
<p>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.</p>
<h3>Keeping Builders building, not reviewing</h3>
<p>More contributors must not turn Builders into a review queue. Five mechanisms prevent that:</p>
<ul>
<li><strong>Everyone self-verifies.</strong> 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.</li>
<li><strong>Machines review first.</strong> CI and a tier-matched Copilot review run before any human looks.</li>
<li><strong>Builders own the hard work.</strong> Yellow and red delivery and the agent platform itself stay with Builders.</li>
<li><strong>Review load is balanced.</strong> An agent assigns reviews by current load (see below) and you throttle intake rather than Builder time when load runs high.</li>
<li><strong>Expertise moves upstream.</strong> 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.</li>
</ul>
<h3>Review assignment</h3>
<p>An agent assigns reviewers by current load, replacing manual assignment from a dashboard or GitHub's simplistic auto-assignment.</p>
<ul>
<li><strong>Reviews are Linear sub-issues.</strong> 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.</li>
<li><strong>Least-loaded eligible reviewer.</strong> 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.</li>
<li><strong>Out-of-office people are skipped.</strong> 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.</li>
<li><strong>Owners can choose.</strong> An owner can name a specific reviewer on the issue and the agent assigns that person instead.</li>
</ul>
<h2>Pillar 3: Documented guidance</h2>
<p>Guidance lives in three layers, split by how often each changes. Anything that must hold is enforced in the repo; the playbook explains why.</p>
<div class="overflow-x-auto"><table><thead><tr><th>Layer</th><th>Contains</th><th>Changes</th><th>Owner</th></tr></thead><tbody><tr><td>Strategy</td><td>Why, principles, operating model, rollout, metrics</td><td>Quarterly</td><td>Engineering leadership</td></tr><tr><td>Agentic engineering playbook</td><td>Rules, templates, how-tos, the acceptable and unacceptable list</td><td>As needed, reviewed monthly</td><td>A named principal engineer</td></tr><tr><td>Repo controls</td><td>CLAUDE.md/AGENTS.md, CODEOWNERS, CI checks, branch protection, the tier-based review workflow</td><td>With each change</td><td>Developer platform and team leads</td></tr></tbody></table></div>
<p>The playbook must cover:</p>
<ul>
<li>The tier-by-role matrix from Pillar 2</li>
<li>The agent-ready issue template</li>
<li>PR standards: a link to the issue and a human-written "how I verified this" section</li>
<li>Data rules: no production data, PII, secrets, or customer financial data in prompts or issues</li>
<li>A short "never do this" list</li>
</ul>
<h2>Rollout</h2>
<p>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.</p>
<figure class="not-prose my-10 [--diagram-accent:var(--color-teal-500)] [--diagram-edge:var(--color-zinc-400)] [--diagram-ink:var(--color-zinc-800)] [--diagram-quiet:var(--color-zinc-500)] [--diagram-rule:var(--color-zinc-200)] dark:[--diagram-accent:var(--color-teal-400)] dark:[--diagram-edge:var(--color-zinc-500)] dark:[--diagram-ink:var(--color-zinc-100)] dark:[--diagram-quiet:var(--color-zinc-400)] dark:[--diagram-rule:var(--color-zinc-700)]"><svg viewBox="0 0 760 304" role="img" aria-label="Rollout in three phases. Phase 1: agent-ready issues are delegated to Linear Agent, opening once the agent tooling and tier automation are in place. Phase 2: Shapers ship green-tier PRs with a preview-env self-check, opening once preview environments are live and Phase 1 quality holds. Phase 3: Shapers open yellow proposal PRs that Builders adopt, opening once Shaper changes match the Builder baseline. Preview environments are built in parallel with Phase 1, and each phase opens after a go/no-go review." font-size="13" class="hidden h-auto w-full md:block"><defs><marker id="roll-arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="var(--diagram-edge)"></path></marker></defs><text x="24" y="30" font-size="15" font-weight="600" fill="var(--diagram-ink)">Builders start first; Shapers join once preview envs are live</text><g><rect x="24" y="56" width="226" height="152" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="36" y1="154" x2="238" y2="154" stroke="var(--diagram-rule)"></line><text x="36" y="78" font-size="11.5" fill="var(--diagram-quiet)">Phase 1</text><text x="36" y="100" font-weight="600" fill="var(--diagram-ink)">Builders delegate</text><text x="36" y="122" font-size="11.5" fill="var(--diagram-ink)">Agent-ready issues are</text><text x="36" y="138" font-size="11.5" fill="var(--diagram-ink)">delegated to Linear Agent</text><text x="36" y="176" font-size="11.5" fill="var(--diagram-quiet)">Opens: agent tooling and</text><text x="36" y="192" font-size="11.5" fill="var(--diagram-quiet)">tier automation in place</text></g><g><rect x="266" y="56" width="226" height="152" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="278" y1="154" x2="480" y2="154" stroke="var(--diagram-rule)"></line><text x="278" y="78" font-size="11.5" fill="var(--diagram-quiet)">Phase 2</text><text x="278" y="100" font-weight="600" fill="var(--diagram-ink)">Shapers ship green</text><text x="278" y="122" font-size="11.5" fill="var(--diagram-ink)">Green-tier PRs with a</text><text x="278" y="138" font-size="11.5" fill="var(--diagram-ink)">preview-env self-check</text><text x="278" y="176" font-size="11.5" fill="var(--diagram-quiet)">Opens: preview envs live</text><text x="278" y="192" font-size="11.5" fill="var(--diagram-quiet)">and Phase 1 quality holds</text></g><g><rect x="508" y="56" width="226" height="152" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="520" y1="154" x2="722" y2="154" stroke="var(--diagram-rule)"></line><text x="520" y="78" font-size="11.5" fill="var(--diagram-quiet)">Phase 3</text><text x="520" y="100" font-weight="600" fill="var(--diagram-ink)">Yellow proposals</text><text x="520" y="122" font-size="11.5" fill="var(--diagram-ink)">Shapers open proposal PRs;</text><text x="520" y="138" font-size="11.5" fill="var(--diagram-ink)">Builders adopt and own them</text><text x="520" y="176" font-size="11.5" fill="var(--diagram-quiet)">Opens: Shaper changes</text><text x="520" y="192" font-size="11.5" fill="var(--diagram-quiet)">match the Builder baseline</text></g><path d="M258 122l10 10l-10 10l-10 -10z" fill="var(--diagram-edge)"></path><path d="M500 122l10 10l-10 10l-10 -10z" fill="var(--diagram-edge)"></path><g><rect x="24" y="224" width="226" height="32" rx="6" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25" stroke-dasharray="4 3"></rect><text x="36" y="244" font-size="11.5" fill="var(--diagram-ink)">In parallel: build preview envs</text><path d="M250 240H290V208" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25" marker-end="url(#roll-arrow)"></path></g><g><path d="M30 278l8 8l-8 8l-8 -8z" fill="var(--diagram-edge)"></path><text x="46" y="290" font-size="11.5" fill="var(--diagram-quiet)">Go/no-go review against the entry criteria</text></g></svg><svg viewBox="0 0 340 676" role="img" aria-label="Rollout in three phases. Phase 1: agent-ready issues are delegated to Linear Agent, opening once the agent tooling and tier automation are in place. Phase 2: Shapers ship green-tier PRs with a preview-env self-check, opening once preview environments are live and Phase 1 quality holds. Phase 3: Shapers open yellow proposal PRs that Builders adopt, opening once Shaper changes match the Builder baseline. Preview environments are built in parallel with Phase 1, and each phase opens after a go/no-go review." class="block h-auto w-full md:hidden"><defs><marker id="roll-arrow-narrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="var(--diagram-edge)"></path></marker></defs><text x="0" y="18" font-size="15" font-weight="600" fill="var(--diagram-ink)">Builders start first; Shapers join</text><text x="0" y="38" font-size="15" font-weight="600" fill="var(--diagram-ink)">once preview envs are live</text><g><rect x="1" y="60" width="338" height="150" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="15" y1="158" x2="325" y2="158" stroke="var(--diagram-rule)"></line><text x="15" y="82" font-size="12" fill="var(--diagram-quiet)">Phase 1</text><text x="15" y="104" font-size="15" font-weight="600" fill="var(--diagram-ink)">Builders delegate</text><text x="15" y="126" font-size="13" fill="var(--diagram-ink)">Agent-ready issues are</text><text x="15" y="144" font-size="13" fill="var(--diagram-ink)">delegated to Linear Agent</text><text x="15" y="180" font-size="12" fill="var(--diagram-quiet)">Opens: agent tooling and</text><text x="15" y="196" font-size="12" fill="var(--diagram-quiet)">tier automation in place</text></g><g><rect x="1" y="282" width="338" height="150" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="15" y1="380" x2="325" y2="380" stroke="var(--diagram-rule)"></line><text x="15" y="304" font-size="12" fill="var(--diagram-quiet)">Phase 2</text><text x="15" y="326" font-size="15" font-weight="600" fill="var(--diagram-ink)">Shapers ship green</text><text x="15" y="348" font-size="13" fill="var(--diagram-ink)">Green-tier PRs with a</text><text x="15" y="366" font-size="13" fill="var(--diagram-ink)">preview-env self-check</text><text x="15" y="402" font-size="12" fill="var(--diagram-quiet)">Opens: preview envs live</text><text x="15" y="418" font-size="12" fill="var(--diagram-quiet)">and Phase 1 quality holds</text></g><g><rect x="1" y="480" width="338" height="150" rx="8" fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"></rect><line x1="15" y1="578" x2="325" y2="578" stroke="var(--diagram-rule)"></line><text x="15" y="502" font-size="12" fill="var(--diagram-quiet)">Phase 3</text><text x="15" y="524" font-size="15" font-weight="600" fill="var(--diagram-ink)">Yellow proposals</text><text x="15" y="546" font-size="13" fill="var(--diagram-ink)">Shapers open proposal PRs;</text><text x="15" y="564" font-size="13" fill="var(--diagram-ink)">Builders adopt and own them</text><text x="15" y="600" font-size="12" fill="var(--diagram-quiet)">Opens: Shaper changes</text><text x="15" y="616" font-size="12" fill="var(--diagram-quiet)">match the Builder baseline</text></g><g fill="none" stroke="var(--diagram-edge)" stroke-width="1.25"><path d="M40 210V282" marker-end="url(#roll-arrow-narrow)"></path><path d="M40 432V480" marker-end="url(#roll-arrow-narrow)"></path><rect x="120" y="226" width="219" height="32" rx="6" stroke-dasharray="4 3"></rect><path d="M144 258V282" marker-end="url(#roll-arrow-narrow)"></path></g><text x="132" y="247" font-size="12.5" fill="var(--diagram-ink)">In parallel: build preview envs</text><path d="M40 236l10 10l-10 10l-10 -10z" fill="var(--diagram-edge)"></path><path d="M40 446l10 10l-10 10l-10 -10z" fill="var(--diagram-edge)"></path><path d="M11 646l8 8l-8 8l-8 -8z" fill="var(--diagram-edge)" transform="translate(-1 0)"></path><text x="25" y="660" font-size="12" fill="var(--diagram-quiet)">Go/no-go review against the entry criteria</text></svg></figure>
<h2>Metrics</h2>
<p>Measure throughput, quality, and morale together; a phase advances only when all three hold. A developer-experience platform such as <a href="https://getdx.com">DX</a> 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.</p>
<div class="overflow-x-auto"><table><thead><tr><th>Metric</th><th>Kind</th><th>Source</th><th>Why it matters</th></tr></thead><tbody><tr><td>Share of issues with an agent draft</td><td>Throughput</td><td>GitHub data</td><td>Shows the inner loop is actually changing</td></tr><tr><td>Issue-to-merge cycle time</td><td>Throughput</td><td>GitHub data</td><td>The core outcome of Pillar 1</td></tr><tr><td>Agent PR discard rate</td><td>Quality</td><td>GitHub data</td><td>High rates point to weak specs or readiness gaps</td></tr><tr><td>Revert and incident rate, by tier and contributor group</td><td>Quality</td><td>GitHub data</td><td>Shaper changes must match the Builder baseline and each tier must hold steady as volume grows</td></tr><tr><td>Review hours per Builder per week</td><td>Morale</td><td>GitHub data</td><td>Guards against Builders becoming a review queue</td></tr><tr><td>Code review satisfaction</td><td>Morale</td><td>Quarterly developer survey</td><td>Shows whether review is becoming a burden as agent PR volume grows</td></tr><tr><td>Agent tooling satisfaction</td><td>Morale</td><td>Tooling CSAT survey</td><td>Shows whether the agent, Copilot review, and the workflow actually help</td></tr></tbody></table></div>
<p>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.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My expectations of engineering initiative owners]]></title>
            <link>https://iangineering.com/articles/engineering-initiative-owner-expectations</link>
            <guid isPermaLink="false">https://iangineering.com/articles/engineering-initiative-owner-expectations</guid>
            <pubDate>Sun, 30 Jun 2024 00:00:00 GMT</pubDate>
            <content:encoded><![CDATA[<p>One of the things I love about the culture on the teams I lead is that there is a high degree of individual ownership. Most of the engineers on my teams are full stack and are expected to be the main drivers of getting initiatives that they own shipped to our customers. Sometimes this responsibility can be overwhelming and we might forget to make sure some aspect of the initiative has been executed properly. I made this checklist to help initiative owners understand what's expected of them when they lead an initiative and even what exceeding those expectations might look like.</p>
<p>Owning an initiative means making sure each of these questions gets answered, not doing every task yourself. Not every question applies to every initiative, and "no" is often a perfectly good answer. "We don't need an RFC because the change is small and easy to reverse" is fine; never having asked the question is not. I recommend going through the list at kickoff, at a midpoint check-in, again before launch, and once more after launch. It also works well as a self-review when performance reviews come around.</p>
<h2>Meeting Expectations</h2>
<p>Here is a non-exhaustive list of questions you should be asking yourself to help ensure you are meeting expectations as an initiative owner:</p>
<ol>
<li>Planning<!-- -->
<ol>
<li>Have you read the Product Requirements Document (PRD), and do you understand the problem we're solving, why it matters now, how Product will measure success, and what is out of scope?</li>
<li>If the feature is an experiment, do you understand the hypothesis and how we'll decide whether it worked?</li>
<li>Do we need an RFC (Request For Comment)?</li>
<li>Has an epic been created?</li>
<li>Have the work items been broken down into stories and estimated?</li>
<li>Have we tried to break up the work so that at least two people have a solid understanding of the problem and solution?</li>
<li>Could another running experiment or a feature being developed in parallel conflict with this one or skew its results?</li>
<li>Are we making sure that we're not adding too much logic to the client instead of the backend, where it can change without an app release and stays consistent across clients?</li>
<li>Have we thought about how the solution will scale? For example, do we need certain indexes or rate-limiting?</li>
</ol>
</li>
<li>Communication<!-- -->
<ol>
<li>Have we reached out to the appropriate stakeholders (e.g. Product, Marketing, Customer Support, Finance, Legal) to gather ideas, context, and feedback?</li>
<li>Are stakeholders getting regular status updates?</li>
<li>Are risks, scope changes, and slipping dates being raised as soon as we know about them?</li>
<li>Are the epic and its stories up to date so that anyone can see where things stand?</li>
</ol>
</li>
<li>Execution<!-- -->
<ol>
<li>Are draft PRs being created as soon as possible so that there is transparency and we can course-correct early if necessary?</li>
<li>Have unit tests, integration tests, and/or end-to-end tests been added?</li>
<li>Have the author and main reviewer both tested the changes locally, and has the author described in the PR how they were tested?</li>
<li>Does the feature require manual testing and if so, are those manual test cases ready to be executed?</li>
<li>Have the necessary pieces been put in place so that we can test in staging and/or production?</li>
</ol>
</li>
<li>Monitoring<!-- -->
<ol>
<li>Have we added enough logging so that we can understand what's happening?</li>
<li>Are we capturing system metrics that we can analyze and use with alerting?</li>
<li>Have alerts been set up so that we can know when the system is not behaving in a way we expect?</li>
<li>Does whoever gets alerted know what to do when an alert fires, for example by following a runbook?</li>
<li>Do we need a dashboard to centralize system metrics and information?</li>
<li>Have we added the necessary eventing so that we can monitor performance from a product perspective?</li>
</ol>
</li>
<li>Rollout<!-- -->
<ol>
<li>Is there a rollout plan, including whether the feature should be behind an experiment or feature flag, released to internal users first, or ramped up by percentage?</li>
<li>Is there a plan for rolling back if something goes wrong?</li>
<li>Are migrations and backfills safe to run, and are the changes backwards compatible?</li>
<li>Will older versions of our clients, such as mobile apps, continue to work?</li>
<li>Have Customer Support and Marketing been told what's launching and when?</li>
</ol>
</li>
<li>Presentation<!-- -->
<ol>
<li>Have you demoed the initiative?</li>
<li>Did you clearly explain the "why" before getting into the "how"?</li>
<li>Are you able to efficiently transfer knowledge about the system to other team members through discussion and documentation?</li>
</ol>
</li>
<li>Post-launch<!-- -->
<ol>
<li>Has the feature been verified in production?</li>
<li>Have we checked the results against the success metrics?</li>
<li>Have feature flags, losing experiment variants, and dead code been cleaned up?</li>
</ol>
</li>
</ol>
<h2>Exceeding Expectations</h2>
<p>Here is a non-exhaustive list of questions that may be asked to determine if you've exceeded expectations while leading an initiative:</p>
<ol>
<li>Have you surfaced any opportunities to improve the product through your technical insight into the system?</li>
<li>Is the solution architected better than one would expect, so that it runs in less time, uses fewer resources, scales more easily, or costs less than a typical implementation would?</li>
<li>Did you find a way to deliver value earlier, such as a smaller first version or a phased launch?</li>
<li>Did you spot risks early and deal with them before they became problems?</li>
<li>Did you recommend cutting scope, changing direction, or stopping when the data or the cost called for it?</li>
<li>Were you able to meet all expectations with less guidance than one would expect?</li>
<li>Have you built or found dashboards for your initiative's product metrics and made checking them a regular habit?</li>
<li>Did you help a teammate grow by mentoring them through part of the work?</li>
<li>Did you leave shared tooling or processes better than you found them?</li>
<li>Can others learn or borrow from the system you've helped construct?</li>
<li>Are there important lessons you've learned through the process that you've shared with the rest of the team?</li>
<li>Were you able to accomplish a personal growth goal through working on the initiative?</li>
</ol>
<p>The goal of this checklist isn't to turn ownership into paperwork. It's to make sure nothing important gets missed, so that you can spend your energy on the parts of the initiative that are actually hard.</p>]]></content:encoded>
        </item>
    </channel>
</rss>