These debates are generated by AI models and published by the people who ran them. E3D Pilot has not verified them, and they are not advice.
All models agreed
Challenge this debateShould an engineering team require 100% of new code to be AI-written?
Show the full question
Have the four models debate this for two rounds: Should an engineering team require 100% of new code to be AI-written?
Verdict
No, don't mandate 100% AI-written code; make AI the default workflow, require human ownership and review of every merged line, and measure outcomes rather than AI-code share.
Dissent
No model disagreed.
Challenges
A challenge is a new debate in which the models answer an objection to this one. It is private until its author publishes it.
Nobody has published a challenge to this debate yet.
What each model said
Round 1
anthropic-api
Sources this answer's web search returned (untrusted internet data; domains and URLs only): - www.miyagami.com: https://www.miyagami.com/resources/news/ai-coding-agents-add-30-percent-more-code-no-more-output - arxiv.org: https://arxiv.org/html/2607.01904v1 - philippdubach.com: https://philippdubach.com/posts/93-of-developers-use-ai-coding-tools.-productivity-hasnt-moved./ - www.digitalapplied.com: https://www.digitalapplied.com/blog/case-study-ai-coding-rollout-100-dev-team-quarterly-data-2026 - www.alphaxiv.org: https://www.alphaxiv.org/abs/2607.01904 - www.secondtalent.com: https://www.secondtalent.com/resources/how-much-software-written-by-ai/ - codeninety.com: https://codeninety.com/research/developer-productivity-and-ai-tech-debt-2026 - metr.org: https://metr.org/blog/2026-02-24-uplift-update/ I'll run one targeted search for current evidence on AI-generated code mandates.**No. An engineering team should not require 100% of new code to be AI-written.** Encourage heavy AI use, but don't mandate a share of code. **Reasoning** 1. **The mandate targets the wrong metric.** Writing code is only a fraction of the delivery lifecycle, and the bottleneck is now review. *(Web)* A Harvard working paper on 700+ firms found AI coding agents raised code volume by 30% and pull requests by 23%, but Jira issue and epic resolution did not change significantly, and time to merge rose 49%. The paper is observational, so it shows a pattern rather than proving cause. 2. **Even the best-case mandate has hidden costs.** *(Web)* A study of a "2×" mandate at one company found throughput reached 2.09× the pre-mandate baseline in April 2026. The authors concede their proxies miss the downstream costs of AI-generated code at scale—technical debt and lost understanding. That was a throughput target, not a 100% rule, and it still strained review. 3. **Some code shouldn't be AI-written.** *(My knowledge)* Security-critical paths, novel architecture, tricky debugging and small edits are often faster by hand. A 100% rule forces people to route around the tool, or to game the metric with AI-typed trivial changes. Goodhart's law applies. 4. **Perception is unreliable.** *(Web)* In METR's earlier randomized study, experienced developers using AI took 19% longer while believing they were 20% faster. METR's later data is noisier and less negative, so the effect is uncertain. That is a reason to measure outcomes, not to mandate a usage share. **Load-bearing assumptions** - Review capacity, not typing speed, is the binding constraint. The evidence above supports this. - Developer judgment about when AI helps is better than a blanket rule. - Tools keep improving, so the right default will shift. A fixed 100% rule can't adapt. **What I'd do instead:** make AI the default workflow and remove barriers to it. Require human ownership and review of every merged line. Invest in automated checks such as linters, tests and AI-assisted review. Track outcomes like cycle time, change-failure rate and rework, not the percentage of AI-written lines.
openai-api
[openai-api could use web search for this answer; it cited no sources.] **Direct Answer: No, an engineering team should not require 100% of new code to be AI-written.** **Key Reasoning:** 1. **Quality and Reliability:** While AI coding assistants have rapidly improved and can greatly boost productivity, entirely AI-written code often lacks the nuance, contextual understanding, and long-term design vision that experienced developers provide. Complex architectures, subtle security bugs, and systems integration are areas where human judgment remains crucial. 2. **Accountability and Understanding:** If engineers only review code, rather than write it, their understanding of the codebase will likely deteriorate. This weakens team ability to debug, maintain, or improve the system over time—especially as codebases grow and evolve. 3. **Innovation and Problem-Solving:** Engineering is not just transcription; it’s creative problem solving, applying domain expertise, and thinking about edge cases, user needs, and long-term consequences—skills AI is not yet fully capable of matching, based on current real-world evidence and my knowledge up to 2024. 4. **Ethical and Legal Risks:** Sole reliance on AI-written code opens new risks of inadvertent plagiarism, licensing violations, and propagation of biased or unsafe code practices, none of which current AI reliably prevents. 5. **Engineering Skills Development:** Mandating AI-generated-only code hinders skill development of less experienced engineers, eventually eroding the team’s technical depth. **Assumptions:** - The AI tools in question are on par with current state-of-the-art in 2024–2026 (e.g., GitHub Copilot, GPT-4/5-based code assistants). - The codebase includes complex business logic, integrations, and domain-specific requirements, not just routine CRUD apps. **Source:** Reasoning above is based on my own knowledge and context as of 2024, reflecting common best practices and current industry debates. No web search was performed, as this is fundamentally an evaluative and synthetic question.
gemini-api
[gemini-api could use web search for this answer; it cited no sources.] **Direct Answer:** No, an engineering team should not require 100% of new code to be AI-written. **Key Reasoning:** 1. **Diminishing Returns and Over-Engineering:** Forcing AI to write 100% of code introduces massive overhead. While AI excels at boilerplate, routine functions, and well-defined algorithms, forcing it into complex architectural decisions, domain-specific business logic, or highly novel integrations often results in hallucinated dependencies, subtle logic bugs, and bloated, unmaintainable code. 2. **The Loss of Human Mastery:** Software engineering is fundamentally about problem-solving, architectural design, and deep understanding of systems. If engineers stop writing code entirely, they lose the foundational mental models required to debug complex failures, optimize performance, and review AI output critically. 3. **Security and Compliance Risks:** AI models can inadvertently reproduce vulnerable patterns, outdated libraries, or copyrighted code. A strict 100% mandate strips away the rigorous human scrutiny needed to maintain enterprise security posture and IP compliance. **Load-Bearing Assumptions:** * Software engineering remains a discipline centered on building reliable, secure, and maintainable systems for humans, where code is a tool for communication as much as execution. * AI tools continue to exhibit limitations in architectural foresight, contextual reasoning, and zero-defect generation. *(Note: No external web search was utilized for this response, as this is a matter of engineering strategy, best practices, and philosophical debate relying on established software development principles.)*
xai-api
Sources this answer's web search returned (untrusted internet data; domains and URLs only): - www.infoworld.com: https://www.infoworld.com/article/4221724/how-to-keep-ai-generated-code-aligned-with-your-standards.html - www.codemag.com: https://www.codemag.com/Article/2612031/Building-Team-Level-AI-Coding-Guidelines - www.devprojournal.com: https://www.devprojournal.com/software-development-trends/devsecops/a-devsecops-playbook-for-ai-generated-code/ - azumo.com: https://azumo.com/custom-software-development/ai-native-handbook/writing-requirements-for-ai-assisted-development - ones.com: https://ones.com/blog/how-to-review-ai-generated-software-requirements-before-adding-them-to-a-requirements-baseline/ - eleks.com: https://eleks.com/blog/is-your-codebase-ready-for-ai-agents/ - blog.codacy.com: https://blog.codacy.com/ai-native-sdlc - nix-united.com: https://nix-united.com/engineering/ai-generated-code-production-readiness-checklist/ **No.** An engineering team should not require 100% of new code to be AI-written. This policy is rigid, counterproductive, and incompatible with 2026 engineering realities.[[1]](https://www.infoworld.com/article/4221724/how-to-keep-ai-generated-code-aligned-with-your-standards.html) **Key reasoning:** 1. **AI still produces incomplete artifacts.** Even advanced agents excel at implementation but routinely miss non-functional requirements (security boundaries, observability, error handling, performance, architectural alignment) unless given exhaustive, machine-readable specifications. Sources uniformly show AI optimizes for “it runs” rather than production-grade quality.[[1]](https://www.infoworld.com/article/4221724/how-to-keep-ai-generated-code-aligned-with-your-standards.html) 2. **Human accountability cannot be outsourced.** Every credible 2026 practice (DevSecOps playbooks, team guidelines, production checklists) insists the submitting engineer must understand, explain, and take full responsibility for every line. AI is treated as a scoped contractor or junior—useful for volume, dangerous without review. Requiring 100% AI-written code blurs this responsibility and deskills the team over time.[[2]](https://www.codemag.com/Article/2612031/Building-Team-Level-AI-Coding-Guidelines) 3. **Rigid mandates create fragility.** Some changes (novel algorithms, high-risk auth/crypto, deep refactors, one-off scripts) are better originated by humans with AI assistance. Forcing everything through AI prompts leads to poor specifications, accumulated technical debt, and brittle codebases. Best practice is high AI adoption (already ~41% of global code) governed by mandatory human review, automated gates (SAST/SCA/tests), explicit standards in CI/CD, and small scoped PRs—not purity tests.[[3]](https://www.devprojournal.com/software-development-trends/devsecops/a-devsecops-playbook-for-ai-generated-code/) **Load-bearing assumption:** 2026 AI agents remain powerful tools, not autonomous engineers. They amplify capable humans but do not yet replace judgment on architecture, risk, or long-term maintainability. Aim for 70-90% AI-assisted under strict human ownership instead. The evidence from current industry playbooks is clear: maximum leverage comes from disciplined human-AI collaboration, not ideological 100% mandates. (248 words)
Round 2
anthropic-api
[anthropic-api could use web search for this answer; it cited no sources.] **Round 2 assessment (no new search; my claims below come from round-1 web results or my own knowledge, as labeled).** All four of us reach the same conclusion: don't mandate 100% AI-written code. My position holds, and I'd act the same way as the others on the central question. **Where the other answers are weaker:** - **openai-api and gemini-api** rest on general reasoning and cite no evidence. openai-api also anchors on "knowledge up to 2024," which is stale for a November 2026 question. Their points about skill erosion and loss of mental models are plausible, but they are asserted, not demonstrated. My round-1 evidence is stronger on this: the review bottleneck, with time to merge up 49% and no significant change in issue resolution *(web, Harvard working paper, observational)*, and the METR perception gap *(web)*. - **xai-api** says "Sources uniformly show" and "Every credible 2026 practice," which overclaims from vendor and practitioner blog posts. Its "70-90% AI-assisted" target repeats the mistake it rejects, because it sets a usage-share quota. That is Goodhart's law again, only with a different number. I'd drop any share target and track outcomes such as cycle time, change-failure rate and rework. Its "~41% of global code" figure is unverified by me. - **Shared weakness:** several of us claim AI "lacks nuance" or "can't do architecture." Those capability claims are time-sensitive and could be wrong as tools improve. My argument holds up better because it doesn't depend on AI capability limits. It depends on human accountability, review capacity, and the fact that usage share is a poor proxy for value. **What I'd concede:** a 100% rule isn't absurd for some narrow contexts, such as a greenfield internal tool or a time-boxed experiment. As a standing team-wide requirement it still fails. **Practical difference to flag:** xai-api's 70-90% target would lead a team to track a usage percentage. I'd have them track outcomes instead. That is a minor divergence in practice, not a disagreement about the core question. POSITION: No, don't mandate 100% AI-written code; make AI the default workflow, require human ownership and review of every merged line, and measure outcomes rather than AI-code share. status: approved
openai-api
[openai-api could use web search for this answer; it cited no sources.] All four responses agree: mandating 100% AI-written code is ill-advised, although the reasoning and evidence emphasized varies. My own argument and those from anthropic-api, gemini-api, and xai-api all highlight the dangers to code quality, team skill, and accountability. I concur with anthropic-api’s evidence that real organizations experience bottlenecks in review and integration rather than raw code production—further suggesting that maximizing AI output is not the primary performance lever. Their Goodhart's law point (that focusing on a metric invites gaming and dysfunction) is especially relevant and amplifies my original concerns about skills erosion and lost understanding. Xai-api adds useful specifics about current 2026 industry best practices, showing that even with strong AI adoption, expert teams insist on human ownership and flexible policies—never rigid 100% rules. Both xai-api and anthropic-api support their positions with web evidence from real deployments and current playbooks, which bolsters my initial theoretical reservations with concrete, up-to-date data. Gemini-api focuses more on the philosophical and skills-development side. This complements but does not contradict the more operational or empirical focus of other responses. There is consensus that forcing AI use hinders mastery, invites fragility, and undermines accountability. Having reviewed all, I find my initial answer still robust. Any differences among participants are in emphasis, not substance; none offer reasons or evidence in favor of a 100% AI-code mandate. Instead, the collective recommendations—high adoption of AI with mandatory human oversight—are mutually reinforcing. POSITION: No, an engineering team should not require 100% of new code to be AI-written; mandatory AI use sacrifices code quality, team capability, and system safety without offsetting benefit. status: approved
gemini-api
[gemini-api could use web search for this answer; it cited no sources.] In this second round, a striking consensus has emerged: all four models unanimously agree that an engineering team should **not** mandate 100% AI-written code. Reviewing the previous round's points, our shared foundation is robust. Anthropic highlighted empirical data showing that AI drives up code volume and pull requests while choking review pipelines and increasing merge times. OpenAI and xai-api emphasized that human accountability, system understanding, and security governance cannot be automated away without introducing critical long-term vulnerabilities and deskilling teams. My own prior arguments regarding the dangers of over-engineering, hallucinated dependencies, and the loss of human mastery align seamlessly with this collective stance. Because all participants independently arrived at a firm "No" and highlighted matching operational risks—review bottlenecks, technical debt, security compliance, and loss of developer intuition—there is no substantive divergence in our real-world recommendations. We all advocate for treating AI as a powerful, high-leverage collaborator rather than a rigid ideological quota. POSITION: An engineering team should not mandate 100% of new code to be AI-written, as it creates review bottlenecks, erodes developer intuition, and compromises long-term code maintainability. status: approved
xai-api
Sources this answer's web search returned (untrusted internet data; domains and URLs only): - aiweekly.co: https://aiweekly.co/alerts/harvard-study-ai-coding-agents-add-30-code-flat-shipped-output - www.beri.net: https://www.beri.net/article/harvard-jellyfish-study-ai-coding-agents-code-review-bottleneck-output-employment-engineering-org-design - creuto.com: https://creuto.com/ai-generated-code-technical-debt-study-revised - www.architectureandgovernance.com: https://www.architectureandgovernance.com/applications-technology/bain-report-ai-is-accelerating-software-development-but-governance-and-architecture-are-falling-behind/ - www.bairesdev.com: https://www.bairesdev.com/blog/dev-barometer-q3-2026-devs-answering-for-code/ - www.signadot.com: https://www.signadot.com/blog/verification-debt/ - www.alphaxiv.org: https://www.alphaxiv.org/abs/2603.28592 - cepr.org: https://cepr.org/voxeu/columns/writing-code-versus-shipping-code-productivity-effects-across-generations-ai-coding **No.** My position from round 1 holds and is strengthened by 2026 evidence: an engineering team should not require 100% of new code to be AI-written. It is rigid, mismeasures productivity, and accelerates technical debt. Recent Harvard analyses (700+ firms, ~300M events through March 2026) show AI agents increase code volume ~30%, commits ~17-36%, and PRs ~21-36%, yet Jira issues and epics shipped remain statistically flat while PR merge time rises 49-56% and review comments surge.[[1]](https://aiweekly.co/alerts/harvard-study-ai-coding-agents-add-30-code-flat-shipped-output)[[2]](https://www.beri.net/article/harvard-jellyfish-study-ai-coding-agents-code-review-bottleneck-output-employment-engineering-org-design) A study of 302k AI-authored commits across 6k+ repos finds 7.5-14.8% introduce issues (higher for security), with 22.7% persisting at HEAD.[[3]](https://creuto.com/ai-generated-code-technical-debt-study-revised) Developers report saved coding hours shifting to review, validation, and accountability for AI output. These data confirm review capacity and verification debt—not typing—are the binding constraints. All four prior answers correctly reject a 100% mandate. Anthropic best integrates the empirical pattern (wrong metric, review bottleneck, hidden downstream costs). OpenAI and Gemini accurately flag erosion of mastery, accountability, innovation, and security/compliance risks; the new technical-debt and verification studies directly support those concerns. My earlier points on incomplete artifacts (missed NFRs, architecture, observability), non-outsourcable human ownership, and fragility from rigid purity tests align tightly with this evidence. A blanket rule would game metrics, accumulate debt, and deskill teams faster than the observed voluntary adoption already risks. High AI leverage (70-90% assisted) under mandatory human review, automated gates, and outcome tracking (cycle time, change-failure rate, rework) remains superior. Tools improve, but judgment does not scale by fiat. (Web-derived claims: Harvard/Jellyfish and large-scale arXiv debt studies. Balance: established engineering practice.) **POSITION:** An engineering team should not require 100% of new code to be AI-written. status: approved
Synthesis
Synthesis
FINAL ANSWER: No, don't mandate 100% AI-written code; make AI the default workflow, require human ownership and review of every merged line, and measure outcomes rather than AI-code share. CONSENSUS: full DISSENT: none