Write Code Like a Human Will Maintain It - The AI Era Debate

Official Sources#

Last updated: July 14, 2026 A piece titled "Write Code Like a Human Will Maintain It" hit the Hacker News front page today with 312 points and 254 comments. The author's thesis is direct: using LLMs as an excuse to skip coding best practices creates a self-reinforcing problem where your codebase trains the AI to produce worse code over time.

The Core Argument#

The author describes a specific anti-pattern they caught themselves in. An identical access-check conditional was duplicated across multiple locations - route handler, background job, API endpoint, webhook. Rather than extracting this into a shared helper function, they let the LLM handle each instance separately.

The result: "Every shortcut you merge into your codebase is a signal about how things are done here." Once bad patterns exist in the repository, LLMs read and replicate them, assuming they represent the project's established style.

This creates an escalating problem. Code smells accumulate - duplicated conditionals, oversized functions, deferred refactoring - each one reinforcing poor practices in future prompts. The author initially believed they were outsourcing maintenance to AI but discovered they were actually training it to develop worse habits.

What HN Is Saying#

The Hacker News thread split into several distinct camps, with strong opinions on both sides.

The vibe-coders push back hard. One commenter wrote: "That sounds like a good idea, but shipping 10x as many features and bugfixes sounds better. I started using AI with the best intentions. Checking everything before committing. Now, AI GOES BURRRRRRRRRRRR! If the tests pass it's good to ship. AI can deal with the problems it may create. No problems so far."

This prompted immediate skepticism. One response questioned the productivity multiplier claim directly: "How did you know you're not stuck at a local optimum where the AI could iterate even faster if you enforced higher quality on what it produced?" Another pointed out that "10x features and bugfixes" makes mathematical sense only if you had tens of thousands of bugs queued up, or if your pre-AI velocity was glacial by industry standards.

Commenters share their codebase degradation experiences. Several developers confirmed the article's thesis from firsthand observation. One noted that baseline tasks start taking longer as code quality drops: "In the beginning (less than 10K LOC), this baseline change will take 2-3 minutes. As you add more code, the same change starts to take 5-6 minutes, and once you hit 1 million LOC, it can take as long as 10 minutes."

This matches what the article describes - a gradual slowdown as the model spends more effort navigating messy code and ensuring changes are correct across a fragmented codebase.

The LLM comment problem gets extensive discussion. A recurring complaint in the thread involves AI-generated comments that break encapsulation by describing the behavior of specific current callers right above a function definition. One developer admitted: "I recently reacted angrily in a PR review comment after encountering one for the umpteenth time... that caught me off guard. I didn't know I was capable of that."

Claude Code users shared their frustrations with over-commenting despite explicit CLAUDE.md rules. One wrote: "Even though I have a rule in my global CLAUDE.md that says 'Only write comments to explain the why when it is not obvious from the code,' it still keeps adding these bad comments."

The suggested fix is aggressive: "The comment rule above beats the style of the surrounding code: neighboring files with what-style comments are not license to write more of them."

Review workflows emerge as a practical solution. Multiple commenters described building review processes into their AI workflows. One approach involves maintaining a 200-item checklist: "Any time I notice something in code review and have to get the agent to fix it, I throw it on the list! Agents don't care that they just got a wall of generic feedback, they happily look into all the bullet points."

Another commenter uses multi-model review: "I run codebases through different models to have them look for bad code smells like repeated code. That's been pretty effective."

Security concerns surface. A commenter raised the Jia Tan comparison - all those years of effort to gain trust and land a sophisticated backdoor, and now developers are just prompting for code and shipping it without review. Another cited Anthropic's own research on how little it takes to poison LLMs, expressing concern about backdoors being introduced through the training data itself.

The Practical Takeaway#

The debate reveals a real tension in AI-assisted development. Pure velocity - "AI goes brrr" - works for personal projects and early prototypes where you control the entire context. But in team environments or projects with longevity, the codebase becomes shared context that shapes all future AI interactions.

The author's recommendation is straightforward: maintain human coding standards even when using AI assistance. Treat generated code with the same scrutiny you would apply when writing manually.

Several commenters offered concrete practices:

• Run periodic refactoring passes to clean accumulated debt
• Use deterministic linting and pre-commit hooks to catch obvious issues
• Build explicit review prompts into your workflow
• Document patterns you want preserved in CLAUDE.md or similar files
• Accept that some manual code review is still necessary

The counterargument - that future AI will just fix everything - requires betting that model capabilities will outpace the technical debt you are accumulating. That may or may not prove true. The safer approach is treating code quality as a compounding investment that benefits both human and AI maintainers.

FAQ#

What does "write code like a human will maintain it" mean for AI-assisted development?#

The essay argues that you should keep human coding standards when using LLMs. Every shortcut merged into a codebase signals how things are done there, so models read those patterns and replicate them, making future generated code worse.

How does sloppy AI-generated code make future AI output worse?#

Code smells such as duplicated conditionals, oversized functions and deferred refactoring accumulate, and each one reinforces poor practices in later prompts. Commenters reported baseline changes taking longer as code quality drops and the codebase grows.

How can teams keep AI-generated code maintainable?#

Commenters suggested periodic refactoring passes, deterministic linting and pre-commit hooks, explicit review prompts, documenting the patterns you want preserved in CLAUDE.md or similar files, running code through different models to find smells, and accepting that some manual review is still necessary.

Why do coding agents keep adding unnecessary comments?#

Claude Code users in the thread reported over-commenting even with a CLAUDE.md rule limiting comments to explaining the why. The suggested fix is a stronger rule stating that the comment rule beats the style of surrounding code, so neighboring what-style comments are not license to write more.

Continue Reading#

• Does Your Codebase Pattern Determine AI Output Quality? HN Debates the Economics of Rewrites
• Benchmarking Opus 5 on SlopCodeBench: AI Code Quality Under Iteration
• Clean Code Makes AI Agents 34% More Efficient - New Research
• OwlPath: Ontology-Based Code Retrieval Cuts Agent Tokens 29%

Sources#

• Write Code Like a Human Will Maintain It - Original article
• Hacker News Discussion - 254 comments, 312 points