New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
New American Economics Part One
Liam Fitzgerald| CEO
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/
Pre-industrial software
The first thing we must understand, dear reader, is that our current software production system is not merely pre-industrial – it is proudly pre-industrial. It does this in an attempt to hide the fact that the emperor has no clothes. It doubles down on its self-aggrandizement to systematically obscure what it does, which is not much at all. You are probably familiar with the hacker news comment on the dropbox launch post, implying that the core functionality could be replicated with a single line rsync command. This is uncritically used as a parable about how good startup ideas are not necessarily technically interesting problems. Take a moment to consider what this implies.
What it implies is that our entire software economy is built on an elaborate game of three-card monte. The real sleight of hand isn't in the technology – it's in convincing everyone to look at the wrong thing. When that Hacker News commenter pointed out the rsync solution, he wasn't just being pedantic; he was accidentally revealing the foundational lie of modern software production.
Consider: if Dropbox's core functionality could indeed be replicated with a single command, what exactly are those thousands of engineers doing? What is being produced by those millions of lines of code? The answer, of course, is complexity itself. They are building ever more elaborate frameworks to manage problems that they themselves created. It's the software equivalent of digging holes and filling them back up, but with stock options.
A note on terminology
You may notice that I use the terms “software industry” and “technology industry” as if their referents were disjunct sets. I do this because they are. The “technology industry” is about the *creation* of technology, forming and productising new technology for the benefit of some consumer. The “software industry” however, takes the waste product of the technology industry and reheats it, hybridizes it, and serves this to you as if nothing is wrong in order to perpetuate the Paul Graham Essay-Industrial Complex. There is no technology being created when somebody deploys a ChatGPT wrapper. This is just the cantillon effect for people that are willing to deal with the psychic damage incurred by trying to keep Elasticsearch running.
Consider the archetypal "tech startup" of today. What you'll find is not a laboratory of innovation, but rather a sort of digital arbitrage operation. They're not discovering new fundamental principles or creating new technologies – they're performing regulatory and attention arbitrage, exploiting the gap between what venture capitalists think is valuable and what is actually valuable.
It’s so easy to fall in love with programming when you do an Introduction to Computer Science course. You can “just do things” . You bang out some fun little command-line application over a weekend. But now you want to show your friends. You’ve been catfished. Weeks navigating a byzantine maze of persistence, authentication, Electron, React, React Native… for what?
This is interminable violence on the mind, and it happens to basically every programmer. The tragedy is that we normalize this violence because we get paid to look the other way.
The software industry has become expert at what we might call "innovation theater" – the practice of making old technology look new through the liberal application of React components and Medium blog posts. This is why every "innovative" startup's tech stack looks identical: a MongoDB instance crying out in pain, a Redis cache that's one network partition away from catastrophe, and enough Kubernetes manifests to wallpaper the Pentagon. None of this is technology – it's fashion.
Why does this happen? There is a kind of convergent evolution occurring everywhere you look in software. When a system of software gets too large to reasonably be maintained by a single team, the typical response is to split the system into several system and create a team for each. This is known as the “microservices” pattern.
But why is our software so large? Is the number of things that your phone could do in 2015 really that much higher than what it can do now?
Let’s step back a moment. Software has become enormous because it has to scale to millions of users. In order to do this, we tear our systems to tiny little pieces and poke at the shards until they resemble a functional system. Now, almost every system has a “Users” service, keeping track of PII, usernames, passwords and the like. The average person has somewhere between 100-240 online accounts. Modulo passwords, this information is basically identical.
This is utterly insane. The same thing has been written more than 150 times over, just to store subsets of the same data. Claude eyeballs the number of developer hours spent implementing authentication systems in the billions.
This happens because modern software systems are distributed, but still centralized. They are centralized to preserve the business’ monopoly on the information inside the software systems, which is often their moat and/or business model. This is convulsive feeding frenzy levels of time-preference. However, the entire software industry is structurally unable to comprehend their own stupidity because their very existence depends on this not being understood.
This is a tragic waste, and I have decided to end it all. …no, not like that. A clearer form of that statement would be: “I have decided to end the software industry as it currently exists”. But, you ask, isn’t software going to continue to eat the world?
I suspect there’s a case of mistaken identity here . Yes, something is eating the world, but it’s not the software industry. It’s just plain old capitalism. Nothing wrong with that. Capitalism needs to grow up and eat the software industry too.
Anyway, ending the software industry. The plan is simple:
Software Fordism
The plan is to bring the entire field of software into the industrial age and in doing so, have the occupation of “programmer” go the same way as the elevator operator.
"But software is different!" they cry. "You can't industrialize creativity!"
This is, of course, exactly what every guild said before their craft was industrialized. The scribes said it before the printing press. The weavers said it before the power loom. The carriage makers said it before Ford.
At some level, improvements in frontier AI models should get us to a double digit percentage of layoffs, but we can do better. The ideal case would be a small village somewhere inland in California, where America’s entire stock of professional programmers are sequestered away in a small village of 100-200 people or so.
Picture it: a small village in the Sierra Nevada foothills. Population: 157 programmers. These aren't just any programmers – they're the last of their kind, like master craftsmen maintaining the last mechanical watches in a digital age. They're the ones who understand how the machines think at their deepest levels, the ones who can still write assembly when needed, the ones who actually understand what a monad is beyond just repeating the burrito analogy.
This isn't a dystopia – it's an optimization. Just as we don't need millions of people who understand how elevators work to have a functioning elevator industry, we don't need millions of programmers to have a functioning software industry.
There are 4.4 million software engineers in North America alone. They are currently consigned to an intellectual roach motel: young ambitious minds check in, but they don’t check out. They are lost beyond the event horizon of an industry increasingly occupied with dealing with the consequences of its own stupidity and short-sightedness. We’re going to free them all.
A Functioning Software Industry
Well, to call it an industry is somewhat of an exaggeration. That’s like calling Sales and Legal part of the “English industry”. We already have a preview of what our programming-without-programmers would look like and it already works for millions of people.
Excel.
Excel is not just a tool. It is the only real programming environment that has ever actually worked for normal humans. Everything else is either a toy or a fraud.
Consider what actually runs the world's economy. Not your trendy blockchain protocols or your web3 smart contracts. Not your microservices or your serverless functions. The world runs on Excel spreadsheets, passed hand to hand like samizdat in the Soviet Union, containing the actual operational knowledge of every major institution.
Much like the Soviet Union, the difficulty with spreadsheets is getting things in and out. The issue is so bad that human genes have been renamed to avoid Excel import shenanigans1. But what if the data never left the spreadsheet? What if, cradle to grave, the lifecycle of any piece of relevant data was all inside the spreadsheet?
Something to think about.
1https://www.progress.org.uk/human-genes-renamed-as-microsoft-excel-reads-them-as-dates/