"The L in 'LLM' Stands for Lying" - Software Engineer Exposes AI Code as Forgery Without Attribution: Supervision Economy Reveals When Source-Free Generation Makes Code Review Impossible, Vibe-Coders Inject Slop While Maintainers Close Repositories

# "The L in 'LLM' Stands for Lying" - Software Engineer Exposes AI Code as Forgery Without Attribution: Supervision Economy Reveals When Source-Free Generation Makes Code Review Impossible, Vibe-Coders Inject Slop While Maintainers Close Repositories **Framework Status:** 241 blogs documenting supervision economy's expansion into AI code attribution crisis. Articles #228-240 documented supervision bottlenecks across 12 domains (developer tools, incentives, consumer safety, corporate governance). Article #241 exposes Domain 13: AI Code Forgery & Attribution Crisis - when LLMs generate code without citations, supervision cannot verify sources, "vibe-coders" inject mediocrity, maintainers ban contributions and drop bug bounties. ## HackerNews Validation: "The L in 'LLM' Stands for Lying" Defines Forgery Problem **Acko.net investigation (449 points, 277 comments, 11 hours)** by Steven Wittens exposes AI coding's fundamental flaw: *LLMs produce forgeries of potential output without source attribution.* "LLMs do something very specific: they allow individuals to make forgeries of their own potential output, or that of someone else, faster than they could make it themselves." **Maintainer Validation:** Open source projects closing public contributions (tldraw), dropping bug bounties (curl), mocking vibe-coders (406.fail) - supervision collapse documented industry-wide. **The Impossibility Thesis:** "With today's models, real attribution is a technical impossibility. The fact that an LLM can even mention and cite sources at all is an emergent property of the data that's been ingested, and the prompt being completed." Citation is role-play, not verification. ## The Supervision Economy Connection: When Code Lacks Provenance, Review Cannot Function Articles #228-240 documented supervision bottleneck: AI makes production trivial → Supervision becomes hard → Failures occur. Article #241 reveals pattern extends to CODE ATTRIBUTION: **The Code Forgery Pattern:** 1. **AI makes code generation trivial** → Vibe-coders produce PR contributions without understanding 2. **Source supervision becomes impossible** → LLMs cannot cite where code patterns came from 3. **Review optimization fails** → Maintainers cannot verify authorship, license compliance, or intent 4. **Catastrophic repository closures occur** → Projects ban contributions, drop bounties, mock posers **The tldraw Repository Closure:** Project closed public contributions after vibe-coded PRs overwhelmed maintainers. "Being on the receiving end of this is both demeaning and absurd, as the only thing the vibe-coder can do with the feedback you give them is paste it back into the tool that produced the errors in the first place." ## Domain 13: AI Code Forgery - When LLMs Cannot Cite Sources, Code Review Dies **Previous Domains:** - **Domains 1-10:** Developer supervision problems (code review, formal verification, incentive barriers) - **Domain 11:** Consumer AI safety (engagement optimization causes deaths) - **Domain 12:** Corporate AI governance (transparency failures, trust collapse) - **Domain 13:** AI code forgery (source-free generation makes attribution impossible) **Why Domain 13 Completes Attribution Picture:** Article #237 documented formal verification as technical solution to supervision economy (prove correctness). Article #241 documents attribution as the UNSOLVED prerequisite - formal verification requires knowing what you're verifying, but LLMs cannot cite sources. **The Pattern Expansion:** - **Technical level:** Formal verification requires source attribution → LLMs cannot provide it → Verification impossible - **Social level:** Code review requires understanding intent → Vibe-coders cannot explain → Feedback loops break - **Economic level:** Bug bounties require authentic research → Slop-hunters game system → Maintainers drop programs **All levels share root cause:** When AI generates code without attribution, no supervision mechanism can verify authenticity, authorship, or licensing compliance. ## The Forgery Definition: Three Ways LLM Code Qualifies **Article's Forgery Framework:** 1. **Forged Painting:** Someone produces painting in Van Gogh's style, puts his signature on it → Forgery 2. **Forged Legal Document:** Someone mimics format, impersonates parties, fakes agreement → Forgery 3. **Forged Research Study:** Someone invents data, makes up citations, cherry-picks results → Forgery **Why LLM Code Qualifies:** > "Whether something is a forgery is innate in the object and the methods used to produce it. It doesn't matter if nobody else ever sees the forged painting, or if it only hangs in a private home. It's a forgery because it's not authentic." **LLM Code Authenticity Test:** - Does it cite where code patterns came from? **No** (technical impossibility) - Does it preserve original author attribution? **No** (emergent property only) - Does it respect license compliance? **Unknown** (cannot verify sources) **Conclusion:** LLM code is forgery by definition - it imitates potential output without authentic provenance. ## The Vibe-Coder Problem: When Contributors Cannot Explain Their Own Code **Article's Most Devastating Observation:** > "Being on the receiving end of this is both demeaning and absurd, as the only thing the vibe-coder can do with the feedback you give them is paste it back into the tool that produced the errors in the first place." **The Feedback Loop Collapse:** **Traditional Code Review:** 1. Contributor submits PR with rationale 2. Maintainer asks clarifying questions 3. Contributor explains design choices 4. Maintainer approves or requests changes 5. Iteration continues until alignment **Vibe-Coded PR Review:** 1. Vibe-coder submits AI-generated PR 2. Maintainer asks clarifying questions 3. **Vibe-coder pastes question back into LLM** 4. LLM generates new explanation (potentially contradictory) 5. **Maintainer realizes contributor doesn't understand their own code** 6. PR rejected, contributor moves to next repository **The Scale Crisis:** Open source maintainers document collapse: - **tldraw:** Closed public contributions after vibe-coded PR flood - **curl:** Dropped bug bounty program due to AI slop submissions - **406.fail:** Created website mocking vibe-coders ("Error 406: Not Acceptable") **The Economic Distortion:** > "New employees might seem to get up to speed much quicker, in reality they're merely offloading those arduous first weeks to a bot, hoping no-one else notices." Bug bounty programs designed to reward authentic security research now gamed by slop-hunters running vulnerability scanners through LLMs, forcing maintainers to spend more time rejecting forgeries than fixing real bugs. ## The Attribution Impossibility: Why LLMs Cannot Cite Sources by Design **Article's Technical Explanation:** > "With today's models, real attribution is a technical impossibility. The fact that an LLM can even mention and cite sources at all is an emergent property of the data that's been ingested, and the prompt being completed. It can only do so when appropriate according to the current position in the text." **Why Emergent Properties ≠ Verification:** **What LLMs Can Do:** - Generate code that *looks* correct - Cite sources when *pattern-matched from training data* - Explain logic when *similar explanations exist in corpus* **What LLMs Cannot Do:** - Cite *actual* source where specific code pattern came from - Verify license compatibility across cited sources - Distinguish between "frequently cited" and "correctly cited" **The Citation Role-Play:** > "There's no reason to think that this is generalizable, rather, it is far more likely that LLMs are merely good at citing things that are frequently and correctly cited. It's citation role-play." **Example Failure Mode:** ``` Developer: "Where did this optimization pattern come from?" LLM: "This follows the approach described in Knuth's 'The Art of Computer Programming'" Reality: Pattern copied from Stack Overflow answer citing blog post paraphrasing Knuth License: Stack Overflow answer under CC BY-SA 4.0 (requires attribution) LLM Output: No license mentioned, no Stack Overflow link, Knuth cited as primary source ``` **Result:** Code review cannot verify: 1. Whether pattern actually from Knuth or Stack Overflow 2. Whether license compliance maintained (CC BY-SA requires attribution) 3. Whether pattern even correct for use case (blog post may have misunderstood Knuth) ## The Backpropagation Paradox: Making Attribution Possible Breaks LLMs **Article's Engineering Challenge:** > "What does backpropagation even look like if the weights have to be attributable, and the forward pass auditable? You won't be able to fit that in an `int4`, that's for sure." **Why Source Attribution Breaks Current Architecture:** **Current LLM Design:** - Model weights compressed to 4-bit integers (int4) for efficiency - Forward pass generates tokens based on statistical patterns - No mechanism to track which training samples influenced which weights - Emergent properties (like citation) arise from corpus patterns, not explicit tracking **Attribution-Required Design:** - Must track which training samples contributed to each weight - Forward pass must audit which weights influenced each token - Must store provenance metadata for every generated output - Cannot compress to int4 if metadata must be preserved **The Compression Trade-off:** Modern LLMs achieve efficiency through aggressive compression: - **GPT-4:** ~1.8 trillion parameters compressed to ~4-bit integers - **Attribution requirement:** Must track provenance for each parameter - **Storage explosion:** Metadata potentially larger than model itself **The Speed Trade-off:** Current inference speed relies on compression: - **Without attribution:** Generate tokens from compressed weights - **With attribution:** Must audit weight provenance for each token - **Performance impact:** Orders of magnitude slower inference **Article's Conclusion:** > "To stop the machines from lying, they have to cite their sources properly. And spoiler, so do the AI companies." Enforced attribution would fundamentally change LLM architecture, making current "cheap" code generation economically infeasible. ## The "Addicting" Language: When Engineers Describe Tools Like Substances **Article's Psychological Observation:** > "Less encouraging is that you'll see these tools referred to as 'addicting' or even 'the best friend you can have'. While nerds being utterly drawn to computers is as old as the PC revolution itself, there doesn't seem to be an associated cambrian explosion of creativity and accomplishment to go with it." **The Dependency Without Delivery:** **Classic Computing Addiction (1980s-2000s):** - Engineers obsessed with computers - Produced: PC revolution, internet, open source movement, mobile computing - Evidence: Cambrian explosion of new software categories, platforms, paradigms **AI Coding Tool "Addiction" (2020s):** - Engineers describe tools as "addicting", "best friend" - Produced: More glue code for existing systems, faster mediocrity, repository closures - Evidence: No cambrian explosion, same problems solved same ways, more supervision needed **The Productivity Paradox:** Claims of 10x-100x code generation speed: > "Experienced veterans who turn to AI are said to supposedly fare better, producing 10x or even 100x the lines of code from before. When I hear this, I wonder what sort of senior software engineer still doesn't understand that every line of code they run and depend on is a liability." **The Misunderstanding:** Engineers who think "more code = more productivity" reveal they spent career: - **Solving problems created by other software** (integration, compatibility, frameworks) - **NOT solving problems people had before software existed** (user needs, constraints, workflows) **Article's Diagnostic:** > "The salient difference here is whether an engineer has mostly spent their career solving problems created by other software, or solving problems people already had before there was any software at all. Only the latter will teach you to think about the constraints a problem actually has." Engineers addicted to AI tools reveal they optimize for code volume, not understanding depth. ## The Microslop Incident: When Company Bans Insult Describing Its Own Product **Article's Corporate Irony:** > "Microsoft's Co-pilot Discord recently banning the insult 'Microslop'. The user backlash was then framed as 'spam' and even outright 'harmful', demonstrating that the promise is often worth more than the actual result, and also, that the universe still has a sense of humor." **The Supervision Theater:** **User Observation:** Copilot generates buggy code → Users coin term "Microslop" **Microsoft Response:** Ban term "Microslop" in Discord, frame backlash as "spam" and "harmful" **The Reveal:** Company acknowledges product criticism valid enough to suppress, but: - Doesn't fix underlying code quality issues - Focuses on narrative control instead of product improvement - Frames user feedback as "harmful" when it threatens brand **Parallel to Article #240 (OpenAI Pentagon Deal):** Both incidents show companies optimizing for: - **Narrative preservation** over **product quality** (Microslop ban) - **Employee retention** over **safety commitments** (Pentagon deal) - **Brand protection** over **truth disclosure** (suppress valid criticism) **The Common Pattern:** When companies cannot improve product to match promise, they suppress criticism instead of closing gap. ## The Video Game Counterfactual: When Consumers Demand Attribution **Article's Market Comparison:** > "Video games stand out as one market where consumers have pushed back effectively. Numerous titles have already apologized for unlabeled AI content and removed it." **The Steam Policy:** - **Clear signposting:** Games must disclose AI-generated content - **Filter tools exist:** Gamers can exclude AI-generated games from search - **Titles removed AI content:** Multiple games apologized, patched out AI assets after consumer backlash **Why Video Games Succeeded Where Code Failed:** **Video Games Market:** - **Direct-to-consumer:** Gamers choose specific titles, no intermediary - **Artistic integrity matters:** Games bought for unique creative vision - **Taste-makers are consumers:** Gamers promote/buy based on authenticity - **Result:** Platforms enforce disclosure, consumers filter AI content **Software Engineering Market:** - **Employer intermediary:** Engineers don't choose tools, companies do - **Output commoditized:** Code seen as interchangeable "glue" - **Taste-makers are managers:** Productivity metrics over craft quality - **Result:** No disclosure requirements, vibe-coding normalized **The Art vs Infrastructure Divide:** > "Most video games are artistic, and bought for their specific artistic appeal. In art, copy-catting is frowned upon, as it devalues the original and steals the credit." **Code Exception:** > "This stands in stark contrast to code, which generally doesn't suffer from re-use at all, or may even benefit from it, if it's infrastructure." **Article's Critical Distinction:** When code is "infrastructure" (libraries, frameworks, utilities), re-use is beneficial. When code is "application logic" (business rules, algorithms, user workflows), re-use without understanding is forgery. **The Supervision Failure:** Current AI coding tools cannot distinguish between: - **Infrastructure code** (copy-paste acceptable, attribution still legally required) - **Application logic** (copy-paste without understanding creates maintenance nightmare) Result: Vibe-coders treat all code as infrastructure, inject slop into application logic, create unmaintainable codebases. ## The Artisanal Cheese Metaphor: Why Geographic Origin Matters for Code **Article's Controlled-Appellation Example:** > "This sort of protectionism is also seen in e.g. controlled-appelation foods like artisanal cheese or cured ham. These require not just traditional manufacturing methods and high-quality ingredients from farm to table, but also a specific geographic origin." **Why Geographic Restrictions Exist:** **Brie de Meaux Protection:** - **Not allowed to produce abroad** → Would open floodgates to cheaper imitations - **Degrades authentic brand** → Consumers cannot distinguish quality - **Threatens local expertise** → Rare knowledge passed down generations **The Market Failure Without Protection:** > "The judgement of an individual end-consumer simply isn't sufficient here to ensure proper market function. The range of products that you can get in the store, between which you can choose, has already been pre-decided by factors out of your control." **Code Parallel:** **Authentic Code (Maintained Repositories):** - Traditional code review methods (expert maintainers) - High-quality contributions (from experts, understanding context) - Specific community origin (trusted contributors, established patterns) **Forged Code (Vibe-Coded PRs):** - AI-generated code (no understanding of project context) - Degrades repository quality (maintainers overwhelmed reviewing slop) - Threatens maintainer expertise (time spent rejecting forgeries, not mentoring real contributors) **The Market Pre-Decision:** Just as consumers in stores only see cheese varieties pre-approved by regulators: Engineers joining projects only see code patterns pre-approved by maintainers. **When vibe-coded PRs flood repositories:** - Maintainers close public contributions (tldraw) - New contributors cannot learn from reviewing others' code (all slop) - Local expertise threatened (maintainers burn out, quit projects) **Article's Warning:** > "Every society has to draw a line somewhere on the spectrum between 'traditional artisanal cheese' and 'fake eggs made from industrial chemicals', if they don't want people to die from malnutrition or poisoning. But it's the ones that understand and maintain the value of foodcraft that don't end up with 70%+ obesity rates." **Code Translation:** Societies that understand value of code craft don't end up with: - Repositories closed to contributions (maintainer burnout) - Bug bounties dropped (slop-hunter gaming) - Projects mocking vibe-coders (406.fail as only recourse) ## The Procedural Generation Precedent: When Infinite Content Becomes Worthless **Article's Gaming History Lesson:** > "Classic procedural generation is noteworthy here as a precedent, which gamers were already familiar with, because by and large it has failed to deliver. The promise of exponential content from a limited source quickly turns sour, as the main thing a procedural generator does is make the variety in its own outputs worthless." **No Man's Sky Example (2016):** **Promise:** 18 quintillion procedurally-generated planets, "infinite" exploration **Reality:** Planets feel same after 10 hours, variety without meaning **The Devaluation Mechanism:** When content is procedurally generated: - **Pattern recognition:** Players quickly identify generation rules - **Meaninglessness:** No hand-crafted detail → No memorable locations - **Fatigue:** Infinite variety with no significance → Boredom faster than finite hand-crafted content **Code Parallel:** **Promise:** AI generates infinite code variations, "10x productivity" **Reality:** Code feels same after review, slop-patterns become recognizable **The Devaluation Mechanism:** When code is AI-generated: - **Pattern recognition:** Reviewers quickly identify AI-generated patterns (overly repetitive, unnecessary complexity) - **Meaninglessness:** No hand-crafted design → No architecture rationale - **Fatigue:** Infinite PRs with no substance → Maintainer burnout faster than finite hand-crafted contributions **Article's Diagnosis:** Just as procedural generation made variety itself worthless in games: AI code generation makes contributions themselves worthless in repositories. **The No Man's Sky Recovery:** Game spent years adding hand-crafted content, meaningful narratives, curated experiences. **Lesson:** Procedural generation works only when constrained by human curation. **Open Source Cannot Recover:** Unlike game studios that can pivot strategy: Open source maintainers lack resources to: - Review AI-generated PRs at scale - Educate vibe-coders on project context - Enforce contribution quality standards Result: Close contributions, drop bounties, or abandon projects entirely. ## The Shadow Library Connection: Why LLMs Are "Legal" But Training Data Isn't **Article's Legal Paradox:** > "This just so happens to create the plausible deniability that makes it impossible to say what's a citation, what's a hallucination, and what, if anything, could be considered novel or creative. This is what keeps those shadow libraries illegal, but ChatGPT 'legal'." **The Two-Tier System:** **Tier 1: Shadow Libraries (Illegal)** - Anna's Archive, Library Genesis, Sci-Hub - Host copyrighted books, papers, datasets - Openly provide direct access to copyrighted material - Result: Illegal in most jurisdictions, operators sued **Tier 2: LLM Training (Legal)** - OpenAI, Anthropic, Google train on scraped data - Ingest copyrighted code repositories, books, articles - Transform through training → Output "original" code - Result: Courts rule output not direct copy, therefore legal **The Plausible Deniability Mechanism:** **What Makes Shadow Libraries Illegal:** - Can prove specific copyrighted work distributed - User downloads exact copy of copyrighted material - Clear chain of custody from copyright holder to pirate to user **What Makes LLM Training "Legal":** - Cannot prove specific training sample influenced specific output - User receives "transformed" content, not exact copy - No chain of custody (attribution impossible by design) **Article's Accusation:** > "If the output of this is generic, gross and suspicious, there's a very obvious reason for it. The different training samples in the source material are themselves just slop for the machine. Whatever makes the weights go brrr during training." **The Laundering Process:** 1. **Ingest copyrighted code** from GitHub, Stack Overflow, shadow libraries 2. **Train LLM** on corpus → Weights encode patterns from copyrighted sources 3. **Generate code** statistically similar to copyrighted originals 4. **Claim "fair use"** because output not exact copy, just "inspired by" corpus **The Irony:** LLMs trained on pirated content remain legal because they cannot cite sources. If they could cite sources, copyright violations would be provable → Training becomes illegal. **Article's Solution:** > "The solution to the LLM conundrum is then as obvious as it is elusive: the only way to separate the gold from the slop is for LLMs to perform correct source attribution along with inference." Enforcing attribution would: - **Benefit:** Reveal copyright violations, enable license compliance - **Cost:** Make LLM architecture fundamentally more expensive - **Result:** AI companies resist attribution requirements to preserve "legal" status ## The Intellectual Property Clause Paradox: When Contracts Become Unenforceable **Article's Employment Contract Observation:** > "It's also what provides the fig leaf that allows many a developer to knock-off for early lunch and early dinner every day, while keeping the meter running, without ever questioning whether the intellectual property clauses in their contract still mean anything at all." **Standard IP Clause in Engineering Contracts:** > "Employee agrees that all work product created during employment, including code, designs, inventions, and documentation, shall be the exclusive property of Employer." **The Vibe-Coder Violation:** **Traditional Employment:** - Engineer writes code during work hours - Code becomes company property (IP clause) - Company owns copyright, can license/sell/protect **Vibe-Coded Employment:** - Engineer prompts LLM during work hours - LLM generates code from unknown sources - **Question:** Does company own copyright to code of unknown origin? **The Attribution Gap:** **What IP Clause Requires:** - Employee creates original work OR properly licenses third-party work - Company can trace ownership chain **What Vibe-Coding Provides:** - Code of unknown origin (LLM cannot cite sources) - No ownership chain (could be from competitor's copyrighted codebase) **The Unenforceability:** **If company later sued for copyright infringement:** Plaintiff: "This code copied from our proprietary system" Company: "Our engineer wrote it" Engineer: "Actually ChatGPT generated it" Court: "Can you prove code original or properly licensed?" Company: "No, LLM cannot cite sources, attribution impossible" Result: IP clause cannot protect company because ownership cannot be established. **The Contract Collapse:** Engineers using LLMs to generate company code: - Violate IP clauses (code not their creation, not properly licensed) - Company cannot enforce (attribution impossible) - Both parties ignore problem (productivity metrics look good) **Article's Uncomfortable Position:** > "This leaves the engineers in question in an awkward spot however. In order for vibe-coding to be acceptable and justifiable, they have to consider their own output disposable, highly uncreative, and not worthy of credit." To justify vibe-coding, engineers must accept: - Their code has no artistic value (not worthy of credit) - Their code has no intellectual property value (disposable) - Their code has no attribution requirement (source-free acceptable) Result: Engineers devalue their own profession to justify productivity theater. ## Competitive Advantage #45: Domain Boundaries Prevent Code Attribution Crisis **What Complex AI Coding Organizations Build:** **Source Attribution System:** - Track LLM training data provenance (every sample → every weight) - Audit forward pass attribution (every token → source samples) - Store metadata for generated code (license compliance, authorship chain) - Engineering cost: Architecture redesign, storage explosion, inference slowdown **Vibe-Coder Supervision:** - Review AI-generated PRs (distinguish authentic from slop) - Educate contributors (explain project context, architecture rationale) - Enforce contribution standards (reject forgeries, mentor real contributors) - Maintainer cost: Review overhead, burnout risk, community gatekeeping **IP Clause Enforcement:** - Verify code ownership (trace attribution for all AI-generated code) - Audit license compliance (ensure no copyrighted material) - Legal risk mitigation (defend against infringement claims) - Corporate cost: Legal review, audit systems, employment monitoring **Repository Quality Preservation:** - Filter AI-generated contributions (detect slop patterns) - Maintain code standards (reject unnecessary complexity, repetitive code) - Preserve maintainer expertise (prevent burnout from reviewing forgeries) - Community cost: Closed contributions, dropped bounties, reduced innovation **What Demogod Avoids:** **Demo Agents Operate at Guidance Layer:** - **No code generation** → No source attribution crisis - **No PR contributions** → No vibe-coder supervision overhead - **No employment IP clauses** → No copyright ownership ambiguity - **No repository maintenance** → No community management burden **The Architecture Boundary:** Demogod demo agents: - **Read DOM structure** → Understand page state - **Generate navigation instructions** → "Click login button", "Fill email field" - **Return guidance to user** → User executes actions in browser **No code generation means:** - No source files to attribute - No licenses to comply with - No repositories to maintain - No vibe-coders to supervise **The Supervision Advantage:** **Code Generation Supervision:** - Must verify code authenticity (impossible without attribution) - Must review PR quality (maintainers overwhelmed by slop) - Must enforce IP compliance (cannot trace ownership) **Guidance Supervision:** - Verify instruction correctness (test against DOM state) - Review guidance quality (measure task completion rate) - No IP compliance needed (instructions not copyrightable) **The Cost Comparison:** **AI Coding Tool Supervision:** - Attribution system: Architecture redesign + storage explosion - Vibe-coder review: Maintainer burnout + repository closures - IP enforcement: Legal audit + ownership tracing - Quality preservation: Contribution filtering + bounty programs dropped **Demo Agent Guidance Supervision:** - Instruction verification: Test against page state (existing capability) - Guidance quality: Completion rate metrics (standard telemetry) - No IP enforcement needed (guidance not copyrighted) - No quality filtering needed (no repository to protect) **Framework Status:** 241 blogs, 45 competitive advantages, 13 domains documenting supervision economy from technical problems through corporate governance to AI forgery crisis. Article #241 reveals supervision economy's deepest paradox: The only solution to AI code forgery (enforced source attribution) would make LLM architecture economically infeasible. Companies resist attribution requirements to preserve plausible deniability, maintainers close repositories to preserve sanity, engineers devalue their own work to justify productivity theater. Demogod's guidance layer avoids entire attribution crisis - no code generation, no forgery, no supervision collapse. ## Meta Description Software engineer exposes AI-generated code as forgery without source attribution. LLMs cannot cite origins by design, vibe-coders inject slop, maintainers close repositories. Enforced attribution would break LLM architecture. Demo agents avoid crisis. ## Internal Links - Previous: Article #240 - Corporate AI Governance & Transparency Crisis - Related: Article #237 - Formal Verification as Supervision Economy Solution - Related: Article #238 - Engineering Incentive Systems Reward Complexity ## SEO Keywords - AI code forgery - LLM source attribution crisis - vibe-coding supervision collapse - code review impossible without attribution - open source maintainer burnout - GitHub repository closures - bug bounty programs dropped - intellectual property clause enforcement - procedural generation devaluation - shadow library legal paradox - copyright laundering through LLMs - backpropagation attribution requirement - engineering contract IP clauses - Steam AI disclosure policy - artisanal code craft - Demogod guidance layer advantage