IdeaWell

Project ideas from Hacker News discussions.

Why Common Lisp is now the best programming language

Original Article

Hacker News Discussion

📝 Discussion Summary (Click to expand)

Four Prevalent Themes in the Discussion

  1. DSLs trade off abstraction benefits against LLM practicality
    While DSLs can reduce token usage by encoding domain semantics, LLMs often struggle to create or use them effectively due to training data biases.

    "DSL presumes agreement on semantics, and that's often the most difficult part." – tzmudzin
    "Writing good DSLs requires one to be great at going up the ladder of abstraction. Not that LLMs can't do it, but they stuggle and choose the path of least resistance." – copperx

  2. Live debugging/resumption (especially in Lisp) enables tight LLM feedback loops
    The ability to pause execution, inspect state, apply fixes, and resume without restarting is seen as uniquely valuable for AI-assisted development.

    "In Common Lisp your program won’t crash, it’ll stop and open a debugger with the whole stack and all the variables. You can just point your LLM at the debugger, and it’ll make its fix and resume the program." – frollogaston
    "In CL, you can resume from exactly the state you were in when the debugger paused, only this time with the correct data in place." – rmunn

  3. Strong typing provides critical context for LLMs, reducing hallucinations
    Static types act as executable documentation that helps LLMs generate correct code by constraining possible interpretations and catching errors early.

    "strong types are disproportionately valuable in LLM coding vs human coding because they essentially function as context and the typechecker actively enforces correctness" – nylonstrung
    "strong types are disproportionately valuable in LLM coding vs human coding because they essentially function as context and the typechecker actively enforces correctness" – georgemcbay

  4. No universal "best" language exists; suitability depends on context and dimensions
    Language effectiveness for LLMs involves trade-offs (e.g., token efficiency vs. tooling vs. ecosystem), making absolute rankings meaningless.

    "Now as ever, there is no 'best programming language'. There’s the right tool for the job, there’s compliance with requirements, there’s personal preference." – andrewstuart
    "This post reads like it was written by a Common Lisp fan who is looking for a reasons to say that Common Lisp is good for AI agents, rather than an AI agent user evaluating what languages are really best." – nickm12
    "Unless of course there are multiple dimensions of 'Good'. I in my opinion this is exactly the case. There are best languages per dimension, but not absolutely best." – Vincnetas

🚀 Project Ideas

Generating project ideas…

SnapDebug: Production-Safe Hot Reloading Debugger

Summary

  • A language-agnostic tool that allows developers to attach to running applications, inspect state during exceptions, make live code/data changes, and resume execution without restarting—inspired by Common Lisp's condition system but designed for production safety in web services.
  • Core value proposition: Eliminates downtime for bug fixes in production by enabling true hot reloading with sandboxed debugging sessions per request.

Details

Key Value
Target Audience Backend developers working with Python, Node.js, Java, or Go who need zero-dotime production debugging
Core Feature Intercepts exceptions, spawns isolated debugging session per affected request, allows code/data mutation, and resumes execution with changes applied
Tech Stack eBPF for process interception (Linux), WASM sandbox for safe code edits, gRPC for IDE integration, Redis for session state
Difficulty High
Monetization Revenue-ready: SaaS tiered pricing ($29/dev/mo for teams, $99 for enterprise)

Notes

  • HN users praised CL's ability to "point your LLM at the debugger" and resume after fixes (rmunn, frollogaston); SnapDebug brings this to mainstream languages while addressing production safety concerns about blocked connections.
  • Solves whartung's frustration with "copying a litany of bits of data" by letting developers fix mapping bugs live without redeploying.
  • Enables the LLM-assisted workflow described by misterchocolat where agents iterate on running code via debugger interaction.

DSLForge: LLM-Powered Domain-Specific Language Generator

Summary

  • A service that converts business process descriptions into custom DSLs and runtime frameworks, reducing boilerplate in ERP-like systems by generating domain abstractions tailored to specific business models.
  • Core value proposition: Cuts DSL development time from weeks to hours using LLMs, while generating type-safe bindings and documentation to combat the "economies of scale" problem mentioned in the discussion.

Details

Key Value
Target Audience Startups and SMBs building custom business software who need agile domain modeling without maintaining parsers/interpreters
Core Feature Transforms natural language business rules (e.g., "online orders need fraud checks, distributor orders need tax exemptions") into executable DSL code with IDE plugins
Tech Stack LLM fine-tuning on DSL grammars (using Lark/ANTLR), TypeScript generator, WebAssembly runtime, Postgres for rule storage
Difficulty Medium
Monetization Revenue-ready: Per-project licensing ($499) + optional hosting ($29/mo)

Notes

  • Directly addresses tzmudzin's point about LLMs changing the DSL economics ("develop your custom solution 20x faster") and sroerick's interest in "DSL for a specific business."
  • Solves the pain of invalidated models when business changes (e.g., adding online shop) by enabling rapid DSL regeneration.
  • Commenters like karrot_kream would appreciate the abstraction ladder climbing without manual macro writing.

DataFlow: Declarative Data Mapping Compiler

Summary

  • A compiler that eliminates manual data transformation code by generating type-safe mapping functions from declarative schemas (JSON/JSONSchema/YAML), targeting the "copying data from one structure to another" pain point in back-end development.
  • Core value proposition: Reduces boilerplate by 70%+ for common tasks like API-to-DB ORM layers, form processing, and ETL pipelines through schema-driven code generation.

Details

Key Value
Target Audience Full-stack engineers tired of writing repetitive data conversion logic in TypeScript, Python, or Java
Core Feature Input/output schema definitions → generated mapping functions with automatic type coercion, validation, and error handling
Tech Stack Rust compiler backend, WASM target for broad language support, SchemaWatch for live schema sync, VS Code extension
Difficulty Medium
Monetization Hobby (open core with paid enterprise features: schema governance, team collaboration)

Notes

  • Directly targets whartung's complaint about "a lot of code tasked with copying a litany of bits of data" being "excruciating detail."
  • Complements LLM workflows: agents could use DataFlow to generate boilerplate while focusing on business logic (as suggested by dang's token efficiency points).
  • soltanov's idea of measuring token efficiency across languages aligns with DataFlow's goal of reducing unnecessary code tokens.

LiveState: Image-Based Development Platform with LLM Pairing

Summary

  • A development platform combining language VM snapshotting (like Lisp images) with real-time LLM assistance, allowing developers to pause execution, edit state/code via natural language, and resume with zero context loss.
  • Core value proposition: Enables the "REPL-driven development" workflow praised in the thread for any language, reducing cognitive load by preserving runtime state during LLM-assisted coding sessions.

Details

Key Value
Target Audience Developers using Clojure, Python, or Node.js who want Lisp-style interactive development with LLM augmentation
Core Feature VM snapshotting + LLM prompt-to-edit interface: "Fix the null pointer here" → applies change to running state and continues execution
Tech Stack Custom VM fork (based on GraalVM/JavaScriptCore), WebSocket LLM bridge, CRDTs for state synchronization, Electron desktop app
Difficulty High
Monetization Revenue-ready: $15/dev/mo for individuals, $40 for teams

Notes

  • Realizes the vision described by chrchr (TDD with debugger) and frollogaston's LLM-connected debugging vision, making it practical for web backends.
  • Addresses karrot_kream's desire for a "zen" moment with macros by letting LLMs handle abstraction layer adjustments in live state.
  • Directly enables the workflow where "the LLM writes some code to fix it, and the user's request completes successfully" (chrchr).

Read Later