<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Organization on Wilson Wu</title><link>https://wilsonwu.me/tags/organization/</link><description>Recent content in Organization on Wilson Wu</description><generator>Hugo</generator><language>en-US</language><lastBuildDate>Fri, 20 Nov 2026 00:00:00 -0500</lastBuildDate><atom:link href="https://wilsonwu.me/tags/organization/index.xml" rel="self" type="application/rss+xml"/><item><title>The Evolution of Software R&amp;D Organizations in the AI Era: Abolish the Functional Split, Keep Only Three Roles</title><link>https://wilsonwu.me/blog/2026/ai-native-rd-organization/</link><pubDate>Fri, 20 Nov 2026 00:00:00 -0500</pubDate><guid>https://wilsonwu.me/blog/2026/ai-native-rd-organization/</guid><description>&lt;p&gt;&lt;img alt="AI-native R&amp;amp;D organization" loading="lazy" src="https://wilsonwu.me/blog/2026/ai-native-rd-organization/1-ai-native-rd-organization.png"&gt;&lt;/p&gt;
&lt;h2 id="introduction"&gt;Introduction&lt;/h2&gt;
&lt;p&gt;Over the past two years, what AI can do with code has reset our expectations almost every quarter: from line-by-line completion, to editing code through conversation in the IDE, to handing an issue straight to a coding agent that reads the code, changes it, runs the tests and opens a PR on its own. In many scenarios, one skilled engineer working with a few AI agents can already deliver what used to take a whole team.&lt;/p&gt;</description><content:encoded><![CDATA[<p><img alt="AI-native R&amp;D organization" loading="lazy" src="/blog/2026/ai-native-rd-organization/1-ai-native-rd-organization.png"></p>
<h2 id="introduction">Introduction</h2>
<p>Over the past two years, what AI can do with code has reset our expectations almost every quarter: from line-by-line completion, to editing code through conversation in the IDE, to handing an issue straight to a coding agent that reads the code, changes it, runs the tests and opens a PR on its own. In many scenarios, one skilled engineer working with a few AI agents can already deliver what used to take a whole team.</p>
<p>Yet most teams&rsquo; org charts have barely changed. Frontend, backend, QA, product and UI design groups each do their own part, and requirements still travel station by station down the same pipeline: &ldquo;product writes a PRD → design produces mockups → frontend and backend development → testing → release&rdquo;. Even if AI made the coding station ten times faster, the pipeline as a whole would not be ten times faster, because most of the time was never spent writing code in the first place. It goes into waiting, handoffs and alignment.</p>
<p>My view is simple: <strong>in the AI era, the organizational structure and division of labor by function (frontend, backend, QA, product and UI design) should be abolished entirely</strong>. Not by adding an &ldquo;AI team&rdquo; to the existing structure, and not by letting each function adopt AI on its own, but by reorganizing from the ground up around just three roles:</p>
<ul>
<li><strong>Product Architect</strong>: the architect role stays, but its scope expands from technical architecture to product architecture; it defines the unified metadata and rules of the whole product.</li>
<li><strong>Module Owner</strong>: there is no more frontend versus backend; each module gets one full-stack developer as its owner, who directs AI to build the whole module.</li>
<li><strong>Intent Owner</strong>: replaces the traditional product manager and focuses on just two things: managing and confirming requirements, and the final hands-on use and acceptance.</li>
</ul>
<p>These names are new on purpose. The industry has no established names for these roles yet, and the names will appear verbatim in the rule files, repositories and tool configurations that AI agents read, so they need to be precise and unambiguous.</p>
<p>The rest of this post covers, in order: why the functional split no longer works, what each of the three roles does, how the organization turns like a flywheel, how to staff it, how the existing team transitions, roughly how much more efficient it can be, and what kind of people the new organization needs most.</p>
<h2 id="part-1-why-the-functional-split-no-longer-works">Part 1: Why the Functional Split No Longer Works</h2>
<h3 id="1-the-premise-of-specialization-has-changed">1. The Premise of Specialization Has Changed</h3>
<p>Frontend, backend, QA and UI design are, at heart, jobs cut along &ldquo;execution skills&rdquo;. That made sense in the past: each skill took years to master, and few people could be experts in React, database tuning, test automation and visual design at the same time. So we traded handoffs for depth, and stitched the pieces together with processes and meetings. The cost of handoffs and communication was the price we paid for specialist depth.</p>
<p>That premise is exactly what AI changes. Building components, writing SQL, writing test cases, tweaking styles: most of this &ldquo;how-to&rdquo; knowledge can now be handed to AI agents, which are reasonably familiar with nearly every mainstream tech stack. Execution skills are no longer scarce. What is scarce now are three things:</p>
<ol>
<li><strong>Setting rules</strong>: what the product should look like, which technologies it uses, and the standard it must be delivered to</li>
<li><strong>Setting direction</strong>: what to do next, and what &ldquo;done&rdquo; means</li>
<li><strong>Making judgments</strong>: whether what AI delivers is right, whether it is good, and whether it can ship</li>
</ol>
<p>An organization should be designed around what is scarce, not around what no longer is.</p>
<h3 id="2-handoffs-have-become-the-bottleneck">2. Handoffs Have Become the Bottleneck</h3>
<p>Here is a requirement&rsquo;s typical journey in a traditional team: product writes a PRD, then a review meeting; design produces interaction and visual mockups, then another review meeting; frontend and backend split the tasks and negotiate the interfaces, frontend waits for the backend APIs, backend waits for product to clarify details; when development is done it goes to QA, waits in the testing queue, and gets bounced back when issues turn up&hellip; The time actually spent writing code is often a small fraction of the whole cycle.</p>
<p>This is Amdahl&rsquo;s law applied to software delivery: how much a whole system can speed up is limited by the part that is not accelerated. AI has compressed the coding stage to a fraction of what it was, but as long as handoffs, queues and alignment remain, lead time will not improve by an order of magnitude. To turn AI&rsquo;s gains into delivery speed, you have to eliminate the handoffs themselves, and handoffs are a direct product of the division of labor.</p>
<h3 id="3-conways-law-systems-mirror-the-organizations-that-build-them">3. Conway&rsquo;s Law: Systems Mirror the Organizations That Build Them</h3>
<p>In 1968, Melvin Conway made the observation that later became known as Conway&rsquo;s law: an organization that designs a system will produce a design whose structure copies the organization&rsquo;s communication structure. Split teams into frontend and backend, and the system naturally splits into a frontend layer and a backend layer, connected by interfaces negotiated across teams; changing a single business feature often spans several teams.</p>
<p>In the AI era, we would rather slice systems vertically by business module: one module, from UI and APIs down to data and tests, owned end to end by one person working with AI. By Conway&rsquo;s law, if you want that system, you first need that organization. This is what the industry calls the &ldquo;Inverse Conway Maneuver&rdquo;.</p>
<h3 id="4-ai-needs-unified-context-but-the-functional-split-fragments-it">4. AI Needs Unified Context, but the Functional Split Fragments It</h3>
<p>The quality of an AI agent&rsquo;s output depends heavily on the context it gets. In a functionally split team, that context is fragmented: requirements live in product&rsquo;s documents, visual specs in the design tool, test cases in the test management platform, and release rules in the heads of the operations folks. Each function keeps its own set, and they often disagree.</p>
<p>People can align in meetings; AI cannot. AI only knows what it can read. So an organization that really suits AI needs someone to gather this scattered knowledge into a single, explicit, machine-readable body of &ldquo;product metadata&rdquo;. That is exactly the Product Architect&rsquo;s job.</p>
<p>Here is the traditional functional split next to the AI-native organization:</p>
<table>
	<thead>
			<tr>
					<th>Dimension</th>
					<th>Traditional functional split</th>
					<th>AI-native organization</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Scarce resource</td>
					<td>Execution skills: writing code, designing, writing test cases</td>
					<td>Rules, direction and judgment</td>
			</tr>
			<tr>
					<td>How work is sliced</td>
					<td>Horizontally by skill: frontend, backend, QA, design</td>
					<td>Vertically by module: one owner end to end</td>
			</tr>
			<tr>
					<td>How people collaborate</td>
					<td>Document handoffs, review meetings, testing queues</td>
					<td>Shared product metadata; AI executes, people decide and accept</td>
			</tr>
			<tr>
					<td>Where knowledge lives</td>
					<td>Scattered across each function&rsquo;s documents and personal experience</td>
					<td>Centralized in the product metadata, readable by people and AI</td>
			</tr>
			<tr>
					<td>Quality assurance</td>
					<td>The QA team guards the gate at the end</td>
					<td>Rules up front, automated gates plus human testing</td>
			</tr>
	</tbody>
</table>
<h2 id="part-2-the-new-organization-only-three-roles">Part 2: The New Organization: Only Three Roles</h2>
<p><img alt="From functional silos to three roles" loading="lazy" src="/blog/2026/ai-native-rd-organization/2-org-before-after.png"></p>
<p>The new organization keeps only three roles, plus the senior leadership that makes the call on key rules:</p>
<table>
	<thead>
			<tr>
					<th>Role</th>
					<th>Core responsibilities</th>
					<th>Main outputs</th>
					<th>Headcount</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Product Architect</td>
					<td>Defines and maintains the product metadata, divides the product into modules</td>
					<td>Product metadata, module boundaries</td>
					<td>Few</td>
			</tr>
			<tr>
					<td>Module Owner</td>
					<td>Full-stack development: directs AI through end-to-end development of a module and keeps iterating</td>
					<td>Shippable modules, rule improvements</td>
					<td>Many</td>
			</tr>
			<tr>
					<td>Intent Owner</td>
					<td>Manages and feeds in requirements, confirms them, human testing, final acceptance and feedback</td>
					<td>Requirements, acceptance decisions, targeted feedback</td>
					<td>Many</td>
			</tr>
	</tbody>
</table>
<p>There is no frontend or backend here, no dedicated QA, no product manager in the traditional sense, and no dedicated UI designer. The work has not disappeared; it is carried differently: execution goes to AI, rules settle into the product metadata, and judgment stays with people.</p>
<p>To be clear: <strong>what we abolish is the division of labor, not the people</strong>. Part 8 covers which new role each existing function can move into.</p>
<h2 id="part-3-product-architect-from-technical-architecture-to-product-architecture">Part 3: Product Architect: From Technical Architecture to Product Architecture</h2>
<h3 id="1-an-expanded-remit-defining-the-product-metadata">1. An Expanded Remit: Defining the Product Metadata</h3>
<p>A traditional architect mainly owns the technical architecture: how the system is layered, how services are split, which middleware to use. In the new organization the architect stays, but the remit expands to the entire product, hence the name Product Architect. Its core output is a unified body of <strong>Product Metadata</strong>, the definition of all the foundational elements of the product:</p>
<p><img alt="Product metadata" loading="lazy" src="/blog/2026/ai-native-rd-organization/3-product-metadata.png"></p>
<table>
	<thead>
			<tr>
					<th>Metadata</th>
					<th>What it defines</th>
					<th>Concrete form (examples)</th>
					<th>Who decides</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Style</td>
					<td>Brand tone, copywriting voice, glossary</td>
					<td>Style guide, glossary</td>
					<td>Leadership</td>
			</tr>
			<tr>
					<td>Visual</td>
					<td>Colors, typography, spacing, icons, components</td>
					<td>Design tokens, component library</td>
					<td>Product Architect; brand-related parts confirmed by leadership</td>
			</tr>
			<tr>
					<td>Experience</td>
					<td>Interaction patterns, navigation structure, accessibility, performance budgets, error messages</td>
					<td>Experience guidelines, performance budgets</td>
					<td>Product Architect</td>
			</tr>
			<tr>
					<td>Tech Stack</td>
					<td>Languages, frameworks, databases, cloud services, and the reasons behind each choice</td>
					<td>Architecture decision records (ADRs)</td>
					<td>Leadership</td>
			</tr>
			<tr>
					<td>CI Rules</td>
					<td>Required checks, branching strategy, code review rules</td>
					<td>CI pipelines, branch protection</td>
					<td>Product Architect</td>
			</tr>
			<tr>
					<td>Environment Rules</td>
					<td>Definitions of the development, test, staging and production environments; configuration and secret management</td>
					<td>Infrastructure as code (IaC), environment templates</td>
					<td>Product Architect</td>
			</tr>
			<tr>
					<td>Release Rules</td>
					<td>Release cadence, canary strategy, rollback conditions, change approval</td>
					<td>Release pipelines, release runbook</td>
					<td>Leadership</td>
			</tr>
			<tr>
					<td>Test Entry Rules</td>
					<td>Conditions a change must meet before it enters human testing</td>
					<td>Quality gates</td>
					<td>Product Architect</td>
			</tr>
			<tr>
					<td>Acceptance Rules</td>
					<td>How to write acceptance criteria, who accepts, what counts as a pass</td>
					<td>Acceptance templates, Definition of Done</td>
					<td>Product Architect together with the Intent Owners</td>
			</tr>
	</tbody>
</table>
<p>For the items that leadership decides, the Product Architect still drafts the proposal.</p>
<h3 id="2-three-properties-of-the-product-metadata">2. Three Properties of the Product Metadata</h3>
<p><strong>First, it is mainly for AI agents.</strong> The product metadata is not a spec gathering dust on a wiki. It lives as files in the code repository, and AI agents read it every time they work. For example:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>.
</span></span><span style="display:flex;"><span>├── AGENTS.md                      # Single entry point for every AI agent; points to the metadata below
</span></span><span style="display:flex;"><span>├── .github/
</span></span><span style="display:flex;"><span>│   ├── copilot-instructions.md    # Repository-wide instructions for GitHub Copilot
</span></span><span style="display:flex;"><span>│   ├── workflows/                 # CI rules
</span></span><span style="display:flex;"><span>│   └── skills/                    # Skills shared by the team
</span></span><span style="display:flex;"><span>├── product/                       # Product metadata
</span></span><span style="display:flex;"><span>│   ├── style.md                   # Style
</span></span><span style="display:flex;"><span>│   ├── design-tokens.json         # Visual
</span></span><span style="display:flex;"><span>│   ├── experience.md              # Experience
</span></span><span style="display:flex;"><span>│   ├── tech-stack.md              # Tech stack and the reasons behind it
</span></span><span style="display:flex;"><span>│   ├── environments.md            # Environment rules
</span></span><span style="display:flex;"><span>│   ├── release.md                 # Release rules
</span></span><span style="display:flex;"><span>│   ├── test-entry.md              # Test entry rules
</span></span><span style="display:flex;"><span>│   └── acceptance.md              # Acceptance rules
</span></span><span style="display:flex;"><span>└── modules/
</span></span><span style="display:flex;"><span>    ├── account/AGENTS.md          # Module-level rules, maintained by the Module Owner
</span></span><span style="display:flex;"><span>    └── search/AGENTS.md
</span></span></code></pre></div><p><a href="https://agents.md/">AGENTS.md</a> is an open format already supported by many coding agents, and the AGENTS.md closest to the edited file takes precedence, which makes subdirectory files a natural home for module-level rules. <code>.github/copilot-instructions.md</code> holds GitHub Copilot&rsquo;s <a href="https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions">repository custom instructions</a>. Skills package reusable capabilities (see my earlier post <a href="/blog/2026/ai-skills/">AI Programming Enters the Skill Era</a>). The specific format matters less than this: the rules exist as files, are versioned and reviewable, and AI reads them every time.</p>
<p><strong>Second, the whole team must understand it.</strong> Although the product metadata is mainly read by AI, it is the &ldquo;constitution&rdquo; of the whole product. Every Module Owner and Intent Owner must be able to read it: a Module Owner needs to know the boundaries when directing AI, and an Intent Owner needs to know the standard when accepting work. So it has to be written clearly in natural language. Anyone can propose a change through a pull request, and the Product Architect reviews and merges it.</p>
<p><strong>Third, decisions are tiered.</strong> The Product Architect defines most of the metadata, but items that touch brand, cost and risk, such as style, tech stack and release rules, should be decided by senior leadership. The Product Architect prepares the options, trade-offs and a recommendation, leadership decides, and the decision is written into the metadata.</p>
<h3 id="3-an-example-test-entry-rules">3. An Example: Test Entry Rules</h3>
<p>In a traditional team, test entry criteria are usually an informal &ldquo;ready for QA&rdquo; agreement between developers and testers, and how well it is followed depends on goodwill. In the new organization, it becomes a rule that AI and people can both read and machines can check:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-markdown" data-lang="markdown"><span style="display:flex;"><span># Test Entry Rules
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Before any change enters human testing, all of the following must hold:
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> CI passes: lint, type checks, unit tests, build
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Unit test coverage of new and changed code is at least 80%
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Every acceptance criterion has at least one automated end-to-end test
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Core pages meet the performance budget: LCP under 2.5 seconds (simulated mobile network)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Security scans report no high-severity issues, and dependencies have no known critical vulnerabilities
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> The change description is clear: what changed, how it was verified, which modules it affects
</span></span></code></pre></div><p>AI agents check, test and fix their own work against these rules before submitting; CI automatically checks whatever can be checked automatically; and the rest, such as whether the change description is clear, is up to the Module Owner. Testing expertise has not disappeared. It has moved from &ldquo;the QA team&rsquo;s experience&rdquo; to &ldquo;standards written into the rules&rdquo;.</p>
<h3 id="4-dividing-modules-and-assigning-owners">4. Dividing Modules and Assigning Owners</h3>
<p>Besides the product metadata, the Product Architect divides the product into modules: by business capability (such as accounts, search, orders and payments), not by technical layer, with modules collaborating through explicit interface contracts. Once the modules are defined, the Product Architect works with management to assign an owner to each one. How well the module boundaries are drawn directly determines whether Module Owners can deliver independently, end to end.</p>
<h2 id="part-4-module-owner-a-full-stack-developer-who-directs-ai-to-build-a-whole-module">Part 4: Module Owner: A Full-Stack Developer Who Directs AI to Build a Whole Module</h2>
<p><img alt="Vertical slices by module" loading="lazy" src="/blog/2026/ai-native-rd-organization/4-module-owners.png"></p>
<h3 id="1-no-more-frontend-and-backend">1. No More Frontend and Backend</h3>
<p>Each module gets one owner, responsible for it end to end: UI, APIs, data, tests, deployment and monitoring, all done with AI. No more &ldquo;frontend waiting for backend APIs&rdquo;, and no more arguing over &ldquo;is this a frontend bug or a backend bug&rdquo;, because one person owns it from top to bottom.</p>
<p>&ldquo;Full-stack&rdquo; here does not mean one person hand-writes the code of every layer the way specialists used to. It means being able to understand every layer, judge whether AI&rsquo;s approach is right, and trace a problem all the way down when something breaks. Deep specialist knowledge lives partly in the AI and partly in the product metadata and skills; what the owner needs is breadth, judgment and command of the whole module.</p>
<h3 id="2-an-owners-daily-work">2. An Owner&rsquo;s Daily Work</h3>
<p>A Module Owner&rsquo;s day looks very different from that of an engineer who used to write code:</p>
<ul>
<li><strong>Break down</strong>: turn the requirements and feedback from Intent Owners into tasks AI can execute</li>
<li><strong>Direct</strong>: assign tasks to different AI agents, for example one to implement, one to write tests, one to review</li>
<li><strong>Review</strong>: examine AI&rsquo;s designs and code, make technical trade-offs, and take final responsibility for quality</li>
<li><strong>Self-test</strong>: walk through the whole thing as a developer before handing it to an Intent Owner for acceptance</li>
<li><strong>Improve the rules</strong>: when AI keeps making the same kind of mistake, add to the module rules or propose a change to the product metadata to the Product Architect</li>
<li><strong>Be on call</strong>: when something goes wrong after release, the owner investigates and fixes it with AI</li>
</ul>
<p>In one sentence: <strong>people are no longer the producers of code, but the directors of AI and the ones ultimately accountable for quality</strong>.</p>
<h3 id="3-how-big-should-a-module-be">3. How Big Should a Module Be?</h3>
<p>Module size depends on whether the owner, working with AI, can deliver at a steady pace and still hold the line on quality. Too big, and the owner becomes the bottleneck; too small, and coordination costs between modules come back. A simple test: the owner can fully explain every feature and every piece of data in the module. Important modules can have a backup owner to avoid a single point of failure.</p>
<h2 id="part-5-intent-owner-owning-requirements-and-acceptance">Part 5: Intent Owner: Owning Requirements and Acceptance</h2>
<h3 id="1-why-a-new-name">1. Why a New Name?</h3>
<p>A traditional product manager does a great many things: market research, competitive analysis, writing PRDs, drawing prototypes, tracking progress, coordinating resources, running reviews, analyzing data&hellip; Much of it can either be handed to AI or is simply unnecessary in the new organization: without handoffs between functions, far less coordination is needed. What remains are the two things AI finds hardest to replace:</p>
<ol>
<li><strong>Knowing what is wanted</strong>: understanding users and the business, and turning vague ideas into clear requirements that can be accepted</li>
<li><strong>Judging whether it is right</strong>: using the product in person and judging whether what was built is what was really wanted</li>
</ol>
<p>That is why I gave this role a new name: <strong>Intent Owner</strong>. In the AI era, people provide the intent and AI does the execution. The Intent Owner owns the intent all the way through: from the moment it enters development (requirements) to the moment it is realized (acceptance), with the execution in between handled by Module Owners and AI. Keep calling the role &ldquo;product manager&rdquo; and everyone will assume it still writes PRDs, draws prototypes and manages projects; a new name draws a clear line around the responsibilities.</p>
<p>It resembles the Product Owner in Scrum, since both are responsible for the backlog. The difference is that an Intent Owner treats hands-on use and acceptance as the core of the job, and carries no project management duties at all.</p>
<h3 id="2-first-job-managing-requirements">2. First Job: Managing Requirements</h3>
<p>The Intent Owner manages the backlog and keeps feeding requirements to the modules. The keyword is &ldquo;confirm&rdquo;: before a requirement goes into development, the Intent Owner and the Module Owner confirm the intent together, especially the acceptance criteria, that is, what &ldquo;done&rdquo; looks like. Requirements do not need a PRD dozens of pages long, but the acceptance criteria must be specific and checkable, because they are used by AI (to generate test cases), by the Module Owner (to self-test) and by the Intent Owner (to accept).</p>
<p>A good requirement looks roughly like this:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-markdown" data-lang="markdown"><span style="display:flex;"><span><span style="color:#75715e">## Requirement: Filter the order list by status
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Intent: Customer support handles a large number of &#34;pending refund&#34; orders every day.
</span></span><span style="display:flex;"><span>Today they have to page through the list to find them; they want to filter them quickly.
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Acceptance criteria:
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">1.</span> A status filter is added at the top of the order list; several statuses can be selected; no filter by default
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">2.</span> After selecting &#34;pending refund&#34;, only pending-refund orders are shown, and the filter persists across pages
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">3.</span> The filter is reflected in the URL, so it survives a page refresh or a shared link
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">4.</span> With up to 10,000 orders, filter results return within 1 second
</span></span></code></pre></div><h3 id="3-second-job-human-testing-and-final-acceptance">3. Second Job: Human Testing and Final Acceptance</h3>
<p>Once what AI delivered has passed the automated gates and the Module Owner&rsquo;s self-test, it enters human testing. The Intent Owner uses it like a real user, checks it against the acceptance criteria one by one, and gives a verdict: accepted, or sent back with feedback.</p>
<p>Feedback quality directly determines iteration speed. A Module Owner cannot direct AI to fix &ldquo;it doesn&rsquo;t feel very usable&rdquo;. Good feedback must be targeted:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-markdown" data-lang="markdown"><span style="display:flex;"><span><span style="color:#75715e">## Feedback: Order status filter
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Acceptance criterion: #3
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Steps: select &#34;pending refund&#34;, copy the page link, open it in a new window
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Expected: the new window still shows only pending-refund orders
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Actual: the filter is lost and all orders are shown
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">-</span> Screenshot: filter-lost.png
</span></span></code></pre></div><p>A Module Owner can hand feedback like this to AI almost verbatim to reproduce and fix.</p>
<h3 id="4-why-you-need-many-intent-owners">4. Why You Need Many Intent Owners</h3>
<p>When AI makes &ldquo;building it&rdquo; cheap, the bottleneck moves to both ends: deciding what to build, and judging whether it was built right. The part of a product that one Intent Owner can use and judge in depth is limited. With too few Intent Owners, Module Owners and their AI either sit idle waiting for requirements or, with nobody accepting the work, build a pile of features nobody wants. So in the new organization, there should be about as many Intent Owners as Module Owners.</p>
<h2 id="part-6-making-the-organization-turn-a-flywheel-of-requirements-execution-acceptance-and-rules">Part 6: Making the Organization Turn: A Flywheel of Requirements, Execution, Acceptance and Rules</h2>
<p><img alt="The iteration flywheel" loading="lazy" src="/blog/2026/ai-native-rd-organization/5-iteration-loop.png"></p>
<p>Put the three roles together and the whole development process becomes a flywheel that keeps turning:</p>
<ol>
<li><strong>Input</strong>: the Intent Owner feeds in new requirements (intent plus acceptance criteria) or the feedback from the last round of acceptance</li>
<li><strong>Execution</strong>: the Module Owner breaks down the tasks and directs AI agents to complete development and automated tests within the constraints of the product metadata</li>
<li><strong>Automated gates</strong>: checks run automatically against the CI rules and test entry rules; AI finds and fixes its own problems until everything passes</li>
<li><strong>Human testing</strong>: the Module Owner self-tests first, then hands it to the Intent Owner, who uses and accepts it like a real user</li>
<li><strong>Feedback or release</strong>: if acceptance fails, the Intent Owner gives targeted feedback and the loop returns to step 2; if it passes, it ships according to the release rules</li>
<li><strong>Improve the rules</strong>: for every problem found in a round, ask &ldquo;can this become a rule?&rdquo; If so, add it to the module rules or the product metadata so AI does not make the same mistake again</li>
</ol>
<p>In this flywheel, people do only three things: <strong>set the rules, provide the intent, and make the judgments</strong>. All the remaining execution goes to AI.</p>
<p>Step 6 is what lets this organization speed up over time. In a traditional team, fixing a bug is the end of it, and the same kind of problem shows up somewhere else next time. In the new organization, the goal is to &ldquo;fix the rule, not just the bug&rdquo;. The better the rules, the more consistent AI&rsquo;s output, the fewer problems human testing finds, and the faster the flywheel turns.</p>
<h2 id="part-7-staffing-few-product-architects-many-module-owners-and-intent-owners">Part 7: Staffing: Few Product Architects, Many Module Owners and Intent Owners</h2>
<p>The three roles differ greatly in headcount:</p>
<ul>
<li><strong>Few Product Architects</strong>: the product metadata is shared across the whole product; once established, it changes incrementally, so one or two Product Architects per product are usually enough. A large product can split the role by domain, for example one focused on experience and visual design and one on engineering and delivery, but the total should stay small, because the metadata must have a single, unified source.</li>
<li><strong>Many Module Owners</strong>: the number of modules determines the number of Module Owners; they are the main force of execution.</li>
<li><strong>Many Intent Owners too</strong>: the bottleneck has moved to requirements and acceptance, so there should be about as many Intent Owners as Module Owners.</li>
</ul>
<p>Take a 12-person team. A traditional setup might have 2 product managers, 1 UI designer, 2 QA engineers, 3 frontend and 4 backend developers. Staffed for the new organization, it could be 1 Product Architect, 6 Module Owners and 5 Intent Owners, roughly 1:6:5:</p>
<p><img alt="Same 12 people, new roles" loading="lazy" src="/blog/2026/ai-native-rd-organization/6-team-ratio.png"></p>
<p>This ratio is not a fixed formula, but the direction is clear: Product Architects are the minority, Module Owners and Intent Owners are the majority, and those two groups are roughly equal in size.</p>
<h2 id="part-8-where-the-existing-roles-go">Part 8: Where the Existing Roles Go</h2>
<table>
	<thead>
			<tr>
					<th>Former function</th>
					<th>New role</th>
					<th>Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Architect</td>
					<td>Product Architect</td>
					<td>Expands from technical architecture to product architecture and owns all of the product metadata</td>
			</tr>
			<tr>
					<td>Frontend and backend engineers</td>
					<td>Module Owner</td>
					<td>Fill in the other side&rsquo;s skills with AI&rsquo;s help, moving from &ldquo;I own the frontend&rdquo; to &ldquo;I own this module&rdquo;</td>
			</tr>
			<tr>
					<td>QA engineers</td>
					<td>Intent Owner or Module Owner</td>
					<td>Those good at finding problems from a user&rsquo;s perspective fit the Intent Owner role; those strong in automation and engineering fit the Module Owner role; testing methodology goes into the test entry rules</td>
			</tr>
			<tr>
					<td>Product managers</td>
					<td>Intent Owner</td>
					<td>Drop PRDs, prototypes and project management to focus on requirements and acceptance; those good at designing the product as a whole can also become Product Architects</td>
			</tr>
			<tr>
					<td>UI designers</td>
					<td>Product Architect or Intent Owner</td>
					<td>Visual and experience standards move into the product metadata, and senior designers can become experience-focused Product Architects; designers with a strong feel for the user experience also make excellent Intent Owners</td>
			</tr>
	</tbody>
</table>
<p>In the 12-person example above, one possible transition is: the 2 product managers, 2 QA engineers and 1 UI designer become 5 Intent Owners; of the 7 frontend and backend engineers, 1 senior engineer becomes the Product Architect and the other 6 become Module Owners.</p>
<p>Whatever the path, the transition means broadening skills: frontend developers learn the backend, backend developers learn the UI, testers learn the product, product people learn acceptance, and everyone learns to work with AI and to write rules.</p>
<h2 id="part-9-how-much-more-efficient-a-rough-estimate">Part 9: How Much More Efficient? A Rough Estimate</h2>
<p>First, a caveat: what follows is a model-based estimate built on assumptions, not measured data. I list every assumption, so you can substitute your own team&rsquo;s numbers and redo the math.</p>
<h3 id="1-what-the-research-says-ai-tools-alone-do-not-make-an-organization-more-efficient">1. What the Research Says: AI Tools Alone Do Not Make an Organization More Efficient</h3>
<p>Published research does not agree on how much AI speeds up software development:</p>
<ul>
<li><strong>Individual level</strong>: in a controlled experiment with GitHub Copilot published in 2023, developers were asked to implement an HTTP server in JavaScript, and the group with access to Copilot finished 55.8% faster than the control group.</li>
<li><strong>Real projects</strong>: METR ran a randomized controlled trial with experienced open-source developers in the first half of 2025. Working in large repositories they maintain themselves, the developers took 19% longer when allowed to use the AI tools of the time. Follow-up data from early 2026 began to show signs of speedup, but the confidence intervals still included zero; and because more and more developers declined to take part since they no longer wanted to work without AI, the researchers themselves consider it only very weak evidence.</li>
<li><strong>Organizational level</strong>: DORA&rsquo;s 2024 report found that AI adoption improved individual productivity, flow and job satisfaction, but had a negative impact on software delivery throughput and stability. DORA&rsquo;s 2025 report puts it even more directly: AI&rsquo;s primary role is that of an amplifier, magnifying an organization&rsquo;s existing strengths and weaknesses, and the greatest returns on AI investment come not from the tools themselves but from a strategic focus on the underlying organizational system.</li>
</ul>
<p>This matches the analysis in Part 1: give everyone AI tools and only the &ldquo;doing the work&rdquo; part speeds up; the waiting, handoffs and alignment stay exactly the same.</p>
<h3 id="2-method">2. Method</h3>
<p>Efficiency is measured with two metrics:</p>
<ul>
<li><strong>Lead time</strong>: the calendar time from when a requirement is raised to when it is live; it measures &ldquo;how fast&rdquo;</li>
<li><strong>Output per person</strong>: how many requirements the same people can deliver per month, derived from the person-days each requirement consumes; it measures &ldquo;how much&rdquo;</li>
</ul>
<p>The most important and most uncertain parameter in the estimate is the <strong>AI execution multiplier s</strong>: once execution work such as design, development and testing is handed to AI, the human time spent on it shrinks to 1/s of what it was. It depends on the AI&rsquo;s capability, how complete the product metadata is, and the state of the codebase, so I use three levels: conservative s = 2, neutral s = 4, optimistic s = 6.</p>
<h3 id="3-doing-the-math-one-medium-sized-requirement">3. Doing the Math: One Medium-Sized Requirement</h3>
<p>Take a medium-sized requirement such as an &ldquo;order refund flow&rdquo;: a few pages, a few APIs and one database schema change. In a traditional organization, product, design, frontend, backend and QA all take part. The table compares its lead time and effort in the two organizations (the new organization uses the neutral assumptions):</p>
<table>
	<thead>
			<tr>
					<th>Stage</th>
					<th>Traditional organization</th>
					<th>New organization (neutral)</th>
					<th>Why it changes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Requirements</td>
					<td>Write the PRD and review it: 3 days, including 1 day of waiting</td>
					<td>Confirm the intent and acceptance criteria: 1 day</td>
					<td>No long PRD; the Intent Owner and Module Owner confirm face to face</td>
			</tr>
			<tr>
					<td>Design</td>
					<td>Interaction and visual mockups, review: 3 days, including 1 day of waiting</td>
					<td>Part of AI execution</td>
					<td>Visual design and experience are defined by the product metadata; AI generates the UI to spec</td>
			</tr>
			<tr>
					<td>Scheduling</td>
					<td>Waiting for a development slot: 2 days</td>
					<td>None</td>
					<td>The Module Owner pulls work straight from the backlog</td>
			</tr>
			<tr>
					<td>Development and testing</td>
					<td>Frontend and backend development, integration: 5 days; QA queue and testing: 3 days, including 1 day of waiting</td>
					<td>AI execution (design, development, automated tests, gates): 2.5 days</td>
					<td>Execution goes to AI, tests run automatically per the entry rules, and there is no frontend-backend integration</td>
			</tr>
			<tr>
					<td>Acceptance and fixes</td>
					<td>Fixes, regression testing and product acceptance: 2 days, including 0.5 days of waiting</td>
					<td>Human testing and acceptance: 1 day; fixes from feedback: 1 day</td>
					<td>Feedback goes straight to the Module Owner, and AI fixes it</td>
			</tr>
			<tr>
					<td>Release</td>
					<td>Waiting for a release window: 2 days</td>
					<td>Release per the release rules: 0.5 days</td>
					<td>Continuous release, no waiting for a release window</td>
			</tr>
			<tr>
					<td>Lead time</td>
					<td>20 days</td>
					<td>6 days</td>
					<td>About 3.3x</td>
			</tr>
			<tr>
					<td>Effort</td>
					<td>20 person-days: product 3, design 2, frontend 4, backend 5, QA 4, reviews and communication 2</td>
					<td>7 person-days: Intent Owner 2, Module Owner 4, Product Architect (amortized) 0.5, communication 0.5</td>
					<td>About 2.9x</td>
			</tr>
	</tbody>
</table>
<p>Of the traditional organization&rsquo;s 20 days, only 5 go to writing code, while pure waiting (for reviews, for scheduling, in the QA queue, for regression testing, for the release window) takes 7.5 days. The new organization&rsquo;s speedup comes from three sources: waiting and handoffs essentially disappear; execution work such as design, development and testing goes to AI; and the acceptance and feedback loop gets shorter, so when an Intent Owner finds a problem, the Module Owner can direct AI to fix it the same day.</p>
<h3 id="4-for-comparison-ai-tools-only-no-organizational-change">4. For Comparison: AI Tools Only, No Organizational Change</h3>
<p>Assume exactly the same AI capability (again s = 4), but no organizational change, with each function using AI for its own work: the hands-on time shrinks from 12.5 days to about 5.5 days, but not a single day of the 7.5 days of waiting goes away. Lead time is about 13 days, only about 1.5x faster. On paper, effort per requirement can drop to about 10 person-days, but each function&rsquo;s headcount is fixed: once development speeds up, the bottleneck quickly moves to product and QA, whose headcount has not changed, so the real throughput gain is smaller still.</p>
<p><img alt="Lead time of one medium-sized feature" loading="lazy" src="/blog/2026/ai-native-rd-organization/7-lead-time.png"></p>
<h3 id="5-results-about-3x-in-the-neutral-case">5. Results: About 3x in the Neutral Case</h3>
<table>
	<thead>
			<tr>
					<th>Setup</th>
					<th>Lead time</th>
					<th>Speedup</th>
					<th>Effort per requirement</th>
					<th>Output per person</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Traditional organization (baseline)</td>
					<td>20 days</td>
					<td>1x</td>
					<td>20 person-days</td>
					<td>1x</td>
			</tr>
			<tr>
					<td>Traditional organization + AI tools (s = 4)</td>
					<td>About 13 days</td>
					<td>About 1.5x</td>
					<td>About 10 person-days</td>
					<td>About 2x on paper, limited by bottlenecks in practice</td>
			</tr>
			<tr>
					<td>New organization, conservative (s = 2)</td>
					<td>10 days</td>
					<td>2x</td>
					<td>11.5 person-days</td>
					<td>About 1.7x</td>
			</tr>
			<tr>
					<td>New organization, neutral (s = 4)</td>
					<td>6 days</td>
					<td>About 3.3x</td>
					<td>7 person-days</td>
					<td>About 2.9x</td>
			</tr>
			<tr>
					<td>New organization, optimistic (s = 6)</td>
					<td>3.5 days</td>
					<td>About 5.7x</td>
					<td>5 person-days</td>
					<td>4x</td>
			</tr>
	</tbody>
</table>
<p>The conservative and optimistic cases use the same method as the neutral one; only s differs, and the human steps (confirming requirements, acceptance, rounds of fixes from feedback) take correspondingly longer or shorter.</p>
<p>So my conclusion is: <strong>under the neutral assumptions, the new organization cuts lead time to about a third of what it was and raises output per person to about 3x</strong>. In the conservative case, lead time still halves and output per person rises about 1.7x; in the optimistic case, delivery is more than 5x faster and output per person is about 4x. In terms of a 12-person team: assuming 20 working days per person per month, all spent on requirements, the team used to deliver about 12 medium-sized requirements a month; the new organization can deliver more than 30 in the neutral case.</p>
<h3 id="6-two-conclusions-worth-noting">6. Two Conclusions Worth Noting</h3>
<p><strong>First, the human steps set the ceiling on efficiency.</strong> The larger s gets, the fewer person-days Module Owners spend, but the human steps (confirming intent, human testing and acceptance, rule maintenance and communication) do not disappear as AI gets stronger. Under the neutral assumptions they take about 3 person-days per requirement, which puts the theoretical ceiling on output per person at about 20 ÷ 3 ≈ 6.7x. This is Amdahl&rsquo;s law again: the stronger AI gets, the more the bottleneck concentrates on human judgment. So keep making requirement confirmation and acceptance more efficient, for example by writing acceptance criteria that are more specific and checkable, and handing every acceptance step that can be automated to end-to-end tests.</p>
<p><strong>Second, staffing ratios must follow the workload.</strong> Under the neutral assumptions, each requirement takes about 4 person-days of Module Owner time and about 2 of Intent Owner time, so a balanced 12-person team would be roughly 1:7:4. As AI gets stronger, Module Owners need fewer person-days, the share of Intent Owners rises, and the ratio gradually moves toward the 1:6:5 of Part 7. Get the ratio wrong and the bottleneck role caps throughput: if there are still only 2 Intent Owners (as many as the original product managers), each with 20 working days a month and 2 person-days per requirement, then no matter how strong AI gets, at most 20 requirements a month can be accepted.</p>
<h3 id="7-assumptions-and-risks">7. Assumptions and Risks</h3>
<p>The estimate rests on a few preconditions:</p>
<ul>
<li><strong>The product metadata is complete enough</strong>: the more complete the rules, the more consistent AI&rsquo;s output and the larger s; with missing rules, AI keeps repeating the same mistakes and s drops to the conservative level or below</li>
<li><strong>Module boundaries are clear</strong>: when modules are tightly coupled, coordination costs between Module Owners come back</li>
<li><strong>Intent Owners can write checkable acceptance criteria</strong>: vague requirements multiply the rounds of feedback and fixes</li>
<li><strong>You accept a ramp-up period</strong>: writing rules, learning to direct AI and filling in full-stack skills all take time, and efficiency may drop rather than rise early in the transition</li>
</ul>
<p>Finally, verify the multiplier with your own data: on the pilot module, record lead time, person-days per requirement, first-pass acceptance rate and rework, and compare them with the numbers before the transition instead of going by gut feeling. METR&rsquo;s research is a reminder that developers&rsquo; own sense of how much AI speeds them up is often unreliable.</p>
<h2 id="part-10-what-kind-of-people-the-new-organization-needs">Part 10: What Kind of People the New Organization Needs</h2>
<p>The estimate in the previous part leads to one conclusion: the stronger AI gets, the more the efficiency bottleneck concentrates on human judgment. So in the new organization, the most valuable thing is no longer &ldquo;mastering a particular framework&rdquo;, but judgment, breadth and communication. Specifically, the new organization needs more of the following kinds of people:</p>
<p><img alt="Who an AI-native team needs" loading="lazy" src="/blog/2026/ai-native-rd-organization/8-talent-profile.png"></p>
<table>
	<thead>
			<tr>
					<th>Who is needed more</th>
					<th>Why</th>
					<th>Roles where they shine</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Senior people who know the business</td>
					<td>AI does not know your business; whether something was &ldquo;built right&rdquo; can only be judged with business experience</td>
					<td>Intent Owner, Product Architect</td>
			</tr>
			<tr>
					<td>People with strong all-round ability</td>
					<td>One person owns a module end to end, from understanding requirements and making technical decisions to quality and release</td>
					<td>Module Owner</td>
			</tr>
			<tr>
					<td>People with broad technical range</td>
					<td>They must understand every layer, judge whether AI&rsquo;s approach is sound, and trace problems all the way down</td>
					<td>Module Owner, Product Architect</td>
			</tr>
			<tr>
					<td>People who communicate clearly</td>
					<td>Instructions to AI, requirements and feedback to people, and rules written into the metadata are all, at heart, communication</td>
					<td>Every role, especially Intent Owner</td>
			</tr>
	</tbody>
</table>
<h3 id="1-senior-people-who-know-the-business">1. Senior People Who Know the Business</h3>
<p>AI can write almost any code, but it does not know why your customers always pile up refund requests at the end of the month, or that a certain rule exists because of a serious incident in the past. That business knowledge is exactly what confirming requirements, accepting results and setting rules need most.</p>
<p>&ldquo;Senior&rdquo; here means truly understanding the business, not years of service. Senior people who know the business make excellent Intent Owners, whether they used to work in product, development or QA; those with the deepest understanding of the product as a whole can become Product Architects and write their experience into the product metadata, so AI and the whole team can use it.</p>
<h3 id="2-people-with-strong-all-round-ability">2. People with Strong All-Round Ability</h3>
<p>A Module Owner is no longer someone who just &ldquo;writes their own layer well&rdquo;, but someone accountable for the outcome of a whole module: confirming intent with the Intent Owner, breaking down tasks, directing multiple AI agents, reviewing designs, controlling quality and handling production issues. That takes all-round ability: understanding requirements, making technical decisions, organizing work and owning results. People who are only good at one step and used to waiting for others to hand work over will struggle in the new organization.</p>
<h3 id="3-people-with-broad-technical-range">3. People with Broad Technical Range</h3>
<p>Full-stack developers live on technical breadth. Frontend, backend, databases, testing, deployment, monitoring: you need to understand every layer to judge whether AI&rsquo;s approach is sound, and to trace a problem all the way down when it breaks. Technical depth is still valuable, but in the new organization depth mostly settles into rules and skills that every person and every AI shares; breadth determines how large a module one person can own independently.</p>
<h3 id="4-people-who-communicate-clearly">4. People Who Communicate Clearly</h3>
<p>In the AI era, communication is productivity. The instructions a Module Owner gives to AI, the requirements, acceptance criteria and feedback an Intent Owner writes, and the rules a Product Architect writes into the product metadata are all, at heart, communication: the clearer they are, the more precisely AI executes and the less rework there is.</p>
<p>At the same time, the new organization removes the layers of handoffs, so collaboration between people becomes direct conversation. How quickly Intent Owners and Module Owners can align on intent, and whether the Product Architect can explain the rules so that everyone understands them, directly determines how fast the flywheel turns.</p>
<h3 id="5-junior-roles-stay-what-matters-more-is-the-ability-to-learn-and-grow">5. Junior Roles Stay; What Matters More Is the Ability to Learn and Grow</h3>
<p>None of this means the new organization has no place for junior staff. A team that only hires senior people will, a few years later, have nobody growing into the next generation of senior people. What changes is what we ask of people: knowing a particular framework matters less; <strong>what matters more is the ability to learn and grow</strong>. That applies to everyone, for three reasons:</p>
<ol>
<li><strong>AI and tools change too fast</strong>: today&rsquo;s best practice may be obsolete in a few months, so senior people must keep learning too; and the advantage of junior people is precisely that they learn fast and carry less baggage.</li>
<li><strong>The new organization offers better conditions for growth</strong>: the product metadata turns the team&rsquo;s experience into rules, so newcomers can quickly understand the product&rsquo;s standards by reading them; and AI is a mentor at their side that can explain any unfamiliar technology or compare approaches at any time.</li>
<li><strong>The growth path is clearer</strong>: a junior can start as the backup owner for a senior Module Owner, beginning with reviews, self-testing and adding rules, then gradually take full ownership of a small module; or start as the Intent Owner of a small business area and build up business experience through acceptance work.</li>
</ol>
<p>One thing to watch for: juniors can easily turn into people who &ldquo;only know how to make AI do the work, without understanding it themselves&rdquo;. So measure a junior&rsquo;s growth not by how much code they produced, but by whether they can explain why AI did what it did, whether it is right, and whether there is a better approach. Only when they can explain it have they truly learned it.</p>
<p>The same shift applies to hiring and training: ask less about &ldquo;do you know framework X&rdquo; and look more at business understanding, technical breadth, communication and learning speed. In an interview, for example, give the candidate an unfamiliar business scenario and see whether they can quickly ask the key questions, explain their approach clearly, and direct AI to build a working prototype.</p>
<h2 id="part-11-common-objections">Part 11: Common Objections</h2>
<h3 id="1-can-one-person-really-be-full-stack">1. Can One Person Really Be &ldquo;Full-Stack&rdquo;?</h3>
<p>They don&rsquo;t need to be an expert in every layer. With AI&rsquo;s help, an experienced engineer can fill in the other side&rsquo;s skills far more easily than before. Where real depth is needed, such as database performance or complex interaction animations, experts can write their experience into rules and skills that every owner&rsquo;s AI can use, instead of stepping in personally on every requirement.</p>
<h3 id="2-without-a-qa-team-who-guarantees-quality">2. Without a QA Team, Who Guarantees Quality?</h3>
<p>Quality should never have depended only on a final gate. The new organization splits quality into three layers: test entry rules define the standard, AI and CI enforce it automatically, and human testing makes the final judgment. The QA team&rsquo;s expertise is not thrown away; it is written into the rules and applied to every single change, not just when a build is handed to QA.</p>
<h3 id="3-without-ui-designers-will-the-product-get-ugly">3. Without UI Designers, Will the Product Get Ugly?</h3>
<p>No; if anything, it may become more consistent. In traditional teams, visual inconsistency often comes from all the manual translation between design mockups and implementation. In the new organization, visual design and experience are first-class product metadata: design tokens and the component library are defined once and apply everywhere, and every interface AI generates follows the same standard. Design talent is concentrated on setting the standard instead of producing mockups one screen at a time.</p>
<h3 id="4-will-the-product-architect-become-the-new-bottleneck">4. Will the Product Architect Become the New Bottleneck?</h3>
<p>The product metadata changes far less often than requirements, and most of the time the Product Architect is reviewing rule changes proposed by others rather than doing everything personally. Anyone can propose a change; the Product Architect keeps the whole consistent. As a product grows, two or three Product Architects can split the work by domain, but there should never be an &ldquo;architecture department&rdquo; again.</p>
<h2 id="part-12-how-to-start-the-transition">Part 12: How to Start the Transition</h2>
<p>You don&rsquo;t need to reorganize the whole department at once. Proceed in this order:</p>
<ol>
<li><strong>Write the product metadata first</strong>: gather the rules scattered across wikis, documents and people&rsquo;s heads, and put them into the repository as files. Start with the tech stack, CI rules, test entry rules and acceptance rules, which pay off fastest.</li>
<li><strong>Pilot with one module</strong>: pick a module with clear boundaries, assign one Module Owner and one Intent Owner, run the flywheel for 2–4 weeks, record lead time, person-days per requirement and rework, and compare them with the numbers before the transition using the method in Part 9.</li>
<li><strong>Change how performance is measured</strong>: stop measuring by function (how much code was written, how many test cases were run) and measure modules by delivery results and acceptance quality; judge the Product Architect by the quality of the rules and the consistency of AI&rsquo;s output.</li>
<li><strong>Change hiring and training</strong>: hire and develop people by the criteria in Part 10, and give juniors a growth path from backup owner to full owner.</li>
<li><strong>Dissolve the functional teams step by step</strong>: once the pilot works, regroup by module and gradually dissolve the old functional teams.</li>
<li><strong>Review the rules every week</strong>: set a fixed time to go over the week&rsquo;s feedback and turn every problem that can be captured into a rule.</li>
</ol>
<h2 id="conclusion">Conclusion</h2>
<p>The functional split was designed for an era when execution capacity was scarce. Today, execution is becoming a utility, available on tap like water and electricity, and what is truly scarce is rules, direction and judgment. Organizations should be rebuilt around those three things:</p>
<ul>
<li><strong>Product Architects</strong> set the rules, so that AI and people alike know what the product should be;</li>
<li><strong>Module Owners</strong> build their modules end to end with AI and keep improving the rules;</li>
<li><strong>Intent Owners</strong> provide the intent and accept the results in person, keeping the product pointed at what users really need.</li>
</ul>
<p>By the estimate in Part 9, under the neutral assumptions such an organization cuts lead time to about a third and raises output per person to about 3x; the stronger AI gets, the higher the multiplier, with the ceiling set by how efficient the human judgment steps are.</p>
<p>And what really makes this organization turn are people who know the business, have strong all-round ability and broad technical range, communicate clearly, and keep learning and growing.</p>
<p>The tools have changed. It&rsquo;s time for organizations to change too.</p>
<h2 id="references">References</h2>
<ul>
<li>Melvin E. Conway, <a href="https://www.melconway.com/Home/Committees_Paper.html">How Do Committees Invent?</a>, Datamation, April 1968</li>
<li>Martin Fowler, <a href="https://martinfowler.com/bliki/ConwaysLaw.html">Conway&rsquo;s Law</a></li>
<li>Thoughtworks Technology Radar, <a href="https://www.thoughtworks.com/radar/techniques/inverse-conway-maneuver">Inverse Conway Maneuver</a></li>
<li>Wikipedia, <a href="https://en.wikipedia.org/wiki/Amdahl%27s_law">Amdahl&rsquo;s law</a></li>
<li><a href="https://agents.md/">AGENTS.md</a></li>
<li>GitHub Docs, <a href="https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions">Adding repository custom instructions for GitHub Copilot</a></li>
<li>VS Code Docs, <a href="https://code.visualstudio.com/docs/agent-customization/agent-skills">Use Agent Skills in VS Code</a></li>
<li>Design Tokens Community Group, <a href="https://www.designtokens.org/tr/drafts/format/">Design Tokens Format Module</a></li>
<li><a href="https://scrumguides.org/scrum-guide.html">The Scrum Guide</a></li>
<li>web.dev, <a href="https://web.dev/articles/lcp">Largest Contentful Paint (LCP)</a></li>
<li>Sida Peng et al., <a href="https://arxiv.org/abs/2302.06590">The Impact of AI on Developer Productivity: Evidence from GitHub Copilot</a>, 2023</li>
<li>METR, <a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity</a>, 2025</li>
<li>METR, <a href="https://metr.org/blog/2026-02-24-uplift-update/">We are Changing our Developer Productivity Experiment Design</a>, 2026</li>
<li>DORA, <a href="https://dora.dev/research/2024/dora-report/">Accelerate State of DevOps Report 2024</a></li>
<li>DORA, <a href="https://dora.dev/research/2025/dora-report/">State of AI-assisted Software Development 2025</a></li>
</ul>
]]></content:encoded></item></channel></rss>