Why Common Lisp is now the best programming language

Original Article ↗ Hacker News Discussion ↗

Common Lisp is held up here as an ideal language for the “LLM era” because of its live image-based development, powerful debugger, and macro system for building concise domain‑specific languages that might reduce token usage and speed agent-driven coding. Many responders push back, arguing that strong static types (Rust, OCaml, F#, Go, etc.), mature tooling, and large ecosystems matter more for AI-assisted development, and that hot reloading and interactive debugging exist in other platforms too. The broader takeaway is that no single “best” language has emerged for LLM-based coding: language choice still depends on domain, architecture, and human maintainability, even as people report promising results with various Lisps, Python, and other ecosystems.

Debugger, conditions, and hot reloading

  • Many comments focus on Common Lisp’s condition system: uncaught errors can drop into an interactive debugger without unwinding the stack, allowing changing values or recompiling functions and then resuming execution.
  • Supporters say this shortens the debug loop, works even with compiled code, and is especially powerful in long‑running systems or REPL‑driven development.
  • Critics argue this is risky in production (untracked “live” changes, potential footguns) and that in practice CL servers usually just log backtraces and crash the request, like other languages.
  • Several note that other ecosystems (.NET, Java, Dart, JavaScript, Smalltalk) also support remote debugging, edit‑and‑continue, or hot reload, so CL is not unique here.

Macros, DSLs, and token efficiency for LLMs

  • Pro‑Lisp voices emphasize macros for building DSLs that encode domain opinions and greatly shrink codebases, which could reduce LLM token usage and improve readability.
  • Others counter that:
    • DSLs add their own learning/manual overhead and can easily become opaque macro‑hell.
    • LLMs don’t need DSLs to be productive, and may prefer mainstream languages with abundant training data and conventions.
    • Static, typed hosts (Rust, OCaml, Lean) might be better DSL platforms due to stronger guarantees.
  • There is extensive debate on whether brevity and “language plasticity” really dominate LLM performance versus architecture, types, and ecosystem.

Image‑based development and agents

  • Several report good results wiring LLM agents into live Lisps (Common Lisp, Clojure, Smalltalk‑style images, Janet): agents connect to REPLs, reload code, run tests, and introspect state inside a running system.
  • This workflow is described as fast and “alien tech”, but also niche and at odds with container‑based disposable deployment; some find similar patterns workable in Python/iPython or Node with autoreload.

Static vs dynamic typing

  • One camp argues strong static types (Rust, OCaml, Haskell, Scala, F#) are especially valuable for LLMs: they act as executable specifications, give precise compiler feedback, constrain search space, and help large teams refactor.
  • Others point out:
    • Common Lisp is strongly typed at runtime and can support static systems (e.g., Coalton‑style) on top.
    • Dynamic ecosystems can use runtime specs, predicates, and generative testing to capture rich invariants that many mainstream static systems can’t express easily.
  • No consensus emerges; both sides cite personal LLM experience favoring their preferred paradigm.

Performance, libraries, and security

  • CL performance (especially SBCL) is described as competitive with other managed languages, though well behind optimized C/C++ in benchmarks.
  • Ecosystem concerns: fewer, less‑audited libraries; missing or weaker support for “foundational” pieces like cloud SDKs, DB drivers, ASN.1, etc.
  • Some argue LLMs can cheaply port or re‑implement missing libs; others worry about rediscovering quirks, lack of security review, and token cost of “from scratch” re‑writes.

“Best language” claims and article skepticism

  • Many reject the notion of a single “best” language, invoking partial orders and multidimensional trade‑offs; language choice is seen as domain‑ and organization‑dependent.
  • Multiple commenters say the article overstates CL’s uniqueness and underplays similar features in other ecosystems; some call it fan‑driven or even LLM‑generated “slop”.
  • There’s meta‑discussion that every community now argues their pre‑LLM favorite (Python, Rust, Go, F#, Elixir, etc.) is “the perfect agentic language”, with largely symmetrical justifications.

Miscellaneous

  • ERP/DSL discussion: people note ERP domains differ greatly across industries; semantics are the hard part, so DSLs and even LLMs don’t magically yield reusable, universal ERP languages.
  • The linked site is flagged as suspicious by some due to an invisible div containing porn links, causing corporate filters to classify it as “adult material.”