Prompt maximalism
Let's say you need an AI-facing software system to do something difficult. The difficult thing involves prompting an LLM. There are at least two broad approaches to achieving this:
- Use traditional software techniques. Maybe you can decompose the problem and use different prompts as appropriate; maybe you can use deterministic techniques to narrow a problem space or verify the LLM's output; maybe you can build an awesome API in a squeaky-clean backend that feeds better and better data to the LLM; and so on.
- You can just try to make the prompt better and better.
You can, of course, do both of these. But these strategies will, at least sometimes, run counter to each other. The main reason for this is that "make the prompt better and better" sometimes means "stuff more and more information into the prompt," including information that traditional techniques would dictate go into separate subsystems: behind APIs, in SKILL files, or wherever else.
If you have to choose, which of these is better? My only honest answers are (i) it probably depends on the application and (ii) I don't know. My gut usually leads me the first way:
- Using traditional, modular techniques has always scaled better.
- It's good to leave yourself the ability to tackle different subproblems with different tools.
- Those techniques offer better observability, which has always been important and is even more important now.
- As the prompt gets bigger, you use more context, which makes performance degrade (but I don't know how much).
But there are also good arguments for the latter approach, which I'll call "prompt maximalism:"
- It's nice and simple.
- The models are very good.
- The models are going to get a lot better.
- Seriously, don't bet against the models.
For all the buzz in the "here's the magic prompt that solves everything" genre, prompt maximalism is probably still underrated. Some programmers, certainly including me, might be quite AI-forward in some ways but still eager to use a full range of traditional techniques. (I suspect this only partly a sober professional judgment, and largely an aesthetic preference.) Prompt maximalism is worth taking seriously: it already gives some good results, and in at least some applications it's likely to get better and better, quickly.