--- title: advanced-context-engineering-for-coding-agents/wsff.md... description: A deep-dive opinion piece arguing that fully automated 'lights-off' software factories fail because current AI coding models cannot maintain codebase quality... canonical: https://daily.dev/posts/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: advanced-context-engineering-for-coding-agents/wsff.md at main · humanlayer/advanced-context-engineering-for-coding-agents | daily.dev og:description: A deep-dive opinion piece arguing that fully automated 'lights-off' software factories fail because current AI coding models cannot maintain codebase quality... og:url: https://daily.dev/posts/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i og:image: https://api.daily.dev/og/posts/Ydc9AY02I.png og:image:alt: advanced-context-engineering-for-coding-agents/wsff.md at main · humanlayer/advanced-context-engineering-for-coding-agents 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. # advanced-context-engineering-for-coding-agents/wsff.md at main · humanlayer/advanced-context-engineering-for-coding-agents **[Hacker News](https://daily.dev/sources/hn)** · 31 min read · 1 upvotes · 1 comments ## Summary A deep-dive opinion piece arguing that fully automated 'lights-off' software factories fail because current AI coding models cannot maintain codebase quality over time — a limitation rooted in how they are trained (pass/fail benchmarks with no penalty for bad architecture). The author draws on personal experience running a lights-off factory that ended in rewrites, explains why RL training on SWE-bench-style tasks can't teach maintainability, and proposes a structured human-in-the-loop workflow: Product Requirements → System Architecture → Program Design → Vertical Slices. The core thesis is that humans must stay in the loop for design decisions, and that front-loading alignment (like pre-AI teams always did) is the key to moving fast without accumulating slop. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Community take How the wider developer community reacted, aggregated from 1 discussion and 318 comments across hackernews (as of 2026-07-24). **TL;DR:** The community is broadly skeptical of fully autonomous "lights-off" AI software factories, agreeing that code maintainability, design taste, and human oversight remain critical gaps—though some argue models have improved enough since 2025 to change the calculus. **Sentiment:** 20% positive · 45% mixed · 35% skeptical **The case for** - High-discipline, high-hygiene teams already see real productivity gains from AI coding agents. - AI agents are excellent for low-stakes, small-scope tasks like scripts and hobby projects. - Deterministic tools (tests, linters) combined with agents can raise the quality floor meaningfully. - Newer frontier models (post-Opus 4.5) represent genuine step-changes in agentic capability. **The pushback** - Agents consistently produce large, hard-to-review PRs that lack narrative structure and mix unrelated changes. - LLMs cannot do long-term architectural planning, leading to codebases that degrade over time without human steering. - There is no fast oracle or verifier for code maintainability, making RL-based improvement very difficult. - Automating code review to circumvent company policy undermines knowledge sharing, compliance (e.g. SOX), and accountability. - Agents generate verbose "what" comments instead of "why" comments, reducing rather than improving code clarity. - Even with good prompts, agents miss obvious optimizations (e.g. data already available client-side) and add unnecessary complexity. **By community** - hackernews (mixed): Commenters are split between those who see real but bounded value in agentic coding and those who argue lights-off autonomy is premature and actively harmful to codebase health. **Hottest debate:** Whether automating PR review with an LLM agent (without human involvement) is a reasonable productivity hack or a fireable offense that undermines the core purposes of code review. **Open questions** - Is there any fast, reliable oracle or verifier for code maintainability that could enable RL training for good design? - At what point (if ever) do model improvements outpace the rate of codebase degradation in fully autonomous workflows? - How should teams structure agent workflows to produce small, reviewable, story-driven PRs rather than large undifferentiated diffs? - What happened concretely with StrongDM's dark factory experiment—what worked and what didn't? **Highlights** > Before LLMs, "organizations" have seen code review as multiple things: * Share knowledge about a particular area of the codebase between multiple people * Share overall engineering knowledge between the parties in the review * Ensure maintainability of the codebase long-term * Ensure readability of the code * Catch architectural/directional omissions (yes, from the planning/architecture phase) before it's really too late and non-reversible change goes in (eg. large destructive DB schema change) * Ensure changes are small, self-contained, and as often as possible, reversible * Do some basic manual QA * Do comprehensive integration testing with a fully built-out system ... * And yes, catch bugs before they hit production. A lot of the above could be fun and engaging, and especially knowledge sharing and ensuring maintainability/readability was a very motivating thing for me as a more experienced engineer having learned so much from getting good reviews when I was less experienced. Programmers care about style to ensure readability and thus maintainability of the code, but also to keep changes minimal — if every diff converted between tabs and spaces in the entire codebase, it'd be impossible to see what has really changed with the simple tooling we generally use (one could build diffing tools that ignore changes like these, and they even exist, but are not ubiquitous). > — [necovek on hackernews](https://news.ycombinator.com/item?id=49027326) > fair point, this is the thing I struggled most to extract out while writing it - if you can propose an RL environment that penalizes a model for bad design, then I'm all ears - right now there's no fast oracle/verifier for this (as stated in the post) My current evolving take on "how would you build such a thing" is you need to tee up a roadmap of 20 features and feed them to a model one at a time, so it can't design up front for what's coming. That way if it builds the first 10 features and the codebase goes to slop, it get's penalized when it can't build features 11-20, or when those features take wayyy more tokens/time/cycles than a model that maintains a clean codebase can do. This is how most real software is built by most teams - incrementally, getting feedback from users along the way, and steering goals in response. > — [dhorthy on hackernews · 2 comments](https://news.ycombinator.com/item?id=49026254) > Gating integration behind code review is futile. I (and many other engineers) already automated it. My agent responds to review requests and reviews as me. Company policies enforcing human code review are futile. I think all these platforms chasing code review are doomed. My LLM doesn't need any of this tooling. We should be reviewing the actual working software. Systems that make it easy and instant to demo any proposed change are what is needed. Code (and specs) are going to fade into obscurity. PR review has already shifted towards validating the product (working software) over the process (code). The future of software production is more like Replit – not GitHub. > — [4lx87 on hackernews · 9 comments](https://news.ycombinator.com/item?id=49025865) > PR review sucks because engineers often don't optimise their code authoring for it. When they do it's a joy. PR review of agent generated code sucks because agents are, in my experience, very poor at authoring for review. This makes sense because the review process is not represented in the resulting code artifact which is what they're trained on. Agents are always producing much larger changes than should be in a single step, and often touch unrelated code with poor judgement of whether it should be included or not. > — [danpalmer on hackernews · 3 comments](https://news.ycombinator.com/item?id=49029767) > > In my experience, managers enforce code review as a quality control mechanism: the "Find Bugs" step in the article's pyramid. Nope. To reduce it down to a single word, I'd say we do code-reviews to assess "taste". ----- Code-review is one part of a larger process (the SDLC!), and while review does help with "finding bugs" it is not the singular reason why we do it; and other parts of the SDLC are concerned with finding bugs in the first place, namely the various Test and QA steps in the process; when your code is in the (peer) code-review step then there's an expectation that the author already identified and resolved actual bugs/defects (i.e. where actual-program-behaviour deviates from the spec[1]), so a PR for new functionality is expected to include unit and integration tests to demonstrate that. Now Claude will gladly take a Jira ticket, write-up a plan/spec, write tests, implement the feature, verify the tests pass, address static-analysis issues, push branch, and submit the PR - and if-the-program-works then it's "correct" and so surely there's nothing really to review and so merging the changes should be a breeze... but I find myself rejecting these PRs all the time because these agents still "just don't get it"[2]. (But I'm sure they'll "get it" eventually; you can't stop progress). We can revisit this topic when we get there; but for now I'm going to reject an AI-authored PR that eschews it. Good taste is important. [1] I'm not going to pretend anyone actually writes any kind of spec (informal or otherwise) for the vast majority of software out there; but an unwritten-spec exists when you mentally combine a vague Jira ticket, platform-conventions and common-sense (and that's how Claude in an Agentic Loop works too, except it always has to write-out the Spec.md/Plan.md to disk first, whereas us humans keep things in our head). [2] I cannot define "it". > — [DaiPlusPlus on hackernews](https://news.ycombinator.com/item?id=49027584) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=49023019) · 142 points · 318 comments ## Similar posts on daily.dev - [Why software factories fail without humans \| HumanLayer, Warp & LinearB](https://daily.dev/posts/why-software-factories-fail-without-humans-humanlayer-warp-linearb-7ibpnjxgn) · Dev Interrupted · 0 upvotes · 0 comments - [Human judgment doesn't leave the software factory. It relocates.](https://daily.dev/posts/human-judgment-doesn-t-leave-the-software-factory-it-relocates--en1s61adq) · Addy Osmani · 9 upvotes · 1 comments - [Forget humans “in” the loop. Harness engineering puts humans “on” the loop.](https://daily.dev/posts/forget-humans-in-the-loop-harness-engineering-puts-humans-on-the-loop--ppbifzl84) · The New Stack · 2 upvotes · 0 comments --- Tags: [#ai-agents](https://daily.dev/tags/ai-agents), [#reinforcement-learning](https://daily.dev/tags/reinforcement-learning), [#context-engineering](https://daily.dev/tags/context-engineering) [View this post on daily.dev](https://daily.dev/posts/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i) ```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":"advanced-context-engineering-for-coding-agents/wsff.md at main · humanlayer/advanced-context-engineering-for-coding-agents","url":"https://daily.dev/posts/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i"},"datePublished":"2026-07-23T18:25:21.441Z","dateModified":"2026-07-24T06:49:45.573Z","description":"A deep-dive opinion piece arguing that fully automated 'lights-off' software factories fail because current AI coding models cannot maintain codebase quality...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/a9d9e736c9eaa2d07e5c01ef30d4be09?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/a9d9e736c9eaa2d07e5c01ef30d4be09?_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/advanced-context-engineering-for-coding-agents-wsff-md-at-main-humanlayer-advanced-context-enginee-ydc9ay02i","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":1}],"keywords":"ai-agents,reinforcement-learning,context-engineering","timeRequired":"PT31M"} {"@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":"advanced-context-engineering-for-coding-agents/wsff.md at main · humanlayer/advanced-context-engineering-for-coding-agents"}]} ```