AI Resistance in Lisp: A Developer's Lament on the Future of Programming Languages

A DevOps engineer's recent experience with AI coding assistants has revealed a stark reality: Lisp, despite its elegance and power, faces significant challenges in the age of AI-assisted development. The findings suggest that language popularity directly impacts AI effectiveness and cost, potentially reshaping how developers choose their tools.

The AI Resistance Problem

The developer, who regularly uses agentic AI through OpenRouter with the Goose CLI tool, encountered unexpected difficulties when attempting to write a tool for converting between different RSS reader formats in Lisp. While Lisp remains their favorite language, the AI's performance was dramatically inferior to what they experienced with Python.

"I had to teach the AI how to use the REPL," the developer explains. "Initially, I had it run commands to interact with the REPL via tmux, but REPL development was very hard for the AI. Claude really spun its wheels."

This resistance manifested in several ways. The developer found themselves spending $10-$20 in just minutes with minimal progress, often ending up rewriting the AI-generated Lisp code entirely. Even when attempting to use cheaper models like DeepSeek and Qwen, which performed adequately for other tasks, the results remained unsatisfactory.

The MCP Server Solution

In an attempt to improve the situation, the developer created a tool called tmux-repl-mcp to streamline REPL interactions. Rather than parsing tmux output and executing multiple commands, the tool allows direct execution of commands in the REPL. However, this workaround only partially addressed the underlying issue.

Interestingly, the developer chose Python for this tool despite their preference for Lisp. "I liked that I just had to install uvx and all of a sudden goose could use all these tools," they note. This decision highlights a practical consideration: the ecosystem and tooling around a language significantly impact AI effectiveness.

The Python Contrast

The difference in AI performance between Python and Lisp was described as "dramatic, downright wild." With Python, the AI successfully wrote all the code and tests, requiring only semi-manual debugging. The developer was able to create a functional tool in just a day or two, even using cheaper models.

This stark contrast raises important questions about the relationship between language design, tooling, and AI capabilities. The developer observed that AI generates code along a "path of least resistance," preferring languages with abundant training data and straightforward tooling.

The Cost Factor

Perhaps most tellingly, the developer calculated that writing in high-internet-volume languages like Go and Python is "orders of magnitude easier and cheaper" than writing in Lisp. This cost differential stems from the fundamental economics of AI APIs: users pay for both signal and noise together.

"With AI, code is cheap, but only if you use a language for which AI has a lot of training data," the developer notes. This observation suggests that language popularity has become a tangible economic factor in development decisions.

Tooling and Cultural Challenges

Beyond the training data issue, the developer encountered persistent tooling challenges. Lisp's diverse ecosystem, while offering flexibility, created friction with AI assistants. The developer had to repeatedly instruct the AI not to use QuickLisp, as it was "sort of built into the AI to use it."

This experience points to a deeper issue: AI models develop preferences based on their training data, and these preferences can be difficult to override. The developer suggests that Lisp's REPL-based development model, which reduces latency for human programmers, actually works against AI effectiveness given the high-latency nature of API interactions.

The Historical Parallel

The developer draws an evocative comparison to Plank Road in Naperville, Illinois. In the 19th century, investors built a wooden plank road to avoid muddy conditions, charging users for the improved experience. When railroads offered to build through the town, the investors declined, believing the plank road would remain profitable. Eventually, everyone switched to rail, and the plank road survived only in name.

"The Plank Road must have been way nicer to traverse than the muddy roads, evoking joy in the travelers when comparing it with travelling in the mud, just like Lisp makes me feel versus writing in something else," the developer reflects. "However, when the railroad came along, all the farmers had to do was load it into the cars."

Implications for the Future

This experience raises profound questions about the future of programming languages in an AI-dominated landscape. The developer wonders what adaptations will be necessary to make AIs work better with Lisp, and whether the language can survive this new "worse-is-better" era.

Despite the challenges, the developer remains optimistic about Lisp's resilience. "Lisp has survived this worse-is-better internet era for decades," they note. "I wonder what we'll learn as it survives the AI era as well."

The Broader Context

The developer's experience reflects a larger trend in software development. As AI coding assistants become increasingly prevalent, the choice of programming language may shift from considerations of expressiveness, performance, or developer preference to factors like AI training data availability and tooling compatibility.

This shift could have significant implications for language communities, educational programs, and the overall diversity of programming paradigms. Languages that struggle with AI assistance may find themselves at a competitive disadvantage, regardless of their technical merits.

Looking Forward

The developer's journey from Lisp enthusiast to AI-assisted Python developer illustrates the practical pressures facing programmers today. While they express sadness about potentially abandoning Lisp, they acknowledge the economic realities of AI development.

"Now I'm thinking of rewriting it in Go," they conclude. "With AI, code is cheap, but only if you use a language for which AI has a lot of training data."

This pragmatic approach may become increasingly common as developers balance their preferences against the realities of AI-assisted development. The question remains whether language communities can adapt to these new constraints or whether the AI era will lead to further consolidation around a handful of mainstream languages.

The developer's experience serves as both a warning and a challenge: a warning about the potential homogenization of programming languages, and a challenge to the AI community to develop tools that can work effectively across diverse language ecosystems. As AI continues to reshape software development, the tension between technical excellence and practical accessibility will likely remain a central theme in the evolution of programming languages.