返回资讯中心
外部精选
软件工程
#开发者实时流

The Pull Request Needs to Die by Ethan Knox

republished from pirate.baby, my tech and near-tech blog

Hacker News 最新nikhilol2026/10/20 · 26 天前30 分钟阅读

以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。

Claude Code

Software Engineering

Software Development

Agentic

The Pull Request Needs To Die

Ethan Knox

15 min read·

Feb 17, 2026

--

republished from pirate.baby, my tech and near-tech blog

This month marks one year of ubiquitous agentic coding in the software world. Early adopters may have dabbled with pre-harness harnesses (remember Cursor? Github Copilot?) going all the way back to 2021, but agentic coding as we know it was really birthed late February of 2025 with the launch of Claude Code.

I struggle to find an accurate historical analog for the rapidity and completeness in which agentic coding has resequenced Software Engineering’s DNA; the cliche’ analogy of horse => automobile is useless here — that transition took nearly half a century. I don’t dare to contemplate what another twelve months at this pace of change will bring us.

A year is long enough to identify patterns that must be capitalized on or corrected. I am by no means the first person to make the case that our traditional software SDLC — a lone developer building a feature branch, then a pull request, and finally an open-ended team code review — is ill-suited for agentic development. The tools of the trade (most notably GitHub) are failing miserably to evolve with the industry. What I’d like to do here is look at where I think the traditional SDLC goes beyond a poor fit and has actually evolved into a primary source of pain; slowing delivery, eliminating code socialization, promoting lower-quality software while encouraging the worst habits of Software Engineers. The Pull Request isn’t just misaligned with agentic coding, it has become our appendix — a now useless reminder of our collective past, transformed into a sack of life-threatening toxins that cripples the body of modern software engineering.

Our traditional SDLC was more than just a mechanical procedure for outputting software, it was an unofficial set of guardrails that aligned teams on what defined a “good Engineer.” Much of our definition centered around a single fundamental truth: creation was always higher friction than consumption. The time, effort and mental energy required to write code (even very bad code), then author documentation, then update Jira tickets, and then of course spell out details in a Pull Request description was always significantly greater than the corresponding effort to review, read, and assimilate all that content. Take the Patagonia 5–15 report as an easy baseline — fifteen minutes of natural language content creation was expected to take about five minutes to consume, so effectively a 3:1 ratio. This ratio also dictated an unspoken contract between creator and consumer; ‘However much investment I am asking from you, I have already committed at least 3x that much effort in creation.` Social contracts between development teams were codified as nuance in the PR process. In a tight-knit bootstrap startup, PR rules could be lax because trust and mutual investment was so high. Likewise, a corporate engineering team was likely to enact exhaustive rules for everything — the format of commit messages, the structure of PR descriptions and links to Jira issues, the frequency, granularity, case and meter of ADR entries, and of course the scope and impact of code changes. Why? For the same reason Van Halen legendarily demanded tour venues provide them “M&Ms, with all the brown ones removed.” Tedium and friction ensured attention to detail in low-trust environments; Van Halen wanted to know if a venue read the contract before trusting them with pyrotechnics on the stage, and corporate software teams wanted to make sure developers stood behind the changes they proposed with a significant up-front investment. It didn’t always work, but the additional creative friction served a purpose all the same.

Agentic tools have not just flipped that effective 3:1 ratio, they have obliterated it. A creator can easily spin up a dozen worktrees against a dozen Linear tasks, and in fifteen minutes generate all the compliant code, documentation, commit messages, and Pull Requests that will take a consumer several hours to properly review. 3:1 has evolved into something more like 1:12, and this new inverted ratio has transformed our Pull Request “safety valve” into an effective sewage pump. Former marks of quality — verbose documentation, improved test coverage metrics, and fully-compliant PR descriptions — are now both instantaneous and effectively free to the creator. Moreover, these quality indicators now often hint at the inverse, actually signalling lower effort and less engagement. I have a friend who lives on the Chesapeake Bay that, whenever she is prepping fresh-caught crabs to make crab cakes, intentionally lets little bits of shell fall into the crabmeat. She says that the shell bits reassure her guests that the crab cakes are fresh, home-made, and not the product of a factory line. In no way am I arguing that “hand crafted software” has any value outside the artistic self-gratification of the code author — just that these signals of quality are no longer effective, and are functionally little more than cargo cult rituals of a dead system.

To understand what agentic software development needs from an effective SDLC, we need to carefully appraise the role of a human Software Engineer in this system. Humans no longer add value by authoring lines of code or walls of documentation; we have marched towards this inevitability for decades (long before mainstream commercial LLMs we typed rails gen into terminals to build walls of boilerplate, and this is in many ways simply the final stage of that effort). The human contribution is now in deriving critical abstraction and applying corrective guidance to what LLMs generate. This is another critical inversion from traditional software development: in agentic software development the raw LLM output for a task is not a product of work, it is work yet to be done.

In agentic software development the raw LLM output for a task is not a product of work, it is work yet to be done

The traditional SDLC is not designed for this configuration, and it has no guard rails to prevent what is in essence a self-inflicted DDOS attack on your software pipeline. Well intentioned Engineers still operating under the old system, with new agentic tools, often behave as overpriced proxy services to Anthropic; they respond to technical discussions by prompting Claude to read and reply, they instruct Claude to review and comment on Pull Requests for them, they prompt-generate great walls of documentation in Linear tickets and Notion docs. The old system tells them this is contributing, and awards them gamified mosaics of green lights and gold stars for the effort. But in the agentic age, where humans add value post-generation, this proxying serves as additional work — not contribution. An SDLC for the agentic age must evolve to reflect the work that humans are actually needed to do. It needs to center around the distribution, collaboration, and coordination of this new locus of human work, making our role as the scrutinous overseers of what agents have generated the premier first-class citizen of the SDLC, while eliminating all value associated with “authoring” code or documentation (in that the “authoring” is now little more than starting an agent).

For the longest time git commits were a thing of quiet pride for Software Engineers. Outside of their purely technical value, commits served a litany of important functions; they were a sort of log book for the evolution of our software, they allowed us to compete for an unofficial score, and they showed the world which important OSS projects had accepted our work. It is precisely because of how Software Engineers have viewed their git commits in the past that an agentic SDLC needs to redefine their role — because in the new agentic world, this aging view causes harm.

Software Engineers do not write code in the agentic world. This is not a conceptual idea, it is the current reality. Consequently, these are not your git commits, they are the commits of an AI agent — and pretending otherwise is masturbation. Given a GitHub account and an Anthropic subscription, a determined toddler could cause Claude Code to push up million OSS commits while they nap and watch Paw Patrol. This is no longer any indication of contribution or achievement. There is no osmosis by which you will gain an understanding of the codebase simply because Claude Code used your ssh key while running push commands. In a workflow designed for the agentic world, git commits will be completely decoupled from individual human contributors, and instead associate humans with their guidance and supervision; this may sound like effectively interchangeable concepts, but I would argue that there is an important difference. Commits still serve a mechanical function in code creation, and need to be allowed to do so independently of human ownership (because again we are being honest now, and humans don’t actually write code). Human ownership comes in the conversation, the direction, the final approval — and that need not be a linear ownership.

Imagine a near-future SDLC where software creation is generated automatically from user requests, Linear tickets, bug reports etc. and queued in a pool of ready work. A team of Engineers attacks this work as a coordinated pack, combing through pre-generated plans, code diffs, and test run results. Sometimes they make simple comments like “we already have a similar enum dry this up” or “this is going to balloon in memory, use a generator.” Other times they intervene more heavily: “This whole thing makes no sense, why not use the existing Redis?” Sometimes they debate, or call in others to confer. They work together to approve code that none of them claim to have personally written so that it may pass through CI and be merged, and this work is what the SDLC enables, elevates, and celebrates. The git commit must fade into obscurity so that the session engagement may ascend.

This is the story of Captain Jack Sparrow

The upheaval of a system always creates new opportunities for regression — and agentic software development is rife with examples of bad habits reborn. However, traditional Pull Request mechanics combined with the sycophancy embedded in commercial LLMs have created a shit-code perfect storm. It is dangerously seductive as an Engineer to simply vibe between session prompt, terminal output and manual click-test, avoiding the code diff all together. It feels magical, powerful, like a commandment: as you have prompted, so shall it be done in your local. Your test coverage increases. This is the future. Why look at the code?

The insidious nature of this moment in agentic coding is the way in which code horror now forms from within.The nightmare vibe spaghetti times of 2023 are thankfully over (there is no helping the poor langchain-infested codebases from that time), but today’s evil is in many ways much more sinister. Horrific architectural time bombs burrow silently like tab-indented Manchurian Candidates. How do these differ?

🧑‍💻”hey everything looks great, except it seems weird to me that you had to add a Users model to the ORM. This app is over a year old. How is it possible we do not have a Users model yet?” 🤖”you’re absolutely right! The ORM model is called User, I shouldn’t have added another model that will be confusing and cause problems.”

🧑‍💻”how is this test passing when it is calling Redis?” 🤖”I mocked out all the Redis calls due to an unrelated network issue, our code is correct and all tests pass.” 🧑‍💻”but we don’t use Redis…”

🧑‍💻”Why did you update all the joins in our database module?” 🤖”to resolve issues with database session scope I simplified by eager joining the models” 🧑‍💻”so every single request pulls down the entire database?”

These aren’t the AI soup of old. The implementation code quality of today’s evil is proba

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →