Supermarket vs Farmer's Market Apples: The Hyper-Standardisation of Software

Apples at the supermarket are commoditised.

Supermarket apples are produced and designed for scale. Standardised for shape, taste, and nutrition. Designed for predictable and homogenous outcomes. Apples at the supermarket need to please everyone. Apples from the same batch cannot be differentiated, or else the less desirables ones would be left behind. We appreciate supermarket apples because we know what we are going to get, and we do not have to waste time selecting the right apple, because all apples are the same. We don’t think much about them, and nor do we want to. They satisfy us when we need them, but we don’t get attached to them.

Apples at the farmer’s market are different.

Farmer’s market apples are not produced for scale. Farmer’s market apples are valuable not because they are the same as others, but because they are different. Apples at the farmer’s market feel different, taste different, look different, and have a different nutritional quality to them. Each apple is an authentic creation of the producer that made them, the environment they grew in, and treatment they received. Customers go to the farmer’s market not for efficiency, but for quality and experience. We choose our apples not just because of the apple itself, but because of everything associated with the apples. Apples from the farmer’s market take on a different meaning than supermarket apples. This is what makes them different, but also more valuable.

The difference between supermarket apples and farmer’s market apples is an analogy for software:

Some software is designed for scale. Utilitarian, neutral, and generic to please and accommodate the largest number of users. This type of software is predictable, and meets basic user requirements without much more. Users of this type of software optimise for efficiency and ease of use. They don’t think much about specs and details, they go for the software that “just works”. This software is similar to supermarket apples: they provide a low-risk, low variance, and reliable outcomes for the user.

Other software is designed to make a difference. Experiential, opinionated, and personal to connect uniquely with the users that care. This type of software has an authentic quality to it, and often presents the user with features or details that go beyond the status quo. Users of this type of software optimise for craft and quality. They look for moments of delight, and go for software that differentiates. This software is similar to farmer’s market apples: they add a premium onto the function of the underlying software through brand, experience, provenance, and uniqueness.

Both types of software are valuable and have their place, but in a world of LLMs, design systems, vertical integration, open source libraries, and concepts spreading like memes on social media - the software landscape is becoming more like a grocery store.

first, LLMs.

LLMs are the equivalent of mass apple producers with economies of scale. They will outpace, outnumber, and outproduce any small producer of software. Similar to mass apple producers, LLMs are trained to produce the most predictable outcomes (in text, images, code, etc.), and can be fine tuned to appeal to the largest number of users. As a result, we can expect LLM software to be the equivalent of supermarket apples: standardised and efficient, but lacking the nutritional quality and emotional connection associated with farmer’s market apples.

While most users appreciate software with unique qualities (at least I like to think so), the economic incentive to reduce cost and maximise growth makes it more likely that LLM software will be mass produced and distributed. LLMs make it harder to justify the incremental cost of doing something great and authentic. Why spend hours on crafting new interface paradigms and tweaking components when you can generate average ones for free in seconds?

Moreover, LLMs add a layer of disconnection between the user and its creation. LLMs abstract the software designer and developer from the output, just like a supermarket chain disconnects you from the producer that put in the time, craft, and effort into producing its apples. As a customer, you only interact with the output, and cannot trace back its provenance.

second, design systems.

Design systems provide design teams with guidelines and pre-set libraries of components and styles to execute faster and consistently at scale. Design systems are designed to converge and constrain creativity, not to expand it.

As products develop and teams grow, organisations increasingly rely on design systems as the foundation to build on. The design system starts to precede creation, instead of the other way around. The cost of re-imagining things increases over time as the design system continues to expand, and new ideas become constrained by outdated guidelines.

With an increasing amount of tooling to automate systematisation and platforms that make it easy to replicate, the consistency from one organisation ripples out to another, and our products start to look and feel the same.

third, vertical integration.

Major players with large sums of capital are taking over production and distribution of software through vertical integration, making it easier and cheaper to engage with their products with bundled features and pricing. As these corporations grow and increase their digital footprint, the products and services they vertically integrate are turned into one unified version with a singular look and feel.

For customers with long lists of software requirements, picking software like apples at the farmer’s market one by one, and paying for each independently is not feasible. Vertically integrated software is like the large supermarket chain that prices out every small producer, making it impossible to compete. The cost and convenience advantage of the vertically integrated solution becomes impossible to ignore.

fourth, open source libraries.

Open source libraries are making software creation more efficient and accessible. Similar to design systems, they enable anyone to fetch the functionality they need without having to develop it from scratch - like a Betty Crocker cake mix. Developers can just add in the extra ingredients, and software is ready for production.

While open source libraries are a blessing for developer productivity and to accelerate technological progress, they make it too easy to skip or override first-principles coding. We opt for widely used libraries instead, and re-create what has already been done.

fifth, social media.

Humans are memetic creatures. We learn through observation and imitation, and trust social consensus as a shortcut to come up with our own thoughts and opinions. Whereas we each used to evolve in our own siloed communities and geographies, social media has unified the entire global internet into one large community in which social signals can flow. As a result, the world is becoming increasingly homogenous in culture, thought, and ideas.

Implications of this are broader than just the way we produce software, but the software we choose to create and engage with is becoming a reflection of the average user preference. Social media is like a supermarket chain, and algorithms are like their merchandising directors. Algorithms optimise for what is most popular and engaging, and as a result, engage in selective breeding of the most common features and products. We end up with more of the same (like AI chatbots), rather than going for something unique.

The result of hyper-standardisation in software is a world in which software appeals to everyone, but not every one.

I am interested in preserving farmer’s market apples and supporting them.

Supporting farmer’s market apples requires taking more time to connect with the stories of the producers, understanding where they come from, and their practices. It requires a different intention, and different incentive structure to thrive. It requires an embrace of what is unique and personal, of what places value on craft and nutrition, and of what takes time and effort.

Software is similar - finding the best applications and software requires taking the time to go beyond category heuristics, and explore what else exists. You might be surprised by the difference it makes to have a team behind a software that truly cares about your experience, and is willing to go the extra mile to make it different.

By supporting farmer’s market apples, we support and maintain diversity. We create a more nutrient dense network of software and tools, and keep our personal computing our own, and not standardised for corporate interest.

My hope in writing this is not to get rid of supermarket apples or to replace them with more farmer’s market apples. I like utilitarian software that I don’t think about much and that just works when I need it, but I also like software that provides me with a unique experience I can engage with and get attached to.

I care about authentically produced software because that it is where innovation comes from. Innovation does not come from replicating and standardising everything, it comes from doing things differently.

Producing authentic software requires challenging ourselves to go through the friction of the creative process. To rethink things, and to go against our lazy instinct by not always going for the shortcuts.

To create from imagination (not LLMs), to design from a blank canvas (not design systems), to convert it with custom code (not open-source library), to distribute as a standalone (not vertically integrated), and to create from unique intuition (not social media signal).

My hope in writing this is therefore to support innovation and creativity. My hope is to raise awareness about farmer’s market apples, and to remind ourselves to think about them more often.

Perhaps just one day, you take the time to explore and experience what it is like to browse independent software creations. Perhaps you will see the difference. Perhaps you will appreciate the difference in nutrition. Perhaps you will find your own unique and perfect apple.