Convex · Published 2026-10-08

Nobody Agrees About Agentic Development

privateReview: unreviewedConfidence: high
AI agentssoftware engineeringarchitectureopen sourceproductivityagentic developmentCode reviewtechnical debtllm failure modesverificationDistribution moat
Open on YouTube ↗

Summary

Overview

  • Speaker: Jamie Cwiling, Theo Brown, Jean-Denis Greze, David Cramer
  • Channel: Convex
  • Main topic: Agentic development and software engineering
  • Purpose: To debate and analyze the practical business and technical value, challenges, and future of agentic development in modern software engineering. A panel discussion exploring the impact of AI agents on software development, productivity, code review, architecture, and open-source practices.

Topic Map

Business and Technical Value of Agentic Development

  • Explanation: Panelists discuss the business value and productivity impact of AI agents on software development across AI and non-AI companies.
  • Key claims:
    • Agentic development increases productivity and self-sufficiency.
    • Most value so far has been internal and operational.
    • Non-AI companies see software as a productivity tool, viewing AI as an efficiency improvement.
  • Examples:
    • Spending money on frontier model use for coding.
    • Internal tooling and documentation access.
  • Terminology:
    • agentic development
    • frontier model
    • productivity tool
  • Why it matters: Determines whether AI agents are transformative or merely incremental efficiency boosts for software engineering.

Code Review and the Bar for Code Quality

  • Explanation: Debate on whether AI agents make code review obsolete or more difficult, and how developers set quality thresholds.
  • Key claims:
    • Code review is stressful and agents make it worse if code generation outpaces human comprehension.
    • Developers keep moving the bar for code quality as models improve.
    • Agents help handle high volumes of pull requests.
  • Examples:
    • Reviewing 1,000 pull requests every two weeks with a small team.
    • Cherry-picking useful commits from agent suggestions.
  • Terminology:
    • code review
    • pull request
    • regression
    • tdd
  • Why it matters: Addresses the liability and maintenance risks associated with AI-generated code bases.

Architecture, Abstraction, and Spaghetti Code

  • Explanation: Discussion on how AI agents handle software architecture, maintain context, and whether they promote spaghetti code.
  • Key claims:
    • LLMs love spaghetti code and tend to break abstractions.
    • Junior engineers can introduce complex technical debt much faster with AI.
    • Good architecture means meeting product requirements with minimal human intervention.
  • Examples:
    • Refactoring codebases and dealing with architectural drift.
    • Writing 5,000 lines of code and running performance checks.
  • Terminology:
    • architecture
    • abstraction
    • spaghetti code
    • refactoring
  • Why it matters: Highlights the risk of unmaintainable codebases scaling rapidly due to AI generation speed.

Open Source vs Closed Source in the Age of Agents

  • Explanation: How agentic development impacts open source software, distribution power, and competitive moats.
  • Key claims:
    • Distribution and network effects remain the ultimate moat.
    • Open source benefits from AI because thousands of eyes can review agent-assisted code.
    • Closed-source companies rely on secrecy and proprietary talent moats.
  • Examples:
    • Cloning convex codebases.
    • Open source repositories handling pull requests with AI.
  • Terminology:
    • open source
    • closed source
    • distribution
    • moat
    • fork
  • Why it matters: Explores the shifting dynamics of software ownership, security, and competitive advantage.

Key Points

Productivity vs Architecture Tradeoff

  • Explanation: AI agents speed up code generation significantly, but maintaining architectural integrity requires strict discipline.
  • Evidence: Panelists noted merging 100 PRs in 24 hours without regression due to robust automated systems.
  • Practical implication: Teams must invest in robust CI/CD pipelines and verification systems to catch agent errors early.

The Changing Role of Junior Engineers

  • Explanation: AI lowers the barrier to introducing complex technical complexity, changing how junior and senior engineers collaborate.
  • Evidence: Juniors can iterate faster, but lack systemic architectural context.
  • Practical implication: Mentorship and architectural oversight remain critical to prevent systemic technical debt.

Distribution as the Ultimate Moat

  • Explanation: While AI lowers barriers to writing code, distribution and user trust remain the primary competitive advantages.
  • Evidence: Commercial giants maintain dominance through market reach and ecosystem lock-in rather than proprietary code alone.
  • Practical implication: Businesses should focus on distribution and customer relationships rather than relying on code secrecy.

Frameworks, Models & Processes

Agentic Engineering Verification Framework

  • How it works: Using automated systems and AI agents to pre-screen, test, and vet code changes before human review.
  • Components:
    • Automated CI/CD checks
    • Agent-assisted PR filtering
    • Architectural guardrails
  • When to use: When managing high-volume code generation from AI agents in production environments.

Examples & Case Studies

A two-person team merging 1,000 pull requests every two weeks using AI agents.

  • Illustrates: The extreme velocity enabled by agentic development.
  • Lesson: Automation and robust testing frameworks are necessary to handle agent-generated code volume safely.

Actionable Takeaways

  • Immediate:
    • Implement automated verification for AI-generated code.
    • Use AI to triage pull requests and surface valuable commits.
  • Strategic:
    • Focus on distribution and network effects rather than code secrecy as a moat.
    • Redefine software architecture around LLM capabilities and limitations.
  • Questions to investigate:
    • At what point does AI-generated code architecture require human intervention?
    • How will open-source ecosystems sustain security with high volumes of AI contributions?

Claims Worth Verifying

  • Distribution is the only moat that truly exists in software. (business strategy)
  • Open-source projects benefit from thousands of eyes reviewing agent-generated code. (software engineering)

Notable Quotes

"Nobody Agrees About Agent Development" "Engineering is not writing code. Engineering is solving problems for people in the presence of constraints." (at 47:08)

Compressed Summary

  • Agentic development dramatically increases code generation velocity.
  • Architectural drift and spaghetti code are major risks with LLMs.
  • Distribution and network effects remain stronger moats than code secrecy.
  • Keywords: ai agents, software engineering, architecture, open source, productivity
  • Core insight: Agentic development drastically accelerates code generation and shifts the primary engineering challenge from writing code to enforcing architecture, verification, and distribution.

Core insights

6
Failure Modehigh noveltymoderate evidence

LLMs exhibit a bias toward spaghetti code and break abstractions, creating a failure mode where agent-generated code erodes architectural integrity unless explicitly constrained.

Why it matters

Identifies a specific LLM behavior that undermines maintainability, implying that architectural constraints must be automated rather than relying on developer discipline.

Generalization

Any agentic coding system must include architectural guardrails to prevent abstraction erosion as code generation scales.

LLMs love spaghetti code and tend to break abstractions.
Open source video
Mechanismmedium noveltymoderate evidence

A verification framework combining automated CI/CD, agent-assisted PR filtering, and architectural guardrails enables high-velocity merging (e.g., 100 PRs in 24 hours without regression) by pre-screening agent-generated code.

Why it matters

Provides a concrete pattern for safely scaling agent output, emphasizing automated pre-screening over human line-by-line review.

Generalization

Automated verification pipelines are essential infrastructure for agentic development, shifting human effort to exception handling and architectural oversight.

merging 100 PRs in 24 hours without regression due to robust automated systems
Open source video
Automated CI/CD checks
Open source video
Agent-assisted PR filtering
Open source video
Architectural guardrails
Open source video
Practicehigh noveltymoderate evidence

Effective code review in agentic development shifts from line-by-line inspection to high-volume triage and cherry-picking of agent-generated commits, necessitating agent-assisted PR filtering.

Why it matters

Redefines the human role in code review and implies that tooling must support summarization, prioritization, and automated regression detection.

Generalization

As generation volume increases, human review must move up the abstraction ladder, focusing on intent and architecture rather than syntax.

Reviewing 1,000 pull requests every two weeks with a small team
Open source video
Cherry-picking useful commits from agent suggestions
Open source video
Agents help handle high volumes of pull requests.
Open source video
Empirical Resultmedium noveltymoderate evidence

Junior engineers using AI can introduce complex technical debt much faster, shifting the risk profile from simple bugs to systemic architectural debt.

Why it matters

Changes the nature of technical debt accumulation and implies that mentorship and architectural oversight become more critical, not less.

Generalization

AI assistance amplifies the impact of inexperience on codebase health, requiring new forms of supervision.

Junior engineers can introduce complex technical debt much faster with AI.
Open source video
Mental Modelmedium noveltymoderate evidence

Engineering is fundamentally about solving problems under constraints, not writing code, which reframes the value of agentic development away from code generation volume.

Why it matters

Shifts the focus from measuring lines of code to measuring problem-solving effectiveness and constraint satisfaction.

Generalization

Agentic systems should be evaluated by their ability to solve constrained problems, not by code output metrics.

Engineering is not writing code. Engineering is solving problems for people in the presence of constraints.
Open source video
Predictionmedium noveltyweak evidence

As AI lowers barriers to writing code, competitive advantage shifts from code secrecy to distribution and network effects, making proprietary code a weaker moat.

Why it matters

Affects strategic decisions about open vs closed source and where to invest engineering effort for defensibility.

Generalization

In an era of cheap code generation, distribution and user trust become primary assets.

Distribution and network effects remain the ultimate moat.
Open source video
Distribution is the only moat that truly exists in software.
Open source video

Deep dives

5

Automated architectural guardrails for LLM-induced abstraction erosion

Research question

Can automated architectural guardrails measurably prevent LLM-induced abstraction erosion in agent-generated codebases?

Why

If LLMs systematically break abstractions, then agentic development velocity creates unmaintainable systems unless constraints are encoded in CI rather than left to developer discipline.

LLMs love spaghetti code and tend to break abstractions.
Open source video
Refactoring codebases and dealing with architectural drift.
Open source video
Source video

Verification architecture for high-velocity agentic PR workflows

Research question

What verification architecture allows a two-person team to merge 1,000 AI-generated PRs every two weeks without increased regressions?

Why

Tests whether high-velocity agentic development is safe and repeatable, and what automated pre-screening must replace line-by-line human review.

Reviewing 1,000 pull requests every two weeks with a small team.
Open source video
Agents help handle high volumes of pull requests.
Open source video
Cherry-picking useful commits from agent suggestions.
Open source video
Code review is stressful and agents make it worse if code generation outpaces human comprehension.
Open source video
Source video

AI-assisted junior engineers and systemic technical debt

Research question

Does AI assistance disproportionately accelerate systemic technical debt accumulation for junior engineers compared with senior engineers?

Why

Determines whether agentic development requires new mentorship and architectural oversight models, because AI removes implementation friction without supplying architectural judgment.

Junior engineers can introduce complex technical debt much faster with AI.
Open source video
Good architecture means meeting product requirements with minimal human intervention.
Open source video
Source video

Dynamic recalibration of code quality thresholds for AI-generated code

Research question

How can teams systematically recalibrate acceptance criteria for AI-generated code as model capabilities improve?

Why

Prevents quality thresholds from being arbitrary and reactive, enabling predictable adoption of better models without losing regression control.

Developers keep moving the bar for code quality as models improve.
Open source video
Code review is stressful and agents make it worse if code generation outpaces human comprehension.
Open source video
Source video

Open-source security under high-volume AI-generated contributions

Research question

Does high-volume AI-generated contribution improve or overwhelm security review in open-source ecosystems?

Why

Open-source security depends on whether more eyes scale with more code or become a bottleneck as agent-assisted PR volume rises.

Open source benefits from AI because thousands of eyes can review agent-assisted code.
Open source video
Open source repositories handling pull requests with AI.
Open source video
Source video

Article ideas

4

Agentic Development's Spaghetti-Code Debt: Why Architecture Must Be Enforced, Not Trusted

AI agents systematically erode abstractions, so the highest-leverage response is automated architectural guardrails in CI, not faster code generation.

Angle

Failure-mode analysis plus concrete guardrail patterns for agent-generated code.

Source video

The 1,000-PR Reality: Code Review Is Becoming Triage Infrastructure

Human line-by-line review cannot survive agentic generation volume; teams must treat code review as agent-assisted triage with automated regression detection.

Angle

Operating model for high-volume AI PRs and the tooling it requires.

Source video

AI Makes Junior Engineers Faster at Creating Technical Debt

AI removes implementation friction for junior engineers without supplying architectural judgment, so mentorship must shift from code writing to constraint and architecture oversight.

Angle

Risk and mentorship implications of AI-assisted junior developers.

Source video

When Code Is Cheap, Distribution Is the Only Moat

As AI lowers the cost of code generation, proprietary source becomes a weaker moat, and open-source/network distribution advantages become the primary strategic asset.

Angle

Strategic impact of agentic development on open source versus closed source.

Source video

Project ideas

4

ArchGuard

gatehouse

Automated architectural guardrails in CI reduce abstraction-eroding changes merged from LLM agents by more than 50% without reducing agent PR throughput.

Proof of concept

Add architecture-as-code checks for dependency direction, module boundaries, and abstraction leaks to a repo receiving LLM agent PRs, then compare against a baseline without guardrails.

Measurement

Abstraction violations per 1,000 agent PRs; PR merge volume; revert rate; reviewer time.

Source video

TriageGate

gatehouse

An agent-assisted PR triage layer can let a two-person team merge 1,000 AI-generated PRs every two weeks with equal or lower regression escape rate than manual review.

Proof of concept

Build a bot that clusters agent PRs by intent, summarizes diffs, ranks regression risk, and suggests cherry-picks, then run A/B tests against manual review on the same backlog.

Measurement

PRs merged per two weeks; regression escape rate; reviewer minutes per PR; cherry-pick precision.

Source video

JuniorDebtBench

beyond-evals

AI-assisted junior engineers introduce systemic architectural debt at a higher rate than AI-assisted senior engineers on comparable modular tasks.

Proof of concept

Run a controlled study where junior and senior developers use the same agent on a modular codebase, measuring introduced coupling, abstraction breaks, and rework on fixed tasks.

Measurement

Architectural debt score; rework rate; abstraction violations per task; time to remediation.

Source video

ThresholdCalibrator

beyond-evals

Teams can systematically raise auto-merge thresholds for AI-generated code as models improve if regression escape rate is tracked against model version and acceptance criteria.

Proof of concept

Build a dashboard that records model version, PR acceptance decision, automated checks, and post-merge regressions, then simulate threshold policy changes across model upgrades.

Measurement

Auto-merge rate versus regression escape rate per model version; reviewer escalation rate; threshold adjustment frequency.

Source video

Architectural implications

3

Architectural integrity must be enforced by automated guardrails rather than relying on developer discipline.

Before

Developers manually maintain abstractions through code review and pair programming.

After

Automated architectural linting and agent-assisted PR filtering become primary enforcement mechanisms.

Consequence

Teams must invest in defining and encoding architectural constraints into CI/CD pipelines.

Source video

Code review shifts from a human-centric, line-level activity to an agent-assisted triage process.

Before

Reviewers read and understand each change.

After

Reviewers filter and cherry-pick agent-generated commits based on automated signals.

Consequence

Tooling must support high-volume summarization, prioritization, and automated regression detection.

Source video

The role of junior engineers changes from learning through implementation to supervising and curating AI output, requiring stronger architectural mentorship.

Before

Juniors learn by writing code and receiving feedback.

After

Juniors iterate rapidly with AI but may introduce systemic debt.

Consequence

Mentorship must focus on architectural principles and oversight systems.

Source video

Tradeoffs and failure modes

3

Agentic development velocity vs architectural integrity

Benefit

Massive increase in code generation and PR throughput.

Cost or risk

LLMs break abstractions and generate spaghetti code, leading to unmaintainable systems.

LLMs love spaghetti code and tend to break abstractions.
Open source video
Source video

AI-assisted junior engineers vs technical debt

Benefit

Juniors can iterate faster and contribute more code.

Cost or risk

They can introduce complex technical debt much faster due to lack of systemic context.

Junior engineers can introduce complex technical debt much faster with AI.
Open source video
Source video

High-volume code generation vs human comprehension in code review

Benefit

Agents help handle high volumes of pull requests.

Cost or risk

Code review becomes stressful and ineffective if generation outpaces human comprehension.

Code review is stressful and agents make it worse if code generation outpaces human comprehension.
Open source video
Source video

Open questions

3

At what point does AI-generated code architecture require human intervention?

Why unresolved

The summary poses this as an open question, indicating no clear threshold or mechanism is established.

Research direction

Develop metrics for architectural drift and study intervention points in agentic coding workflows.

Source video

How will open-source ecosystems sustain security with high volumes of AI contributions?

Why unresolved

Raised as an open question; the balance between increased review volume and security assurance is unclear.

Research direction

Investigate automated security review tools and incentive structures for open-source maintainers.

Source video

How do teams systematically recalibrate quality thresholds for AI-generated code as models improve?

Why unresolved

The summary notes developers keep moving the bar, but no method for systematic recalibration is provided.

Research direction

Study dynamic acceptance criteria and evaluation frameworks that adapt with model capabilities.

Source video

Key claims

8
causalVerification needed

LLMs tend to produce spaghetti code and break abstractions.

Evidence

LLMs love spaghetti code and tend to break abstractions.

Question

Under what conditions do LLMs break abstractions, and can architectural guardrails prevent it?

Source video
causalVerification needed

Junior engineers can introduce complex technical debt much faster with AI.

Evidence

Junior engineers can introduce complex technical debt much faster with AI.

Question

Does AI assistance specifically accelerate technical debt accumulation for junior engineers compared to senior engineers?

Source video
factualVerification needed

Merging 100 PRs in 24 hours without regression is possible with robust automated systems.

Evidence

merging 100 PRs in 24 hours without regression due to robust automated systems.

Question

What specific automated systems enable this, and what is the false negative rate for regressions?

Source video
factualVerification needed

A two-person team can merge 1,000 pull requests every two weeks using AI agents.

Evidence

A two-person team merging 1,000 pull requests every two weeks using AI agents.

Question

What is the defect rate and long-term maintainability of code merged at this velocity?

Source video
opinionVerification needed

Distribution and network effects remain the ultimate moat in software.

Evidence

Distribution and network effects remain the ultimate moat.

Question

Does AI-driven code generation reduce the importance of proprietary code as a moat in practice?

Source video
causalVerification needed

Open source benefits from AI because thousands of eyes can review agent-assisted code.

Evidence

Open source benefits from AI because thousands of eyes can review agent-assisted code.

Question

Does the increased volume of AI-generated open source code improve security through review, or does it overwhelm reviewers?

Source video
opinionVerification needed

Developers keep moving the bar for code quality as models improve.

Evidence

Developers keep moving the bar for code quality as models improve.

Question

How do teams systematically recalibrate their acceptance criteria for AI-generated code over time?

Source video
opinionVerification not requested

Engineering is not writing code; it's solving problems for people in the presence of constraints.

Evidence

Engineering is not writing code. Engineering is solving problems for people in the presence of constraints.

Source video

Connections

3