Top Developers Return to Hand-Writing Code as AI Slop Backlash Trends on X

A short post from Sam Hogan, CEO of agent-tooling startup MultiplyAI, has ignited the loudest pushback against AI coding tools in 2026. On April 25, Hogan wrote, "All the best programmers I know are starting to write code by hand again." The tweet pulled in 419,000 views in six hours, and four hours later Linear's CEO posted a similar thesis that drew another 126,000 views. By the next morning, X was trending the topic "Top Developers Returning to Hand-Writing Code Over AI Tools" with more than 5,700 posts and 6,000 reactions still climbing.

Key Highlights

• Sam Hogan's tweet on April 25, 2026 hit 419K views in six hours and triggered an X-wide trend on hand-coding.
• Linear's CEO publicly echoed the thesis four hours later, adding institutional weight to the backlash.
• The trend pushes back on Kyle Daigle, GitHub COO, who said hand-typed code "days are quickly slipping behind us."
• MIT Technology Review research shows AI-generated code is verbose, copy-paste heavy, and 2.2x larger than human-authored equivalents.
• Pull request size grew 33 percent in 2025; lines of code per developer jumped from 4,450 to 7,839.
• A METR study found developers believed AI made them 20 percent faster but objective tests showed they were 19 percent slower.

The Spark

Hogan's framing hit a nerve because it inverted the dominant 2026 narrative. Anthropic has said 70 to 90 percent of its internal code is AI-generated, and Boris Cherny, who leads Claude Code, has not edited a line by hand since November 2025. Andrej Karpathy described his own December-onward workflow as essentially supervisory. Against that backdrop, Hogan's claim that elite engineers are reverting to manual coding read as a quiet rebellion.

The replies split sharply. One camp framed it as a skill issue and pointed to high AI usage at Google and Anthropic. Another agreed that AI works for prototypes and small tasks but fails on long-lived systems where ownership and mental models matter. The framing that gathered the most traction came from developers complaining that AI agents produce plausible code that passes tests today and quietly becomes a liability tomorrow.

The Data Behind the Backlash

The trend lines up with findings from MIT Technology Review's December 2025 investigation and a follow-up Greptile analysis published in April 2026. AI-generated code is getting bigger, not better. Lines of code per developer rose from 4,450 to 7,839 over 2025. Average pull request size grew 33 percent between March and November, climbing from 57 to 76 lines changed. Individual file changes became 20 percent larger and denser. GitClear flagged a sharp rise in copy-pasted code since 2022, and over 90 percent of issues found in AI-generated code are now classed as "code smells" rather than functional bugs.

A widely-cited METR study compared developer self-perception against objective measurement. Engineers using AI coding tools believed they were 20 percent faster. Stopwatch testing showed they were 19 percent slower. Mike Judge of Substantial replicated the finding in personal benchmarks and described AI assistants as "nearsighted," only able to look at the thing right in front of them.

The Counter-View

Not every developer is buying the backlash. Trevor Dilley of Twenty20 Ideas reported Claude Code finishing a four-hour task in two minutes with code quality he rated above his own. Coinbase has told staff that simple tasks like restructuring and test scaffolding see speedups up to 90 percent, even as complex work sees only modest gains. Kyle Daigle, COO of GitHub, told developers in March that hand-typed code is a fading skill: "those days are quickly slipping behind us."

The honest middle ground is captured by Luciano Nooijen of Companion Group, who told MIT Technology Review, "I was feeling so stupid because things that used to be instinct became manual." The complaint is not that AI fails. The complaint is that it hollows out the craft and makes engineers passive reviewers of code they did not author.

Why It Matters

For working teams, the trend signals a course correction rather than a reversal. Nobody on the trending thread argued for abandoning AI tools entirely. The argument is about where AI helps and where it harms. Prototypes, scripts, scaffolds, and one-off tools are still being delegated. Long-lived production code, performance-critical paths, and architecturally load-bearing systems are increasingly being kept under direct human authorship for the sake of maintainability and ownership.

That maps cleanly onto the data. Outages have steadily increased since 2022. Code duplication is up across the industry. Junior developer volume is overwhelming senior reviewer capacity at multiple companies. The hand-coding revival is less a rejection of AI and more a recognition that speed without ownership creates technical debt faster than it ships features.

Background

The backlash has been building for months. Karpathy noted in March that AI agents are "very prone to copy pasting code blocks" and tend to "bloat abstractions." Greptile published a thesis in April arguing that economic pressure will force AI models toward simpler, more maintainable output because complex code costs more tokens to generate and modify. Mike Mason wrote about "the code you're not reading" as a category of risk: AI-generated code that ships without anyone fully understanding it.

Hogan's tweet did not introduce these arguments. It compressed them into nine words and gave the doubters a banner.

What's Next

Expect AI vendors to react. Anthropic, OpenAI, and Cursor are all already shipping agent-review and code-curation features that frame human oversight as the differentiator. Expect engineering leaders to publish formal "where we use AI and where we do not" policies over the next quarter. And expect a quieter trend underneath the headlines: hiring filters that test for the ability to read, refactor, and own code that was not originally yours, regardless of whether a human or an agent wrote the first draft.

Source: X (Sam Hogan) — additional context: MIT Technology Review, Greptile Blog