In economics, deflation is the opposite of inflation—it's what we call it when prices go down instead of up. It is generally considered harmful: both because it is usually brought on by something really bad (like a severe economic contraction), and because in and of itself, it has knock-on effects on consumer behavior that can lead to a death spiral. One of the main problems is that if people expect prices to keep going down, they'll delay purchases and save more, because they expect that they'll be able to get the stuff for less later. Less spending means less demand means less revenue means fewer jobs which means less spending and then whoops you're in a deflationary spiral.
This is why we like to run the economy at 2% annual inflation—it's low enough to avoid the bad parts of inflation, but it encourages spending and leaves a nice healthy cushion between you and the deflation trap. (This is also kind of a huge problem for the White House, because everyone who's mad about inflation won't be happy 'til prices go down, but if prices actually went down, they'd probably be very unhappy for other reasons. So like. Good luck with that.)
This isn't really an economics blog post, though. I'm thinking about deflation because it parallels a recent pattern I'm seeing in startups. (So I guess you could call it a micro-economics blog post?) The basic mechanism is: (1) it's easier and cheaper to build software now than ever before; (2) it seems like it probably will keep getting easier and cheaper for the forseeable future; so (3) why bother building anything now, just build it later when it's cheaper and easier.
The Driving Forces
Technology has, of course, always been getting better over time (except for the Dark Ages and stuff). But Moore's law didn't magically make software development 2x faster each year, and it's not that much easier to make a web application with React than with Rails. In software, there's a confluence of forces leading to the feeling of rapid techological change that (to me) feels novel.
First, models getting better makes AI-based applications easier to build, because they can be simpler. More of the hard work can be offloaded on to the LLM, and you can expect it to follow rules like producing valid JSON. Workflows can have fewer steps and less retry logic, prompts can be less tortuous and exacting, and you don't have to be quite as choosy about what to dump into the longer context window. Of course, there's a Jevon's paradox type of thing here too, where models also make more ambitious applications possible, and then complexity returns in the form of tool calls, sub-agents, computer use, and so on. But building the same functionality has undoubtedly become simpler.
The second piece is that writing functioning application code has grown easier thanks to AI. Notice I said "functioning"—I'm no starry-eyed idealist about AI-generated code. But there's no denying that in the post-Claude-Code era, for simple to medium-hard tasks, you can usually get something that basically does what you want. Maybe in a painfully overwrought way that has 11 nested try-catch blocks and runs out of memory with 5 concurrent users. But it basically works! It does the thing! And for startups, that's often all you need in the near term. Do things that don't scale, right?
This development velocity is hugely important. It allows startups to waltz up to incumbents that have spent years building a dauntingly large suite of products and features, and kick them in the face. Used to be, you had to find a customer in SO much pain that they'd settle for a point solution to their most painful problem, while you slowly built the rest of the stuff. Now, you can still do that one thing really well, but you can also quickly build a bunch of the table stakes features really fast, making it more of a no-brainer to adopt your product.
This is what I'm calling technical deflation: it's getting easier and easier for startups to do stuff, and this seems likely continue at least for the next few years. (Importantly, this is true regardless of whether you think pretraining or RLVR have "hit a wall"—improvements on speed, cost, context length, tool use, etc. are all sufficient to keep the trend going.) So what are the consequences of technical deflation?
The Micro: Why We Will Never Have a Desktop App
... continue reading