The 'Lisp curse' describes a historical phenomenon in programming where the extreme power and flexibility of the Lisp language allowed developers to create custom solutions so easily that they often bypassed shared libraries. Because it was faster to write a unique solution than to learn the specific abstractions and 'way of thinking' of others, Lisp ecosystems often lacked the centralized frameworks found in other languages. This isolation led to a lack of reusable components, as developers preferred to 'reinvent the wheel' in private, often resulting in code that was difficult for third parties to comprehend or maintain.
Tim Zöller argues that Large Language Models are now bringing this curse to mainstream ecosystems like Java. As LLMs make it cheaper and faster to generate functional code from a few prompts, the incentive to research, read documentation, or learn the interfaces of established libraries diminishes. If a developer can generate a custom module in 20 minutes for a few dollars in tokens, the friction of integrating a stable, community-tested library—which requires understanding its specific API and versioning—becomes a significant hurdle. This shift could lead to a more individualistic development model where software is built in isolation rather than through collective problem-solving.
This trend poses a dual threat to the open-source model. First, a decline in library usage reduces the feedback loop for maintainers, making it harder to sustain existing projects. Second, the creation of new libraries may stagnate; the 'hard part' of open source—modularization, hosting infrastructure, and maintaining backward compatibility—becomes less appealing when a developer can simply generate a disposable, local module tailored exactly to their immediate needs. While some developers argue that LLMs actually make it easier to integrate existing libraries, others warn of a 'sea of slop' where AI-generated code makes individual human contributions harder to distinguish or value. The trade-off is a move toward extreme customization and speed at the potential cost of the stability and collective knowledge provided by mature software ecosystems.