--- title: AI usage generates a fragile codebase | daily.dev description: Heavy reliance on AI coding tools produces fragile, brittle codebases, a former Meta engineer argues. The author lists four causes: AI writes shallow tests... canonical: https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9 twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: AI usage generates a fragile codebase | daily.dev og:description: Heavy reliance on AI coding tools produces fragile, brittle codebases, a former Meta engineer argues. The author lists four causes: AI writes shallow tests... og:url: https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9 og:image: https://api.daily.dev/og/posts/6EcxBInl9.png og:image:alt: AI usage generates a fragile codebase og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # AI usage generates a fragile codebase **[Hacker News](https://daily.dev/sources/hn)** · 7 min read · 3 upvotes · 1 comments ## Summary Heavy reliance on AI coding tools produces fragile, brittle codebases, a former Meta engineer argues. The author lists four causes: AI writes shallow tests that miss things that matter to humans, generates overly complex code by over-applying principles like DRY, erodes human understanding of the codebase, and ships pull requests faster than reviewers can properly vet them. These lead to four symptoms: more incidents, slower incident recovery, errors only visible to real users, and a degraded overall user experience. The author says they generated at least 90% of their code with AI at Meta and now generates 100% at their current job, calling it an industry expectation. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What are the main ways AI coding agents make a codebase fragile? Four patterns stand out: AI writes shallow tests covering only trivial get/set methods or already-covered cases, it writes overly complex code by over-applying principles like DRY with unnecessary helper methods, heavy reliance erodes human developers' understanding of the codebase, and pull requests arrive faster than reviewers can properly scrutinize them, letting small quality issues accumulate into tech debt. _Weigh these AI code-generation tradeoffs against your own team's review practices using discussions tracked on daily.dev._ ### Do AI-generated codebases lead to more production incidents? Yes, according to one engineer's experience at a large SaaS company: after a year or two of agentic coding, incidents escalated from occasional to happening nearly every weekend, and recovery took longer each time because developers had a shallower understanding of the code and had to dig through unfamiliar, poorly tested territory to find root causes. _Track real-world reports like this to gauge whether agentic coding is worth the incident risk for your team, on daily.dev._ ## Community take How the wider developer community reacted, aggregated from 1 discussion and 293 comments across hackernews (as of 2026-11-10). **TL;DR:** Discussion is split between developers who say large AI-generated codebases hold up fine in their personal/solo projects and skeptics who argue early-stage, low-user projects can't yet prove long-term maintainability; many also debate whether 'maintainability' even matters anymore if rewrites become cheap. **Sentiment:** 30% positive · 25% mixed · 45% skeptical **The case for** - Several people report maintaining sizable AI-generated codebases (mobile apps, a mountaineering app) without major issues. - Some argue that as models improve, rewriting code becomes cheaper than maintaining it, making traditional maintainability concerns less relevant. - One commenter describes a workflow (mutation tests, property-based tests, modular isolation) that reportedly reduced incidents while shipping more. - Pairing AI code generation with strongly typed/functional languages is said to reduce the need for extensive tests. **The pushback** - Critics argue a two-week-old app with only 30 users provides no real evidence about long-term maintenance burden. - Several note that LLMs tend to produce verbose, duplicated, over-tested, or oddly-architected code that a human then has to prune. - Some warn that architecture and requirements are themselves being delegated to AI, removing the human oversight needed to catch misaligned or nonsensical goals. - There's concern that institutionalized, unreviewable AI-generated complexity will erode developers' skills and understanding over time, creating long-term risk even if short-term output looks fine. - One commenter points out that LLM failure modes are unpredictable/alignment-based, unlike well-understood human error patterns, making them harder to guard against at scale. **By community** - hackernews (heated): A long, contentious subthread pits people who claim AI-built codebases remain healthy against others insisting such claims are unverifiable without real users and time, alongside a broader philosophical debate about whether code maintainability still matters. **Hottest debate:** Whether a solo, days-old, low-user AI-generated app is legitimate evidence that large AI-written codebases stay maintainable long-term. **Open questions** - Does code maintainability as a concept still matter if the marginal cost of rewriting with better models keeps dropping? - How do you measure or prove that an AI-generated codebase isn't accumulating hidden fragility before it has significant real-world usage? - Can 'black box' prompting (goals only, no architecture guidance) scale to complex systems without producing unrealistic or nonsensical specs? **Highlights** > After 7 months and a 500k LOC codebase I can say that in my experience the fragility is inconsequential. Disclaimer: I have no SaaS platform, it's a mobile app. In my experience maintenance does not suffer long term with codebase size, if anything it became easier with model advances. Most people talking about suboptimal implementation, fragility, and maintenance burden seem to theorize and extrapolate with no actual experience in implementing a large project with AI. I can't blame them, I see the same in my day job, but the results after 500h+ on a separate project show that the concerns do not manifest in practice. > — [user43928 on hackernews · 11 comments](https://news.ycombinator.com/item?id=50438912) > > You think that after my 500h of work and daily usage of my own app, I have no idea about what maintenance looks like. At 30 users you have no idea what maintenance looks like. That's literally what maintenance is - responding to real world usage. Come back with your experience when you have lots of users that stick with your app, you're putting out fires and implementing new features. Your experience will be meaningful after 6 months to a year. I'll wager that right now you have a PoC that needs a lot of work to be something that retains users. That's not a criticism, that's just how it works for every startup. > — [hologramofham on hackernews · 1 comments](https://news.ycombinator.com/item?id=50439633) > I have a similar position - maintainability of code written by AI no longer matters in any meaningful way, as as the models advance, one simply rewrites. At the current pace, the very idea of maintaining software will become as relevant as the idea of trimming wicks, stropping razors - or making every frame you take with a camera count. When the marginal cost of replacement drops to a sufficiently low level, the entire paradigm changes. I say this as someone with 30+ years of development experience, who built everything to be maintained until the heat death of the universe. I just don't think it's a relevant question in this brave new world. > — [madaxe\_again on hackernews · 1 comments](https://news.ycombinator.com/item?id=50439078) > > If you architect well what you generate then it stops being slop the problem is that the "architect well" part is also being left to the LLMs > — [insane\_dreamer on hackernews](https://news.ycombinator.com/item?id=50443282) > Step 2: Prompt the agent to comment out the "when" code and check if the tests fail. (If tests don't fail it's a poor test) Step 3: Prompt the agent to write mutation tests to harden the suite Step 4: Prompt the agent to write property-based tests. Step 5: Prompt the agent for 100% code coverage Step 6: Keep a look out for small issues with steps 2-5 above and refine a Skill or Rule to package the workflow and plug gaps in the model's current shortcomings. Step 7: Dedicate some time to manually reviewing and thinking about interesting edge cases worth testing. --- If you follow these steps, you will have better test coverage than 99.9% of any code an engineer ever wrote pre-AI... and it will be almost completely automated. My team's incidents and bugs are DOWN this year while we're shipping more. Leveraging AI effectively requires a new paradigm of interaction. The name of the game is to use techniques and strategies and guardrails that create an environment that produce good software. > — [drooby on hackernews · 1 comments](https://news.ycombinator.com/item?id=50439296) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=50438318) · 93 points · 293 comments ## Community discussion Top comments from developers on daily.dev. **@kartiknvj** · 0 upvotes > What makes the shallow-test problem so sticky for me is that line coverage stays green while it grows, so no dashboard ever flags it. I read the agent's test file before its diff now, since the coverage number will not say what never got asserted. And 90% generated being the minimum for a decent rating explains how review became the choke point you describe. ## Similar posts on daily.dev - [AI still needs humans](https://daily.dev/posts/ai-still-needs-humans-nml187ik0) · InfoWorld · 0 upvotes · 0 comments - [AI is Coding Us Into a Corner](https://daily.dev/posts/ai-is-coding-us-into-a-corner-xg52035q1) · DevOps.com · 0 upvotes · 0 comments --- Tags: [#testing](https://daily.dev/tags/testing), [#ai-coding](https://daily.dev/tags/ai-coding), [#technical-debt](https://daily.dev/tags/technical-debt) [View this post on daily.dev](https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"AI usage generates a fragile codebase","url":"https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9"},"datePublished":"2026-11-10T12:40:14.284Z","dateModified":"2026-11-10T18:11:39.323Z","description":"Heavy reliance on AI coding tools produces fragile, brittle codebases, a former Meta engineer argues. The author lists four causes: AI writes shallow tests...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/be4866f825b15b5374bbc58e6d67174d?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/be4866f825b15b5374bbc58e6d67174d?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":1,"discussionUrl":"https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":3},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":1}],"keywords":"testing,ai-coding,technical-debt","timeRequired":"PT7M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"AI usage generates a fragile codebase"}]} {"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9","comment":[{"@type":"Comment","text":"What makes the shallow-test problem so sticky for me is that line coverage stays green while it grows, so no dashboard ever flags it. I read the agent’s test file before its diff now, since the coverage number will not say what never got asserted. And 90% generated being the minimum for a decent rating explains how review became the choke point you describe.","datePublished":"2026-11-10T17:30:48.986Z","url":"https://daily.dev/posts/6EcxBInl9#c-fUFdJ2YE3","author":{"@type":"Person","name":"kartik-nvjk","url":"https://daily.dev/kartiknvj","image":"https://media.daily.dev/image/upload/s--3gGgsVCw--/f_auto/v1781456774/avatars/avatar_TvTVeiMdkRCqWUDullFmy?_a=BAMAMiWQ0"}}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/ai-usage-generates-a-fragile-codebase-6ecxbinl9#faq","mainEntity":[{"@type":"Question","name":"What are the main ways AI coding agents make a codebase fragile?","acceptedAnswer":{"@type":"Answer","text":"Four patterns stand out: AI writes shallow tests covering only trivial get/set methods or already-covered cases, it writes overly complex code by over-applying principles like DRY with unnecessary helper methods, heavy reliance erodes human developers' understanding of the codebase, and pull requests arrive faster than reviewers can properly scrutinize them, letting small quality issues accumulate into tech debt. Weigh these AI code-generation tradeoffs against your own team's review practices using discussions tracked on daily.dev."}},{"@type":"Question","name":"Do AI-generated codebases lead to more production incidents?","acceptedAnswer":{"@type":"Answer","text":"Yes, according to one engineer's experience at a large SaaS company: after a year or two of agentic coding, incidents escalated from occasional to happening nearly every weekend, and recovery took longer each time because developers had a shallower understanding of the code and had to dig through unfamiliar, poorly tested territory to find root causes. Track real-world reports like this to gauge whether agentic coding is worth the incident risk for your team, on daily.dev."}}]} ```