Fast and Hard Code

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

The thread treated the article less as a claim that programming is finished than as a test of what AI changes about technical ambition. Several commenters have watched chat models and coding assistants lower the entry barrier to work once reserved for specialists: systems tooling, unfamiliar languages, compiler-backed Rust analysis, and sizeable application rewrites. The optimistic case is not that developers can stop thinking, but that an experienced developer can explore more designs, take on formerly impractical projects, and use a model as a fast research and implementation partner. The strongest pushback is about the gap between producing code and owning it. Readers argued that unfamiliar-language output cannot be responsibly reviewed, debugged, evolved, or trusted merely because it compiles. This becomes acute in cryptography and other high-consequence systems, where a plausible implementation can hide fatal mistakes. One experiment produced a sophisticated linting approach from broad requirements, but its author explicitly limited that workflow to a domain where missed findings cause no harm. Commenters also stressed that model performance follows the density and maturity of public training material: established math, algorithms, and bindings fare well, while newer language features and polished UI remain weak. The broad middle ground is that AI shifts programmers toward wider domain knowledge and sharper evaluation skills rather than making either unnecessary.

The central fight is whether AI makes deep knowledge of a programming language and its underlying systems largely optional. Optimists say agents can absorb language friction and let capable people pursue much larger ideas, while curiosity-driven specialists will still push the frontier. Skeptics say code is only useful when its owner can inspect its assumptions, catch language-specific traps, and maintain it after the model's first pass.

• Praise: Coding assistants are letting developers attempt systems projects, full rewrites, and niche tooling that previously died under their sheer implementation cost.
• Praise: Conversational model use can act as a serious force multiplier for experienced developers, accelerating delivery while leaving human judgment on the critical path.
• Praise: Models can surface stronger technical approaches than a developer would initially choose, such as using compiler name resolution instead of fragile source parsing for workspace-wide analysis.
• Praise: Rich public prior art gives models real leverage in mathematics, algorithms, and established low-level interfaces, making cross-language experimentation less intimidating.
• Concern: Generated code in an unfamiliar language is hard to review or maintain, so treating language knowledge as obsolete turns reliability into an article of faith.
• Concern: Custom cryptography remains a high-stakes danger zone: a convincing implementation can conceal subtle failures that only deep expertise exposes.
• Concern: Agent-built applications can invent data, mishandle alignment, and corrupt caches, illustrating how a polished first pass can mask basic correctness defects.
• Concern: Models lag on cutting-edge language features and often produce generic UI because their competence tracks the availability and quality of training examples.