The End of Programming

Based on 15 sampled comments from this thread. Analyzed 2026-08-26.

The thread mostly rejected the headline while taking the underlying capability jump seriously. The Bun Zig-to-Rust rewrite impressed many readers as evidence that LLMs can now translate large codebases, exploit strong test harnesses, and grind through enormous volumes of already-understood implementation work. Several commenters argued that this is exactly where a large share of programming lives: reimplementation, adaptation, and translation rather than pristine invention. But the dominant qualification was that the rewrite depended on years of human engineering embedded in its architecture, tests, oracle, and technical objective. Readers argued that turning a vague business need into a correct specification, deciding what tradeoffs matter, and detecting subtle bad decisions remains the work. Current agents can produce a convincing prototype, yet commenters repeatedly distinguished that from maintaining a safe, reliable production system. Limited context, excessive confidence, language-idiomatic mistakes, and buggy AI tooling itself all undercut claims of imminent replacement. The more plausible future, in the thread's view, is a shift from manually typing implementations toward orchestrating models, designing verification environments, and expressing intent precisely. Some see that as democratizing bespoke software; others fear it erodes expertise, narrows junior training paths, and gives executives an excuse to reduce engineering headcount before the technology is dependable.

The central dispute is whether powerful AI-assisted rewrites show programming is ending or merely changing levels of abstraction. Optimists say well-specified tasks plus automated verification let models do vast amounts of useful work, making intent, evaluation, and rapid iteration the new scarce skills. Skeptics answer that constructing the specification and oracle, making architectural calls, and productionizing unreliable output are programming and engineering—not evidence that either has disappeared.

• Praise: LLMs look genuinely formidable at cross-language translation and reimplementing proven behavior, making million-line migrations far less dependent on hand-written boilerplate.
• Praise: A rigorous test suite and behavioral oracle let AI iterate toward reliable results, hinting at a workflow where verification amplifies model output rather than human code review alone.
• Praise: Cheaper implementation could make custom software economically viable for customers previously forced into one-size-fits-all SaaS products.
• Praise: The emerging premium skill is not typing syntax but framing intent, building evaluators, and orchestrating models around explicit architectural constraints.
• Concern: Treating code delivery speed as the only metric risks hollowing out architectural judgment, leaving teams unable to recognize when a fluent model has made a costly mistake.
• Concern: The celebrated rewrite rests on a human-built target, years of tests, and a sharply defined migration goal; without that scaffolding, the alleged end of programming evaporates.
• Concern: Agents can make prototypes look nearly finished while the difficult work—edge cases, operability, maintenance, and production reliability—has barely begun.
• Concern: Current coding models remain bug-prone, overconfident, and constrained by partial codebase context, while even their own development tools ship with disruptive instability.
• Concern: If AI handles routine work too early, new engineers may lose the apprenticeship path that creates the experts needed to supervise and repair automated systems.