AI Engineer · Published 2026-09-27

No, That's Not a Software Factory — Ryan Cooke, WorkOS

privateReview: unreviewedConfidence: high
Software FactoryMCPagentsinfrastructureculturecontextcontext-engineeringagentic-workflowssoftware-factorymemory-architectureSandboxingoutcome-metricsmulti-agent
Open on YouTube ↗

Summary

Overview

  • Speaker: Ryan Cooke
  • Channel: AI Engineer
  • Main topic: Building autonomous AI software engineering factories and moving beyond basic output metrics
  • Purpose: To critique the industry-standard 'software factory' model based purely on code output and present WorkOS's approach to encoding product engineering culture and institutional knowledge into autonomous agent systems. Ryan Cooke from WorkOS argues that typical AI software factories focusing solely on sandbox, model, and repo setups with output metrics like PR counts and lines of code fail to deliver true organizational leverage. Instead, engineering teams must encode their actual culture, product engineering processes (such as Hilltop documents, dependency chains, and review loops), and institutional knowledge into executable agent workflows using Model Context Protocol (MCP) gateways and contextual engines.

Topic Map

The Standard Playbook vs. Output vs. Outcomes

  • Explanation: Examining industry standards where companies set up sandboxes, models, repos, and PR generation, and why measuring output metrics (PRs/week, lines of code, PR velocity) obscures true value compared to outcome metrics.
  • Key claims:
    • Most industry benchmarks focus on output metrics like lines of code or PR count.
    • Output metrics can disguise whether AI systems are actually driving business outcomes.
    • More code and faster generation is not the same as more value and faster delivery.
  • Examples:
    • Ramp (>50% merged PRs from AI)
    • Spotify (1,500+ AI-generated PRs merged)
    • Stripe (1K+ merged PRs per week)
  • Terminology:
    • output metrics
    • outcome metrics
    • sandbox
    • model router
    • pull request
  • Why it matters: Optimizing for output metrics leads organizations to measure the wrong variable while failing to accelerate feature delivery time or engineer leverage.

What WorkOS Built: TARS and Horizon

  • Explanation: Introducing TARS (the product interface interacting via Slack, Linear, GitHub, and web UI) and Horizon (infrastructure orchestration running warm-pooled sandboxes and event loops).
  • Key claims:
    • Infrastructure is only half the story; agents must participate in the actual engineering process.
    • TARS handles user interactions, operational instructions, and open PRs.
    • Horizon orchestrates webhooks, sandboxes, and event loops between Linear and repo.
  • Examples:
    • TARS integration with Slack, Linear, and GitHub
    • Horizon cloudflare workers and warm-pooled sandboxes
  • Terminology:
    • TARS
    • Horizon
    • MCP gateway
    • warm-pooled sandboxes
    • event loop
  • Why it matters: Demonstrates how combining product engineering processes with robust infrastructure enables agents to handle end-to-end tasks autonomously.

The Blueprint and The PM Agent

  • Explanation: Encoding WorkOS's product engineering culture—featuring Hilltop documents, small teams, dependency chains, and review-first loops—into the PM agent lifecycle.
  • Key claims:
    • Hilltop documents capture narrative specifications before writing code.
    • The PM agent reads Hilltop documents, divides projects into issues, handles human reviews, and creates implementation tickets.
    • Autonomous agents can execute work through every stage of the lifecycle without constant human shepherding.
  • Examples:
    • Vault internal API project initiated via Slack command and executed by TARS
    • Hilltop document review milestones
  • Terminology:
    • Hilltop documents
    • dependency chains
    • review-first loop
    • PM agent
    • units of work
  • Why it matters: Encodes institutional culture and planning processes into executable agent workflows, solving the cold start problem for AI development.

The Context Engine and Memory Layers

  • Explanation: Using a custom MCP gateway called the Context Engine to connect internal data lakes like Snowflake with semantic tables and tool descriptions, providing evergreen context across per-user, per-team, and company-wide memory layers.
  • Key claims:
    • The MCP server is not data plumbing; it is culture encoding.
    • Snowflake semantic tables describe product utilization and customer conversations for agent queries.
    • Memory layers compound learnings across the organization, scoped by identity rather than harness.
  • Examples:
    • Snowflake semantic tables for product utilization and customer conversation analysis
    • Slack-based direct querying of internal data through MCP
  • Terminology:
    • MCP gateway
    • Context Engine
    • semantic tables
    • memory layer
    • paved paths
  • Why it matters: Provides agents with deep contextual awareness of how tools are used and how the company operates, multiplying their effectiveness across internal tools.

Key Points

Measure outcomes, not just output

  • Explanation: Focusing on lines of code or PR counts obscures whether software factories are improving feature delivery time, defect rate, or engineer leverage.
  • Evidence: Industry metrics from Ramp, Spotify, and Stripe show high production rates, but production rate does not equal value delivered.
  • Practical implication: Engineering leaders should invest in systems that accelerate actual feature delivery and system compounding over time.

Infrastructure plus engineering culture

  • Explanation: Sandboxes, models, and repos are necessary but incomplete conditions for a software factory.
  • Evidence: Building on Cloudflare and open-source models without cultural process integration resulted in indistinguishable developer output.
  • Practical implication: Teams must encode their specific planning rituals, such as Hilltop docs and review loops, into agent workflows.

The Context Engine as cultural encoding

  • Explanation: An internal MCP gateway provides tool descriptions, guidelines, and semantic database queries that orient coding agents.
  • Evidence: Connecting Snowflake semantic tables and Slack query capabilities allowed agents and developers to query customer data directly.
  • Practical implication: Investing in an internal MCP gateway yields incredible leverage across multiple internal tools and developer workflows.

Frameworks, Models & Processes

The Software Factory Blueprint

  • How it works: Combines sandbox infrastructure with encoded product engineering rituals and contextual engines to automate end-to-end feature delivery.
  • Components:
    • Hilltop Documents
    • Small Teams
    • Dependency Chains
    • Review-First Loop
    • MCP Context Engine
  • When to use: When scaling autonomous software engineering agents within an engineering organization.

Examples & Case Studies

A WorkOS engineer kicked off a Vault internal API project in Slack with a simple multi-sentence description.

  • Illustrates: How TARS and the PM agent automatically generate Linear projects, Hilltop document drafts, decision logs, and open questions without manual setup.
  • Lesson: Agents can eliminate the blank page problem by initializing complete project structures from brief descriptions.

Actionable Takeaways

  • Immediate:
    • Audit your software factory metrics to ensure you are measuring outcome over output.
    • Build or adopt an internal MCP gateway to provide standardized tool shapes and context to coding agents.
  • Strategic:
    • Encode institutional knowledge and planning processes (like PRDs and review loops) into executable agent workflows.
    • Move from rented sandbox infrastructure to owning your session and memory infrastructure layers.
  • Questions to investigate:
    • How do you handle authorization and security governance when autonomous agents have broad system access?
    • How do you prevent agents from overestimating project scope and generating excessive unnecessary code?

Claims Worth Verifying

  • Ramp has greater than 50% of merged PRs generated from AI. (Statistic)
  • Spotify has merged over 1,500 AI-generated PRs. (Statistic)

Notable Quotes

"No, that's Not a Software Factory" (at 0:22) "More code, faster, is not the same as more value, faster." (at 3:30) "The unlock isn't infrastructure. It's institutional knowledge, made executable." (at 30:01)

Compressed Summary

  • Standard software factories focus on output metrics rather than true business outcomes.
  • WorkOS built TARS (product interface) and Horizon (infrastructure orchestration) to automate product engineering.
  • Hilltop documents and dependency chains encode human engineering culture into agent workflows.
  • An internal MCP gateway called the Context Engine connects data lakes like Snowflake to provide evergreen context.
  • Keywords: software factory, mcp, agents, infrastructure, culture, context
  • Core insight: True software factories require encoding institutional knowledge and product engineering culture into autonomous agent workflows rather than just scaling code output metrics.

Core insights

6
Architecturehigh noveltymoderate evidence

An internal MCP gateway is framed as culture-encoding infrastructure rather than data plumbing: the gateway supplies tool descriptions, guidelines, and semantic database queries that orient coding agents toward how the company actually operates.

Why it matters

If tool shape and guidance are the real payload of an MCP layer, then the design question shifts from 'what data can agents reach' to 'what behavioral norms and paved paths does the gateway enforce' — a different abstraction boundary than a generic tool registry.

Generalization

Any org deploying coding agents can treat its internal tool gateway as the primary surface for encoding review norms, naming conventions, and approved workflows, making culture an executable artifact instead of documentation.

The MCP server is not data plumbing; it is culture encoding.
Open source video
An internal MCP gateway provides tool descriptions, guidelines, and semantic database queries that orient coding agents.
Open source video
Tradeoffmedium noveltymoderate evidence

Output metrics (PR counts, lines of code, PR velocity) can mask whether an agentic system changes feature delivery time or engineer leverage; no outcome data is presented even alongside high-production figures.

Why it matters

Teams optimizing PR volume may ship a measurement system that rewards generation over delivery, making the factory look successful while the actual constraint (time-to-feature, defect rate) is untouched.

Generalization

For any agent-driven pipeline, the instrumentation should be chosen before the autonomy is scaled, otherwise the metric becomes the target and masks regressions in the outcomes it was meant to proxy.

Most industry benchmarks focus on output metrics like lines of code or PR count.
Open source video
More code and faster generation is not the same as more value and faster delivery.
Open source video
Output metrics can disguise whether AI systems are actually driving business outcomes.
Open source video
Architecturehigh noveltymoderate evidence

Memory layers are scoped by identity (per-user, per-team, company-wide) rather than by agent harness, so learnings compound across whoever is asking rather than accumulating inside a specific tool.

Why it matters

Scoping memory to identity rather than to the harness lets multiple agents and human developers share learned context, avoiding silos where each agent instance or tool rediscovers the same organizational knowledge.

Generalization

Context engines that key on the acting identity rather than the invoking runtime allow knowledge reuse across heterogeneous agents, surfaces (Slack, web, IDE), and human users.

Memory layers compound learnings across the organization, scoped by identity rather than harness.
Open source video
providing evergreen context across per-user, per-team, and company-wide memory layers
Open source video
Architecturemedium noveltymoderate evidence

The system is split into a product-surface agent (TARS: Slack, Linear, GitHub, web UI interactions and open PRs) and a separate infrastructure layer (Horizon: webhooks, warm-pooled sandboxes, event loops between Linear and repo).

Why it matters

Separating 'agent participates in the engineering process' from 'runtime orchestration of sandboxes and events' isolates the stateful orchestration concerns (queueing, pooling, webhook handling) from the process-participation concerns, letting each evolve independently.

Generalization

Agent platforms tend to need two distinct planes: a process-participation plane (how work enters and exits the human workflow) and a runtime plane (sandbox lifecycle, event routing, concurrency), which should not be collapsed into one service.

TARS handles user interactions, operational instructions, and open PRs.
Open source video
Horizon orchestrates webhooks, sandboxes, and event loops between Linear and repo.
Open source video
Infrastructure is only half the story; agents must participate in the actual engineering process.
Open source video
Mechanismmedium noveltymoderate evidence

The PM agent encodes a narrative-first planning ritual: it consumes Hilltop documents, decomposes projects into issues with dependency chains, runs human review milestones, and emits implementation tickets, letting a brief Slack description bootstrap a full project skeleton.

Why it matters

This moves the agent's first job from code generation to project initialization, which is where most of an organization's implicit process lives; encoding that ritual is what makes the rest of the pipeline deterministic.

Generalization

Where an org has a stable planning artifact (spec doc, RFC, design review), an agent that reproduces the artifact-to-ticket decomposition captures far more institutional knowledge per unit of integration work than an agent that only writes code.

Hilltop documents capture narrative specifications before writing code.
Open source video
The PM agent reads Hilltop documents, divides projects into issues, handles human reviews, and creates implementation tickets.
Open source video
Agents can eliminate the blank page problem by initializing complete project structures from brief descriptions.
Open source video
Empirical Resulthigh noveltyweak evidence

Sandboxes, model routing, and repos alone produced developer output indistinguishable from prior practice; cultural process integration was the differentiator claimed.

Why it matters

This implies the marginal return on agent capability investments may be far lower than the marginal return on encoding the org's actual review and planning rituals into workflows — a resource-allocation claim rather than a capability claim.

Generalization

For teams evaluating agent platforms, the discriminating variable may be process fidelity (does the agent follow our actual rituals) rather than model or sandbox quality.

Building on Cloudflare and open-source models without cultural process integration resulted in indistinguishable developer output.
Open source video
Sandboxes, models, and repos are necessary but incomplete conditions for a software factory.
Open source video

Deep dives

5

Outcome metrics for agentic software pipelines

Research question

Which delivery outcomes (time-to-feature, defect escape rate, engineer leverage) can replace PR count and lines of code as primary metrics for agentic engineering pipelines?

Why

Without outcome instrumentation, scaling agent autonomy can optimize generated volume while hiding regressions in delivery time, quality, and engineer leverage.

Most industry benchmarks focus on output metrics like lines of code or PR count.
Open source video
More code and faster generation is not the same as more value and faster delivery.
Open source video
Output metrics can disguise whether AI systems are actually driving business outcomes.
Open source video
Source video

Identity-scoped memory conflict resolution

Research question

How should context engines reconcile conflicting per-user, per-team, and company-wide memories, and what precedence rules maximize agent task success?

Why

Identity-keyed memory avoids harness silos, but without explicit precedence it can serve contradictory guidance across agents, surfaces, and human users.

Memory layers compound learnings across the organization, scoped by identity rather than harness.
Open source video
providing evergreen context across per-user, per-team, and company-wide memory layers
Open source video
Source video

Culture-as-executable-workflow brittleness

Research question

What is the maintenance cost and process-change coupling of encoding engineering rituals (review norms, Hilltop docs, dependency chains) into MCP gateway guidance and PM agent workflows?

Why

If encoded culture becomes stale, agents will enforce outdated rituals and require re-encoding, potentially eroding the leverage that culture encoding was meant to create.

The MCP server is not data plumbing; it is culture encoding.
Open source video
Hilltop documents capture narrative specifications before writing code.
Open source video
The PM agent reads Hilltop documents, divides projects into issues, handles human reviews, and creates implementation tickets.
Open source video
Source video

PM agent generalization beyond narrative specs

Research question

Can a PM agent that decomposes narrative specs into issues, dependency chains, and tickets generalize to teams using RFCs, ADRs, or ticket-only planning?

Why

WorkOS's blueprint depends on Hilltop documents; transferability determines whether the pattern is a general agent architecture or a bespoke artifact tied to one planning culture.

Agents can eliminate the blank page problem by initializing complete project structures from brief descriptions.
Open source video
The PM agent reads Hilltop documents, divides projects into issues, handles human reviews, and creates implementation tickets.
Open source video
Source video

Two-plane agent platform architecture

Research question

What coordination failure modes and cost tradeoffs arise when separating a product-participation agent surface (TARS) from runtime orchestration (Horizon)?

Why

Collapsing these planes can couple interaction changes to sandbox lifecycle and event routing, while separating them introduces a boundary that must be managed for latency, cost, and reliability.

Infrastructure is only half the story; agents must participate in the actual engineering process.
Open source video
Horizon orchestrates webhooks, sandboxes, and event loops between Linear and repo.
Open source video
Source video

Article ideas

4

Your AI Software Factory Is Measuring the Wrong Variable

PR counts, lines of code, and PR velocity are output metrics that can mask whether agentic engineering improves time-to-feature, defect escape rate, or engineer leverage; teams should instrument delivery outcomes before scaling autonomy.

Angle

Metrics critique with a concrete instrumentation proposal for agent-authored changes.

Source video

MCP Is Not a Tool Bus—It's Your Engineering Culture as Code

An internal MCP gateway's real payload is not data access but encoded review norms, guidelines, and semantic workflows; treating it as plumbing forfeits the main leverage of agent adoption.

Angle

Architecture essay reframing MCP gateway design as culture encoding rather than tool registry design.

Source video

Identity-Scoped Memory Makes Agents Interchangeable—If You Solve Conflicts

Scoping memory to identity rather than agent harness prevents rediscovery across tools and surfaces, but the durable asset only compounds if per-user, per-team, and company-wide context conflicts have explicit precedence rules.

Angle

Architecture analysis with conflict-resolution design questions for shared context services.

Source video

The First Agent Job Isn't Code—It's Killing the Blank Page

PM agents that consume narrative specs like Hilltop documents and emit issues, dependency chains, and tickets capture more institutional knowledge than code-generation agents; the gating factor becomes spec quality and artifact generality.

Angle

Workflow analysis of agentic project initialization and its dependence on planning artifacts.

Source video

Project ideas

4

Outcome Meter for Agentic PRs

beyond-evals

Replacing PR-count dashboards with time-to-feature and defect-escape metrics for agent-authored changes will reveal weak or negative delivery impact that PR volume hides.

Proof of concept

Instrument agent PRs by linking them to originating tickets; compute time from ticket creation to merge/deploy, revert/defect rate, and review rework versus a matched human-authored baseline.

Measurement

Delta time-to-feature, defect escape rate, and review rework for agent vs human PRs; correlation between PR volume and delivery outcomes.

Source video

Gateway-Encoded Culture Testbed

gatehouse

Encoding review norms, naming conventions, and approved workflows in an MCP gateway's tool descriptions and semantic queries increases agent PR acceptance without rewrite compared to bare repo access.

Proof of concept

Build a minimal internal MCP gateway for one repository exposing guidelines, tool descriptions, and semantic DB queries; run identical agent tasks with and without gateway guidance.

Measurement

PR acceptance without rewrite, reviewer comments per PR, rework cycles, and task completion rate.

Source video

Identity-Scoped Memory Precedence Engine

new

Memory keyed to acting identity with explicit precedence across user/team/company scopes reduces redundant discovery and context conflicts versus harness-scoped memory.

Proof of concept

Implement a context service with three memory scopes and a conflict-resolution policy; run multi-agent tasks across Slack, IDE, and CLI surfaces.

Measurement

Redundant file/tool reads, task success rate, conflict incidents, staleness rate, and cross-surface context reuse.

Source video

PM Agent on RFC/ADR Planning

movement-lab

A PM agent that decomposes narrative specs into issues and tickets can generalize to RFC/ADR/ticket-only planning, but generated project structures will require more human rewrite than on Hilltop-style docs.

Proof of concept

Replicate the PM-agent pattern on teams using RFCs, ADRs, or ticket-only planning; compare cold-start project structure acceptance and dependency-chain accuracy against Hilltop-style inputs.

Measurement

Percentage of generated tickets accepted, dependency chain accuracy, human rewrite rate, and time saved in project initialization.

Source video

Architectural implications

3

Memory and context ownership is being moved out of individual agent harnesses into a shared, identity-keyed context service.

Before

Memory and context live inside each agent harness or tool integration, scoped to that runtime.

After

Memory is served by an internal MCP gateway/context engine and scoped per-user, per-team, and company-wide.

Consequence

Agents become interchangeable consumers of context; the durable asset is the context service, and agent harnesses become more commoditized.

Source video

Project initialization is delegated to an agent that operates on a narrative specification artifact before any code is written.

Before

A human turns a brief into a spec, issues, tickets, and dependency chains.

After

The PM agent generates Linear projects, Hilltop document drafts, decision logs, open questions, and tickets from a brief Slack description.

Consequence

The spec document becomes an executable input rather than a human-only artifact, making spec quality the gating factor for downstream agent work.

Source video

Runtime orchestration (warm-pooled sandboxes, webhook handling, event loops) is separated from the product-facing agent surface.

Before

A single agent service handles both user interaction and execution infrastructure.

After

A product interface (TARS) and a separate orchestration layer (Horizon) with pooled sandboxes and event loops.

Consequence

Sandbox lifecycle, concurrency, and cost can be tuned as infrastructure concerns without touching the interaction surface, but introduces a coordination boundary between the two planes.

Source video

Tradeoffs and failure modes

4

Output-metric optimization

Benefit

Easy to instrument and benchmark across organizations (PR counts, lines of code, PR velocity).

Cost or risk

Optimizing production volume can obscure whether feature delivery time, defect rate, or engineer leverage improved at all.

Output metrics can disguise whether AI systems are actually driving business outcomes.
Open source video
Source video

Review-first loop as autonomy boundary

Benefit

Human review milestones keep the agent aligned with organizational standards and preserve accountability.

Cost or risk

Human review gates reinsert a human latency and attention dependency into a pipeline otherwise marketed as autonomous, limiting end-to-end autonomy.

The PM agent reads Hilltop documents, divides projects into issues, handles human reviews, and creates implementation tickets.
Open source video
Source video

Custom internal MCP gateway investment

Benefit

Standardized tool shapes and contextual querying yield leverage across multiple internal tools and developer workflows.

Cost or risk

A bespoke gateway couples every agent to one organization's internal semantics and requires ongoing maintenance of tool descriptions and semantic tables.

Investing in an internal MCP gateway yields incredible leverage across multiple internal tools and developer workflows.
Open source video
Source video

Warm-pooled sandboxes

Benefit

Pre-provisioned sandboxes reduce the latency of starting agent work on repository tasks.

Cost or risk

Maintaining a warm pool implies idle compute cost and management of a pool lifecycle alongside the event-driven orchestration.

Horizon cloudflare workers and warm-pooled sandboxes
Open source video
Source video

Open questions

5

What outcome metrics actually substitute for PR count and lines of code when evaluating an agentic software pipeline?

Why unresolved

The summary asserts outcomes matter but provides only output-style examples (Ramp >50% merged PRs from AI, Spotify 1,500+ AI-generated PRs merged, Stripe 1K+ merged PRs per week) and no outcome data.

Research direction

Define and instrument time-to-feature, defect/escape rate, and engineer-leverage measures that are attributable to agent contributions, then compare against output metrics on the same pipeline.

Source video

How is identity-scoped memory implemented in practice, and how are conflicting per-user, per-team, and company-wide contexts reconciled?

Why unresolved

The summary states memory is scoped by identity rather than harness but gives no resolution mechanism or precedence rule.

Research direction

Prototype precedence and conflict-resolution policies across the three memory scopes and measure retrieval accuracy and staleness in agent tasks.

Source video

How much of an organization's engineering culture can be encoded as executable workflow before it becomes brittle to process change?

Why unresolved

The summary lists encoded rituals (Hilltop docs, small teams, dependency chains, review-first loop) but does not address maintenance or drift.

Research direction

Track how often encoded workflows require revisions as processes evolve, and measure the cost of re-encoding versus the leverage gained.

Source video

Does encoding one org's narrative-first planning rituals generalize to teams without an equivalent spec artifact?

Why unresolved

The blueprint depends on Hilltop documents, a possibly WorkOS-specific artifact; the summary offers no evidence of transfer to other planning cultures.

Research direction

Replicate the PM-agent pattern on teams using RFCs, ADRs, or ticket-only planning and compare cold-start quality of generated project structures.

Source video

What is the reliability of a long-running agent lifecycle that spans spec, ticketing, implementation, review, and merge without constant human shepherding?

Why unresolved

The summary claims agents can execute through every stage autonomously but provides only one anecdote (the Vault internal API project).

Research direction

Run repeated end-to-end lifecycle trials and measure failure, abandonment, and human-intervention rates by stage.

Source video

Key claims

7
causalVerification needed

Output metrics like PR count and lines of code hide whether AI systems improve business outcomes.

Evidence

Output metrics can disguise whether AI systems are actually driving business outcomes.

Question

In pipelines with high AI PR volume, do feature delivery time and defect rate improve relative to matched non-AI baselines?

Source video
comparativeVerification needed

Sandboxes, model routing, and repos without cultural process integration yield developer output indistinguishable from prior practice.

Evidence

Building on Cloudflare and open-source models without cultural process integration resulted in indistinguishable developer output.

Question

What measurement was used to determine indifference, and does it hold across teams or only for the initial rollout?

Source video
opinionVerification not requested

The MCP server functions as culture encoding rather than data plumbing.

Evidence

The MCP server is not data plumbing; it is culture encoding.

Source video
causalVerification needed

Memory layers scoped by identity rather than harness compound learnings across the organization.

Evidence

Memory layers compound learnings across the organization, scoped by identity rather than harness.

Question

Does identity-scoped memory measurably increase task success or reduce redundant discovery versus harness-scoped memory?

Source video
factualVerification needed

The PM agent can take a brief description and emit a complete project structure without manual setup.

Evidence

Agents can eliminate the blank page problem by initializing complete project structures from brief descriptions.

Question

How often are the generated Hilltop drafts, decision logs, and open questions accepted versus rewritten by engineers?

Source video
causalVerification needed

TARS and Horizon together let agents handle end-to-end tasks autonomously by pairing infrastructure with product engineering process.

Evidence

Demonstrates how combining product engineering processes with robust infrastructure enables agents to handle end-to-end tasks autonomously.

Question

What fraction of tasks completed without human intervention across the full lifecycle, and at what volume?

Source video
factualVerification needed

Industry scale figures indicate high AI-generated PR production across major companies.

Evidence

Ramp (>50% merged PRs from AI)

Question

What percentage of AI-generated PRs pass review unmodified, and how do they compare in defect or revert rate to human-authored PRs?

Source video

Connections

4