Link Search Menu Document

Revisiting the Lisp Curse

Posted: Nov 5th, 2026 - Modified: Nov 15th, 2026

This paper was presented in a very preliminary form on November 5th, 2026 at the Missouri Valley Econ Association Conference. Here are the slides from this presentation.

The Lisp Curse

There’s an old story that’s been stuck in my head lately.

As a computer science undergrad, they had us do little projects in all sorts of languages, and one of these language families was Lisp. It’s an astoundingly powerful programming paradigm. Programming a symbolic differentiation engine felt as natural as printing “Hello, World.” It was an almost revelatory experience, and then I never used it again. That’s strange.

I don’t think I’m the only one who had this experience.

xkcd 224: Lisp

xkcd: Lisp by Randall Munroe, CC BY-NC 2.5.

Well, back around that time, I came across an essay with a very interesting explanation of why Lisp isn’t more widely used. Rudolf Winestock’s essay, “The Lisp Curse,” argues that Lisp, despite its power, its flexibility, its elegance, isn’t more widely used because it’s just too good.

In C++, you need some tool, you go figure out what other people are using. If it’s not quite right, you contribute to it. Easy peasy. Lisp, you need a tool, spin it up, good enough. Move on with your day. But then without that friction, we never build up a stock of common shared systems.

Lisp is so powerful, the essay argues, that problems which are technical issues in other languages are instead social issues in Lisp.

Lisp is so powerful that problems which are technical issues in other programming languages are social issues in Lisp.

-Rudolf Winestock, The Lisp Curse.

Now, it’s worth pointing out that for Lisp in particular, it’s maybe not actually true. After this essay was written, Lisp did become quite popular again. It’s widely used by all sorts of companies. We’ll come back to that later.

But this story popped back into my head earlier this year. Doesn’t this sound familiar? This idea that things being too easy - our tools being too powerful - might actually make us lose out on something?

Indeed, we have this new technology, AI agents, which make it a lot easier to do a lot of things. They make it cheaper to build and cheaper to learn. It’s most obvious with computer code, of course, but a lot of professions have a lot of knowledge work which AI agents are capable of accelerating and automating.

So, could this prevent us from developing shared systems and shared knowledge? Could it become so easy to do things good enough on our own that we don’t end up with anything really good?

A Model of Tacit Knowledge

The starting point is that we’ve got to assume AI can learn things. It can expand. It can automate knowledge tasks. But at the same time, I don’t just want to say, well, it’s going to instantly be able to do things. So here’s a simple model of learning by doing and failing. I think this is how people learn, and I think this is how systems learn as well.

A protocol has capability $z$, and tasks have difficulty $x$, drawn uniformly from $[0,1]$. If $x \le z$, the task succeeds and produces one unit of value. If $z < x \le z + \Delta$, capability increases by $x-z$.

Diagramatic illustration of the learning window described in the above paragraph. Very hard tasks are too difficult to learn from, easy tasks are already solved, and there's a narrow window in which you can learn from your failures.

The “protocol” here could be literal code, some sort of protocol in a business, or just an individual person’s workflow.

You learn when a task is just a little bit beyond your capability. Capital $\Delta$ is the learning window, representing how broad a range of experiences you can learn from. If a task is harder than $z + \Delta$, you just fail and, eh, what can you do about it?

If you create a new protocol, there’s some amount of explicit knowledge $b$ that you can learn without doing, simply by paying fixed cost $F$ to start at $z=b$.

Alternatively, you could defer a task to an existing protocol, a “specialist”. If you do so, then you’ll benefit from their presumably higher capability, but there’s some real cost of service $c$, and the specialist learns from your failures instead of you. (Being able to make your own mistakes is valuable if you want to be more capable in the future.)

Finally, tacit knowledge becomes obsolete at rate $\delta$, and cases arrive at some rate $n$ ($n=1$ for your own bespoke system and $n=N$ for a specialist with $N$ users).

For this functional form, things get a bit messier at very high levels of capability, but if $z \le 1-\Delta$, the net learning rate is:

\[\dot z= \underbrace{\frac{n\Delta^2}{2}}_{\text{learning from failures}} - \underbrace{\delta(z-b)}_{\text{obsolescence}}.\]

and the steady state is:

\[z^*=b+\frac{n\Delta^2}{2\delta}.\]

Graph illustrating the capability over time for systems with different numbers of users. The "specialist" starts at the same place as everyone else, but can grow faster and to a higher level because they see more cases.

Specialists here, instead of being born with higher skill, see more cases and so they can sustain a higher capability in the long run.

Efficient Shared Systems

The first question is when do we want people to share a system? When is it efficient?

Starting from scratch with $N$ potential users, the shared knowledge protocol specialist will be more efficient than individual bespoke solutions as long as the higher, faster path of growth is enough to justify the real service cost.

\[F \geq F_{\mathrm{eff}} \equiv \frac{c}{r}-\frac{N\Delta^2}{2r(r+\delta)},\]

This happens when the cost $F$ of building a new system with baseline capability is greater than or equal to $F_{\mathrm{eff}}$, which I call the efficient threshold.

Click to expand the derivation.

If a protocol starts at capability $z=b$ at $t=0$, and has case arrival rate (n), then its capability grows according to:

\[z(t)=b+\frac{n\Delta^2}{2\delta}(1-e^{-\delta t}).\]

If the discount rate is $r$, then discounted output per user is therefore:

\[\int_0^\infty e^{-rt}z(t)\,dt =\frac br+\frac{n\Delta^2}{2r(r+\delta)}.\]

If $N$ individuals each pay fixed cost $F$, and receive cases at rate $1$, then discounted welfare is

\[W_{\mathrm{private}} =\frac{Nb}{r}+\frac{N\Delta^2}{2r(r+\delta)}-NF.\]

If a single specialist serves the other $(N-1)$ users, in addition to themselves, then the fixed cost is only paid once, and the specialist can build up a stronger capability, but serving the other $(N-1)$ incurs real cost $c$ for each of them:

\[W_{\mathrm{shared}} =\frac{Nb}{r}+\frac{N^2\Delta^2}{2r(r+\delta)} -F-\frac{(N-1)c}{r}.\]

Subtract:

\[W_{\mathrm{shared}}-W_{\mathrm{private}} =(N-1)\left[ F+\frac{N\Delta^2}{2r(r+\delta)}-\frac{c}{r} \right].\]

For (N>1), sharing is more efficient when the rightmost term in square brackets is non-negative, and this occurs when

\[\boxed{ F\geq \frac cr-\frac{N\Delta^2}{2r(r+\delta)} }\]

When do we adopt a shared system?

The next question is when can we build one of these shared systems? If we can always just implement the efficient allocation, then a technology which makes it easier to build things won’t do us any harm. So instead, I’m going to take a leaf out of Fuchs, Garicano, and Rayo (2015)1 and ask which shared systems can be supported by non-negative spot pricing.

Let $V_{\mathrm{build}}$ be the present discounted value of building your own system from scratch.

\[V_{\mathrm{build}} =\int_0^\infty e^{-rt}\left[b+\frac{\Delta^2}{2\delta}(1-e^{-\delta t})\right]dt-F.\] \[V_{\mathrm{build}} =\frac{b}{r}+\frac{\Delta^2}{2r(r+\delta)}-F.\]

If you haven’t built your own system yet, the maximum you’re willing to pay for a specialist with quality $z_S$ is:

\[p=z_S-rV_{\mathrm{build}}.\]

The maximum you’re willing to pay to defer to the specialist is the quality they give you minus the discounted value of building your own system. That’s the price that makes you indifferent, as you’re delaying your own knowledge acquisition.

For a brand new specialist:

\[p_0=b-rV_{\mathrm{build}} =rF-\frac{\Delta^2}{2(r+\delta)}.\]

Suppose the specialist can offer services for free but cannot pay users or commit to future prices, then:

\[p_0\ge0\quad\Longleftrightarrow\quad F\ge F_{\mathrm{adopt}}\equiv\frac{\Delta^2}{2r(r+\delta)}.\]

If the fixed cost is above $F_{\mathrm{adopt}}$, the adoption threshold, then we get spontaneous adoption of a shared system, even when the specialist isn’t actually better than anyone else yet.

But when the fixed cost is below this threshold, the specialist would actually have to pay other people for the privilege of doing their work and learning from the resulting failures.

Three Regimes And the Effect of AI

With two thresholds, we have three potential regimes.

If $F < F_{\mathrm{eff}}$, then separate bespoke protocols are efficient. Everyone can and should just do things themselves.

If the fixed cost is high enough, if \(F \geq \max\{F_{\mathrm{eff}},F_{\mathrm{adopt}}\}\), then shared protocols are efficient and can easily arise spontaneously.

But if the fixed cost lies between these two thresholds, if \(F_{\mathrm{eff}} \leq F < F_{\mathrm{adopt}}\), then a shared protocol is efficient but cannot be created with non-negative spot prices. We want to defer to a specialist, but it’s hard to build that shared system from scratch.

AI technology can move us between these regimes in three different ways.

Firstly, it can lower the fixed cost, $F$. AI can make the implementation of a new protocol based on explicit baseline knowledge much, much cheaper, potentially moving us between regimes.

Secondly, it can decrease real service cost, $c$, easing the frictions of using a shared specialist. This lowers the value of the efficient threshold, $F_{\mathrm{eff}}$. This won’t make us worse off, but could mean that the gains to the new technology are limited by a standard coordination problem.

Thirdly, AI technology could accelerate learning by expanding the learning window $\Delta$. When $\Delta$ increases, the efficient threshold falls and the adoption threshold rises. The gap between these thresholds is where we find the proverbial Lisp curse.

2D diagram illustrating the three regimes with construction cost, F, on the horizontal axis and the learning window delta on the vertical axis.

Note that none of these technological changes make any of our options worse. Cheaper implementation and faster learning enhance the value we get from either a shared specialist or from individual bespoke solutions.

Graph illustrating the Lisp curse with two curves. One represents the value of deferring to a shared specialist; the other represents the value of a bespoke individual learning system. Both curves are increasing in the learning window, capital delta. A bold path overlaid on the curves illustrates the spot transaction equilibrium. As delta increases, the value of the shared system first overtakes that of the bespoke systems, and the spot transaction equilibrium switches to a shared system. But at very high learning rates, people switch back to bespoke systems, even though the shared system is far more efficient.

As the learning rate increases, the potential gains from defering to a specialist rise, of the specialist rises faster and people may spontanesouly switch from bespoke protocols to using the shared specialist system.

But then, as learning becomes very easy, the Lisp Curse takes hold. The potential gains from building up a specialist are larger than ever, but individuals build up their own “good enough” bespoke systems instead.

Hence if the technology of learning is too good, output becomes limited not by technical constraints, but rather by social ones.

Policy Implications

Okay, so if we make it too easy to build and learn, then we can get stuck in a worse equilibrium. What do we do about it?

You could mandate or subsidize shared standards. It’s something governments often do.

You could tax bespoke systems. That’s impractical and hard to monitor. You could instead try gatekeeping by making it just harder or shameful to do things yourself.

Maybe we could abolish data privacy laws and make it so whenever you use AI, it feeds the data back to the lab so they can build their own shared systems and capture all the residual. Maybe. It’s a bit dystopian, but it could be efficient.

Or we could dodge the adoption threshold by saying that we do have some commitment mechanism. A shared specialist system can have a negative spot price because the users are giving up the value of implementing things themselves and learning from the experience. There’s a genuine cost to making yourself dependent on a third-party in that way. But if the specialist can commit to a permanent low price, then users can be more confident about making themselves dependent on that shared system. One example of this solution in use is software released under a “copyleft” license, in which the the creator relinquishes the right to prevent others from sharing and using the software.

Another way to avoid the Lisp curse is to relax our assumption that an individual user has the same rate of use cases as anyone else. A large user’s own cases can build expertise well in excess of what the typical user can develop. If this difference in expertise becomes large enough, then it may be attractive to others to switch to that well-developed system. Higher capability supports a high spot price, and a shared specialist system can arise by simply being useful to one particular outstanding user.2

And in fact, Lisp itself doesn’t really suffer from the curse. A dialect of Lisp called Clojure has seen fairly wide use in a number of industries in the years since “The Lisp Curse” was written, and is the de-facto “standard” way to write Lisp, so the lore goes. The curse has been overcome, and in the case of Clojure, we can see the application of some of the potential solutions above. Rich Hickey, its “benevolent dictator for life,” spent two years on sabbatical developing Clojure to the point where it was not just good enough, but so good that it made more sense to learn how to use Clojure than to spin up your own bespoke little tools. And in building Clojure, Hickey himself relied on shared systems, with the language built on top of something called the Java Virtual Machine, which allows programs to operate across many different environments.

One final option to avoid the Lisp Curse would be to just make AI worse, but AI makes all of our options better, so that’s perhaps short-sighted. A closely related paper is “AI, Human Cognition, and Knowledge Collapse” by Acemoglu, Kong, and Ozdaglar (2026). In their model, individual learning effort helps build general knowledge, and agentic AI recommendations can lead to the collapse of shared knowledge by crowding out individual effort. The policy solution in their model is Butlerian Jihad temporary suppression of AI technology followed by a cap on precision. They suggest avoiding the perils of knowledge collapse by making the technology worse.

But I think this is the wrong way to think about AI. I’m optimistic that AI can enable both individuals and shared systems to grow in capability. I don’t think there’s a technical issue where AI use necessarily shuts down learning. I think the risk is that AI is so powerful that what were technical issues can become social issues. And that’s the Lisp curse.

  1. There are many papers on learning by doing, but the primary inspiration for the model in this essay is actually Fuchs, Garicano, and Rayo (2015), Optimal Contracting and the Organization of Knowledge. In their model, capability level $z$ is exogenous and fixed, and you can dispatch a task to the expert after failing it yourself. But their approach of limiting the price structure for knowledge services gave me a tractable handle by which to introduce the Lisp Curse into my model. ↩

  2. Consider Amazon Web Services as an example. ↩