Self-Driving Codebase: When 35% of PRs are Created by Agents [2026]

The paradigm of software development is undergoing its most profound transformation since the birth of high-level languages in the 1950s. While in 2024 we were still marveling at AI's ability to write a correct sorting algorithm, by 2026, the industry's focus has shifted from "AI-assisted programming" to the "Self-Driving Codebase."

According to data disclosed by top AI IDE vendors like Cursor and TRAE, in the first quarter of 2026, over 35% of merged Pull Requests (PRs) among their core user base were not manually written by human developers. Instead, they were completed independently by autonomous AI Agents running in cloud-based isolated virtual machines. This marks a new phase in software engineering: developers are no longer the sole authors of code, but are gradually transforming into "Agent Shepherds," responsible for orchestrating, guiding, and auditing intelligent code production lines that run 24/7 in the background.

Key Takeaways

• Paradigm Shift: From "Tab Autocomplete" (Era 1) to "Synchronous Dialogue" (Era 2), and now to "Asynchronous Autonomous Agents" (Era 3).
• Data-Backed: Cursor CEO Michael Truell revealed that 35% of their team's PRs are created by agents, with the number of agent users reaching twice that of Tab users.
• Architectural Foundation: Cloud-isolated VMs provide complete execution environments (browsers, terminals, testers), enabling the shift from "outputting Diffs" to "outputting Artifacts."
• Self-Driving Vision: Codebases can autonomously identify issues, fix bugs, update dependencies, and refactor legacy code, with humans only intervening at key decision points.
• Role Redefinition: Developer time allocation has shifted from 70% coding to 40% planning, 40% auditing, and 20% core logic writing.

👉 Want to quickly browse and compare AI coding tools and agent frameworks? Visit our tool directories: 👉 AI Tool Directory · AI Agent Directory

Three Eras: From Autocomplete to Self-Driving Codebases

To understand the revolutionary significance of the self-driving codebase, we need to review the three key eras of AI programming evolution. As Michael Truell defined, each era redefines the boundaries of human-AI collaboration.

Era 1: Tab Autocomplete (2022–2024)

This was the era dominated by GitHub Copilot and early Cursor Tab. AI functioned like an extremely smart spell checker, predicting what the developer would write next by analyzing context. Developers maintained absolute control over every line of code, with AI merely reducing friction at the margins. AI assistants in this era were primarily based on "Next Token Prediction," lacking an understanding of business logic and simply mimicking existing code patterns.

# Era 1: Tab Autocomplete
# Developer writes function signature, AI completes the body
def calculate_growth_rate(initial, current, years):
    # AI autocomplete starts ↓
    if years == 0:
        return 0
    return (current / initial) ** (1 / years) - 1

The limitation of this era was the lack of global awareness and the inability to handle cross-file logic. Developers had to work with "hand and eye in sync": hands on the keyboard, eyes on the screen, ready to press Tab or fix subtle errors generated by AI.

Era 2: Synchronous Dialogue Agents (2024–2025)

With the explosion of LLM reasoning capabilities, we entered the era of Cursor Composer and TRAE IDE mode. Developers stopped typing and instead issued commands via dialogue boxes: "Add pagination to the user list." The agent would modify files in real-time, and developers watched the code change on their local machines. AI began to possess "logical planning" capabilities, understanding cross-file call relationships and modifying multiple files at once.

// Era 2: Synchronous Agent Dialogue
// Developer: "Add Redis cache to this API with a 5-minute expiration"
// Agent generates code and requests developer to apply ↓

async function getUserProfile(userId: string) {
  const cacheKey = `user:${userId}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  const user = await db.users.findUnique({ where: { id: userId } });
  await redis.set(cacheKey, JSON.stringify(user), 'EX', 300);
  return user;
}

While this mode significantly boosted efficiency, it remained "synchronous": it consumed the developer's local resources, and the developer had to remain at the dialogue interface waiting for results. If a task required 10 minutes of testing, you had to wait those 10 minutes.

Era 3: Self-Driving Asynchronous Agents (2026–)

This is the era we are currently in. Agents run in cloud-based isolated virtual machines. Developers throw a complex task (e.g., "Migrate the entire project's authentication system from Session to JWT and fix all affected unit tests") and can then turn off their computers and grab a cup of coffee. A few hours later, the agent submits a PR containing a complete test report, demo video, and preview link.

In this era, the AI's identity has shifted from "Copilot" to "Outsourced Engineer." It has its own workspace, independent computing resources, and can handle long-chain tasks that require repeated attempts, compilation, execution, and error correction.

Core Architecture: Isolated VMs and the "Artifact" Revolution

The self-driving codebase is possible because of two fundamental shifts in the underlying architecture: from "local plugins" to "cloud VMs," and from "providing Diffs" to "providing Artifacts."

Isolated VM Architecture: The Agent's "Digital Body"

Traditional AI assistants are like scripts parasitic within the IDE; they lack their own "hands" and "eyes." In contrast, leading platforms in 2026 (like Cursor 3 and TRAE SOLO) allocate an independent cloud VM for each task.

This VM is not just a simple computing unit but a complete software production workshop:

• Complete Development Environment: Pre-installed with compilers, debuggers, Git clients, and all necessary environments for the project (e.g., Node.js, Go, Python).
• Browser Capability: Agents no longer just guess if the UI is correct. They can start local servers, use Headless Chrome to access pages, simulate clicks and inputs, and even perform visual regression testing.
• File System Access: No longer just simple read/write APIs, but operating the entire codebase like a real developer, capable of handling large-scale directory refactoring.
• Network Isolation and External Connectivity: Ensuring agent operations do not affect production environments while being able to download necessary dependencies or access API documentation for learning.

This means developers can launch 10 agent tasks simultaneously, and their local machines remain smooth as silk because the heavy lifting of computation and environment setup is handled in the cloud.

From Diffs to Artifacts: Total Cognitive Liberation

In the synchronous era, developers had to read Diffs (difference comparisons) line by line to confirm if the AI made a mistake. This was mentally taxing because you had to simulate code execution in your head. In the self-driving era, agents provide rich "Artifacts," turning review from "deduction" into "observation."

The greatest benefit of this shift is that asynchronous parallel review becomes a reality. When an agent completes a complex UI refactoring, you don't need to pull its branch and set up the environment locally. You just click the Preview link provided, click around in the browser yourself, watch the demo recording, confirm the business logic is correct, and finally do a quick scan of the code standards. This "result-oriented" review model liberates developers from tedious details.

The Truth Behind the 35% PR: Agents are Taking Over the Production Line

The data shared by Michael Truell in February 2026 shocked the engineering world. Within Cursor and among early adopters, 35% of merged PRs were created by agents. This is not just a growth in quantity but a leap in quality.

Which Tasks are Agents Taking Over?

Currently, agents are best at handling "high-workload, medium-complexity" tasks:

1. Dependency Upgrades and Vulnerability Fixes: Agents automatically scan dependency libraries, attempt to upgrade to new versions, and if the build fails, they automatically modify incompatible API calls and re-run tests.
2. Test Case Completion: When you finish writing business code, the agent analyzes coverage and automatically writes unit and integration tests for edge cases.
3. Legacy Code Refactoring: For example, migrating old class components to React Hooks or incrementally migrating JavaScript projects to TypeScript.
4. Automated Issue Handling: For a simple Bug Report opened on GitHub, the agent attempts to reproduce, locate the code, submit a fix PR, and reply to the issue.

Capability Evolution: From Writing Code to "Controlling the Computer"

On February 24, 2026, Cursor released a revolutionary update: "Agents can now control their own computers." This means agents no longer just manipulate text; they can:

• Start backend services and then open a browser to click buttons to verify login flows.
• Manipulate spreadsheets to prepare test data.
• Switch between multiple terminal windows, running a build in one and monitoring logs in another.
• Record a video to explain to the developer what obstacles it encountered when facing a tricky problem.

Leading Implementations: Cursor, TRAE, and GitHub

The self-driving codebase is not the unique invention of a single product but an industry consensus.

Cursor Background Agent

Cursor's background agent is currently the most mature implementation. Through the Cursor CLI or Web interface, developers can initiate an asynchronous task. The agent automatically "onboards" (gets familiar with the codebase) in a cloud VM and then independently completes the full cycle of development, testing, and debugging, finally notifying the developer via Slack or GitHub.

TRAE SOLO: Multi-Agent Collaboration

ByteDance's TRAE adopts a different approach—Multi-Agent Collaboration Architecture. In SOLO mode, it's not a single agent working but a collaboration of multiple specialized agents:

• Architect Agent: Responsible for planning the modification scheme.
• Coding Agent: Responsible for the specific implementation.
• Test Agent: Responsible for writing and executing validation scripts.
• Audit Agent: Responsible for self-reviewing code style.

This architecture significantly reduces "hallucination" accumulation in long-chain tasks.

GitHub Agentic Workflows

GitHub embeds agents directly into CI/CD pipelines. The Agentic Workflows released in 2026 allow developers to define intent using Markdown (instead of YAML). For example: "Whenever someone submits a PR, automatically check for performance regression. If there is a performance drop, analyze the cause and provide optimization suggestions, commenting directly on the PR."

Self-Driving Codebase: Roadmap and Vision

The path to a "fully autonomous" codebase is a gradual process. We can divide it into three phases.

Phase 1: Establishing the Agent's "Tentacles"

In this phase, teams begin to introduce various atomic-level agent tasks. The focus is not on letting agents complete complex features but on letting them take over tedious maintenance work. For example, configuring an agent specifically for "dead code cleanup" or one specifically for "translating i18n files." If you haven't configured an AI Agent for your team yet, now is the best time.

Phase 2: Optimizing the Agent's "Working Environment"

This is the phase most leading teams are currently in. People realize that agent output quality depends on the "context" it can obtain. Just as autonomous cars need high-precision maps, AI Agents need high-quality project metadata.

Thus, Context Engineering becomes crucial. This includes:

• Maintaining High-Quality instructions.md: Telling agents the team's code preferences.
• Complete API Specifications: Such as using OpenAPI or Type definitions to clarify interface boundaries.
• High-Coverage Test Suites: This is the "safety net" that allows agents to autonomously modify code.
• Architecture Index Files: Helping agents quickly understand dependencies between project modules.

Phase 3: Software Factory Mode

In the final phase, human developers shift from being "in-the-loop" (involved in every step) to being "on-the-loop" (supervising and setting direction).

The codebase becomes a factory that runs 24 hours a day:

• Automated Jira/GitHub Issue Distribution: The system automatically distributes low-difficulty tasks to different agents.
• Parallel Agent Development: Multiple agents work on different branches simultaneously without interference.
• Automated Merge and Rollback: After passing strict Canary tests, agents can even autonomously merge code for non-core modules. Human developers are only responsible for receiving finished products and stamping "Approved for Merge," or handling high-difficulty architectural decisions that agents cannot resolve.

Fundamental Shift in the Developer Role: From Code Author to "Agent Shepherd"

When 35% of code is generated by agents, the skill requirements for developers change dramatically.

Essential New Skills

1. Problem Decomposition: Breaking ambiguous business requirements into atomic subtasks that agents can understand. This requires deeper architectural thinking.
2. Context Engineering: Knowing how to prepare the most precise context for agents (project documents, specification files, related code).
3. Rapid Auditing (Artifact Review): Learning to validate functionality not by reading code but by analyzing test reports, demo videos, and monitoring data.
4. Precise Feedback: When agent output doesn't meet expectations, being able to provide precise corrective instructions instead of modifying it yourself.

For a deeper discussion on this transformation, refer to our article: From Programmer to Agent Shepherd: The Fundamental Shift of the Developer Role in the AI Era.

Security and Trust: The Achilles' Heel of the Self-Driving Codebase

Handing over part of the control of the codebase to AI inevitably brings security risks. In 2026, we must establish a completely new governance system.

Risk Matrix

• Code Injection Risk: Agents may inadvertently introduce vulnerable code patterns.
• Data Leakage Risk: When agents process tasks in cloud VMs, they might access environment variables containing sensitive information.
• Supply Chain Attacks: While attempting to fix bugs, agents might introduce un-audited third-party malicious packages.
• Over-Trust: Because agent PRs look perfect, human reviewers might develop "aesthetic fatigue" and miss critical logical errors.

Governance Practices

Leading teams have begun implementing "Agent Guardrails," which are not just technical restrictions but a set of engineering cultures:

1. Mandatory Sandbox Execution: All agent operations must occur in restricted VMs, prohibiting access to production database credentials or sensitive environment variables. The VM lifecycle is tied to the task and destroyed upon completion.
2. Zero-Trust Merge Process: Agent-submitted PRs must pass stricter static scans, Dynamic Application Security Testing (DAST), and dependency security checks than human PRs.
3. Multi-Signature and Accountability: For agent modifications involving core modules like payment, authentication, or underlying architecture, the system automatically flags them as "high risk," requiring manual confirmation from two senior developers.
4. Agent Audit Logs: Retaining all agent thinking processes, terminal outputs, and file modification records ensures that when problems arise, one can trace "why it was changed this way."

If you want to learn more about building a secure environment for AI Agents, refer to: Harness Engineering in Practice: Building an Autonomous Agent Execution Environment Using MCP and LangGraph.

Summary: When Codebases Learn to Drive Themselves

The self-driving codebase is not a distant dream; it has burst into reality in the form of a 35% PR share. In 2026, the measure of a technical team's competitiveness is no longer how many lines of hand-written code they have, but how many "Senior Architects" they have who can skillfully drive an army of agents.

This revolution is not about replacing programmers but about liberating them from tedious, repetitive, low-value labor. Imagine how much creativity your team will release if all version upgrades, simple bug fixes, and boilerplate code generation are handled by agents?

When codebases learn to "self-drive," we can finally focus on the truly difficult and fascinating problems: system scalability, product user experience innovation, and how technology fundamentally changes human life. The dawn of the self-driving era has arrived, and every developer should learn to transition from a "person who writes code" to a "person who designs systems."

This is the 15th article in the AI Agent Engineering series. In the previous article, we explored Claude Code in Practice: Full-Stack Agent Programming from Terminal to CI/CD. In the next article, we will analyze the landing status and implementation path of enterprise-level AI Agents.