An "oh fuck" moment in time
Claims that an AI assistant rapidly converted a complex Rust audio library into a working Haskell wrapper spark debate over how powerful current coding LLMs really are. Commenters contrast impressive wins in boilerplate, FFI bindings, and code scaffolding with frequent hallucinations, fragile project structure, poor reasoning, and the overhead of verification, arguing that these tools help but don’t replace deep engineering skill. The thread also raises concerns about overconfident reliance by novices, long‑term effects on developer competence and wages, and unresolved copyright and originality issues around AI‑generated code.
Perceived Capabilities and Limits
- Many see LLMs as excellent “translators”: between languages (e.g., Rust→Haskell, SQL→Jooq) or formats (YAML↔JSON, code scaffolding).
- Others report that large, ambitious tasks (e.g., fully porting complex libraries like megaparsec or entire apps) quickly degrade into wrong, shallow, or partial implementations.
- Some argue LLMs aren’t “inventing” but recombining existing patterns; translation/wrapping C APIs is seen as commodity work, not true novelty.
Coding Assistants in Practice
- Popular use cases: boilerplate generation, refactors/renames, API lookups, unit-test scaffolding, state-machine skeletons, simple scripts, and “smarter grep/RTFM” for docs.
- IDE-integrated tools (Windsurf, Cursor, Cody, Copilot-like systems) are praised for autocomplete and local edits, but criticized for:
- Deleting or duplicating code unexpectedly.
- Getting stuck in fix loops.
- Producing placeholders instead of full implementations.
- Poor handling of project structure and long-lived maintainable design.
Reasoning, Hallucinations, and Trust
- Users note recurring hallucinations: invented sentences in translations, wrong logic-puzzle answers, fabricated links, incorrect descriptions of protocols/APIs.
- “Confidently wrong” answers erode trust, especially when domain knowledge is required to even detect errors.
- Some insist logic puzzles are a poor benchmark; others argue basic reasoning is prerequisite if we expect reliable code.
Impact on Developers and Skills
- One camp: assistants are a “massive force multiplier”; engineers who ignore them “won’t make it,” analogous to refusing modern tools.
- Counterpoint: fundamentals matter more; assistants are easy to pick up later, while overreliance can atrophy reasoning skills and produce graduates who “can’t program without ChatGPT.”
- Debate over future roles: developers shifting toward project management, code review, maintenance of AI-generated “spaghetti,” vs. pessimistic views that entire occupations may become obsolete.
Originality, Intelligence, and “Mechanical Turk”
- Some compare LLMs to a scaled-up Mechanical Turk: impressive output but entirely dependent on human training data, thus not genuine intelligence.
- Others respond that humans also “stand on the shoulders of giants,” and that high performance on many benchmarks suggests something more than simple lookup.
Copyright and Licensing
- Concern that AI-generated ports/wrappers may embed open-source code without attribution, complicating clean-room and licensing.
- Suggestions appear that AI-generated output should be public domain, but others note this doesn’t resolve underlying infringement of training data.