Software Gets Personal: An Introduction

Metadata

• Author: Fabien Girardin
• Full Title: Software Gets Personal: An Introduction
• URL: https://medium.com/pr%C3%B3ximo-presents/software-gets-personal-an-introduction-1175c7f1edbd

Highlights

• The micro-tools made by “anyone” for themselves and the people around them (View Highlight)
• In 2019, a friend reached out with a simple request. As a start-up founder and an avid cyclist, he needed a simple tool to share bike ride summaries on social media. Nothing fancy, just a clean, shareable map animation. As the experiment worked, I decided to make the tool accessible to anybody with a similar need. It worked. Other cyclists saw it, and then hikers, navigators, runners, anybody who records GPS trails wanted to create their own map animation. That quick solution has become Rumbo, with over 80,000 videos produced by thousands of users and counting. (View Highlight)
• I didn’t start Rumbo to “revolutionize” or “disrupt” anything. I certainly did not plan to build a commercial product. I know how to build software, but I never fall into the distraction that every software idea must scale. I just solved a specific problem for a friend. And yet, here we are, somewhere in that uncomfortable zone between a personal tool and a commercial product with more than 500 Pro customers, raising questions I never intended to face about maintenance, scaling, and sustainability. (View Highlight)
• Rumbo is part of what I call “personal software”, a fourth category of software that sits alongside commercial software (built for scale), boutique software (tailor-made for companies and organizations) and open source software (structured for collaboration). Personal software is a solution that is good enough for a niche audience. It’s software made by “anyone,” for themselves and the people around them. This is fundamentally different from software designed by professionals organized in teams for paying customers. (View Highlight)
• The structure of Personal, Commercial, Boutique and Open Source software. Other models exist like shareware, freeware, public domain, but these four capture the dominant patterns. (View Highlight)
• (View Highlight)
• The schema above illustrates the four main software categories that differ not only in what they produce, but in how makers and users relate. Personal software keeps everyone in one circle. Boutique and commercial software place a company between contributors and users. One collaborates with a few, the other serves many. Open source distributes contributors and users roles across a decentralized community. (View Highlight)
• Creating software has been the domain of trained professionals like me. AI is changing that. Today, it is becoming more accessible to anyone who is “programming-adjacent” (e.g. an academic who builds their own tools, a creative who experiments with code, an expert who wants to try building a solution). Soon, more of us will have the possibility to build our own micro-tools, not as programmers, but as people with ideas or problems to solve. (View Highlight)
• This essay maps that emerging terrain: what personal software is, how it becomes popular, what is changing, why it matters, and what motivates its makers. It is also an invitation to an attitude and practice to rethink software that is beginning to form with AI. (View Highlight)
• Personal software is not entirely new. People have been building their own solutions for decades. Some of my favourite examples come from the early Mac indie scene, like NetNewsWire, an RSS feed reader I still use today that Brent Simmons originally built in 2003 for himself and a few friends. This ethos has appeared under many names over the past decades. (View Highlight)
• In 1973, at the dawn of the Personal Computer era, philosopher Ivan Illich introduced the idea of tools for conviviality, which empower individuals to shape their own technological environment with autonomy and creativity. Later in 2004 during the mobile and social media revolutions, Clay Shirky reflected on his students work at NYU’s Interactive Telecommunications Program (ITP) and described what they were building as situated software designed for particular social contexts. Today, people talk about single-player software, disposable software, malleable software, personal micro-software, or one of my favorites snowflake software. The terminology varies, but the essence is the same: there’s a type of software that does not fit neatly into the well-known categories. (View Highlight)
• I prefer “personal” because it describes what the software creates, not just what it is. It emerges from a personal relationship (a friend’s request, a colleague’s frustration) or it establishes one. Each Pro subscriber of Rumbo left me a message explaining why they signed up. The app is part of a relationship, not a transaction. (View Highlight)
• According to my experience, observations and research, what distinguishes personal software from its commercial, tailor-made and open source cousins are 3 key characteristics: (View Highlight)
• What makes personal software distinctive is proximity: it is made by people who understand the problem more deeply than the underlying technology to solve it. For this reason alone, broadening who can make software is essential. (View Highlight)
• For instance, novelist Robin Sloan built BoopSnoop, a messaging app for his family of four. It captures photos and videos, sends them without editing, and messages disappear once viewed. For years, it has maintained four daily active users with zero churn, a resounding success by its creator’s own measure. Sloan’s essay about the project coined the term “home-cooked software”: software made like a meal, for the people you love, with no need to scale. (View Highlight)
• I experienced the challenge of democratization firsthand in 2012 with Quadrigram, a visual environment built within the design studio Bestiario to let people manipulate and visualize data without writing code. While it opened new possibilities for non-technical professionals like designers, analysts and journalists, it also revealed a limit: the promise of software made by “anyone” is not really for everyone. Even with highly visual tools, creating software still requires skills in abstraction that most people do not naturally possess. The vision of software made by “anyone” remains powerful, but it is not evenly accessible. (View Highlight)
• In 2023, OpenAI’s co-founders Andrej Karpathy famously claimed: “The hottest new programming language is English.” It marked a transformative moment in software development where Large Language Models (LLMs, including multi-modal, visual models) could effectively link natural language with functional code. (View Highlight)
• LLMs serve as authors generating code. AI coding assistants and agentic coding based on LLMs (Cursor, Floot, Claude Code, Replit, OpenAI’s Agent Builder) leverage a wide amount of code repositories and web conversations to generate code from natural language. They also use both open source and private libraries and frameworks to automate software production. Some call this evolution the rise of industrial software. (View Highlight)
• (View Highlight)
• Today, there is a large amount of online tutorials, forum conversations and YouTube videos teaching non-professionals how to create software with LLMs. For instance, inspired by OpenAI demos at the release of GPT5, the tech popularizer Azeem Azhar described in his Exponential View newsletter how his team without specialized knowledge had built a Korean learning app. Similarly, tech journalist Kevin Roose, who does not code, built a replacement for his favorite read-later app in under three hours. This pattern repeats across social media. Designers, product managers, academics sharing their small apps and simple tools that would have needed a team of developers a few years ago. Together, they explore a wide terrain of new possibilities demonstrating how to create software without formal training. Similar developments are taking place in organizations that I will describe in more detail in a follow-up chapter. (View Highlight)
• In some cases, AI models (including LLMs) are components embedded within applications, wrapped by code that provides structure, guardrails, and interfaces. People integrate these AI models into their solutions using a mix of traditional code, visual programming and natural language (i.e. prompts). (View Highlight)
• When existing tools are too generic, too expensive, or too complex, or when no tool exists at all, people look for ways to build their own. Personal software emerges from this impulse to shape one’s tools: fixing frustrations, automating tedium, augmenting capabilities, creating something new within a specific practice. (View Highlight)
• In a world defined by software built for a generic user, there is something powerful about creating tools to meet one’s own needs. Following the spirit of the Do-it-yourself (DIY) movement, personal software may lack the consistency of professional products, but it develops a different quality: the charm of something made by hand, for oneself, friends, family and colleagues. Personal software is built by and for real people with names and contexts. As Robin Sloan demonstrated with his family app BoopSnoop, software can be meaningful and valuable without pursuing commercial success. The measure of success becomes people empowerment, not financial growth. (View Highlight)
• Because personal software does not aim at robust, perfect, or complete results, the code itself has little transferable value. It does not cover edge cases and it may only work in a specific context. For these reasons, It rarely converts directly into open-source projects or commercial products. (View Highlight)
• The real value emerges when people experiment, learn, and share not the code, but the knowledge. Creators of personal software describe how they solve problems, what they learn from a small set of users, what works and what does not, what they imagine building. This knowledge and creativity circulates more through language (e.g. conversations, online posts, and video demonstrations) than code repositories. The impact is difficult to track with conventional indicators and remains largely invisible. (View Highlight)
• The media and software company Every has built part of its business model around this principle. They offer five AI tools each produced by one person: Lex for writing, Spiral for content repurposing, Sparkle for file organization, Cora for email, and Monologue for voice dictation. These products first emerged from personal needs of the 11 employees, then found resonance with their audience. They are bundled into a $200/year subscription alongside Every’s in-depth writing on AI. They are not as polished as commercial software from a dedicated product company. Rather than building products for growth and generic users, Every builds products for itself and within its community of subscribers. (View Highlight)
• This inverts the conventional relationship between software and users. Commercial software extracts value from a user base. Personal software creates value within a group. The distinction matters: one scales by acquiring customers, the other strengthens by cultivating relations. (View Highlight)
• This essay has mapped a terrain that is transforming. We are standing in what serial entrepreneur Lisa Gansky calls the “No More / Not Yet”: the traditional models are challenged, but the alternatives remain unfinished. Personal software is an invitation to shape what comes next. (View Highlight)
• For decades, software has been something most people consume, not create. The software industry measures success through scale: users, revenue, growth. That relentless pursuit of scale has produced systems that serve their own logic rather than the people using them. The tools we use daily are shaped by distant teams optimizing for markets we happen to belong to. Personal software inverts this relationship and the measures of success: it is built by the people it serves, small enough to comprehend, close enough to control, good enough to fit. (View Highlight)
• The barrier to software creation has lowered, but it has not disappeared: even with AI assistance, systems still demand comfort with abstraction. LLMs are expanding the circle of who can build but they do not erase the circle entirely. Projects are easier to start, but making them fit still requires ability and expertise. In the next chapter, I look at the new creators that shape the practice: their approach, their work, their skills. (View Highlight)
• For organizations, personal software raises strategic questions. When employees can build their own tools, what happens to governance, human resources, procurement, and institutional knowledge? How do you support this capacity without losing coherence? How do you capture the learning that emerges from small experiments? How do you measure success? I explore these questions in the final chapter. (View Highlight)
• Rumbo started with a friend, a problem, and a few days of work. Many well-known software companies and other commercial businesses start that way (e.g. eBay, Slack, BlaBlaCar, Wallapop, etc). The difference now is that more people and organizations can shape their own tools with AI, forming a long tail of thousands of micro-tools. (View Highlight)
• . Built for immediacy Personal software begins with an immediate need, a problem faced by its creator or someone nearby (e.g. friend, colleague). It’s not designed for a market, but for a moment. It solves something specific without trying to generalize or anticipate future use. If others find it useful, it can accidentally break toward commercial territory, but that’s a side effect, not the goal. (View Highlight)
• 2. Finished when it fits Personal software is complete the moment it works for its maker. It doesn’t need to scale, integrate, or evolve into a product. It’s not a Minimum Viable Product (MVP) waiting for investors, nor a demo that showcases technical capacity, nor a Proof of Concept (POC) waiting for validation. It is done when it fits. Longevity depends on continued use, not planned maintenance or future versions. (View Highlight)
• 3. Human in scale Personal software is designed for use by a specific group, rather than for a generic set of “users”. It optimizes for specificity over universality, intimacy over scale, immediacy over evolutivity. Its makers learn by building, staying close to the code and the group of people who use it. The learning from the creation and adoption (not the code) can inspire, influence or guide the development of other categories of software. (View Highlight)
• We are clearly in the early stages of a significant new wave of capabilities and reach. Looking at what people share and talk about, few archetypes emerge from traditional code to LLM-infused systems: Main archetypes of personal software: A script automates a task with code; A workflow automates a task by connecting tools; An app performs a predefined set of tasks through graphical interactions; A plugin adds functionality to an existing App; An assistant performs tasks through natural language interaction; An agent makes decisions, and takes actions to achieve goals. (View Highlight)
• Shopify-OML Archetype: Plugin Próximo Lab member Rohit Gupta coined the term “in-between software” for the half-baked mechanisms that connect services never designed to work together. Our editor Patrick Pittman built one: a Shopify plugin linking our online bookshop with a local distributor who ran warehouse stock on a Google spreadsheet. Personal software often lives in these gaps: too specific for any vendor to address, too necessary to leave unfilled. (View Highlight)
• Tenth team memberArchetype: Assistant At BBVA, where I have consulted on AI strategy, a member of the legal advisory team built a custom GPT to help the nine lawyers handle 40,000 customer queries per year. The tool drafts answers faster and more thoroughly than manual lookup; all responses undergo human review before reaching branch managers. It is software shaped by one team’s experience and workflow, not by the IT department. (View Highlight)
• FlowArchetype: App/Workflow Designer and teacher Etienne Mineur has been creating custom tools that augment a designer’s singularity, instead of AI normalizing creation. He built Flow, a workflow generator that orchestrates a synthetic creative team (strategist, logo specialist, design critic) to brainstorm, critique, and iterate under his direction. It is software shaped by one person’s practice and AI’s possibilities, not by a market. (View Highlight)
• The incompleteness of personal software, far from being a flaw, becomes an invitation. In his 1989 essay Worse is Better, computer scientist Richard P. Gabriel observed that systems designed with practical simplicity often achieve better adoption than perfect feature-rich systems. Imperfection creates openings: releasing something that others know how to improve is one of the best ways to attract collaboration.

  Personal software is the beginning of a relationship, not the end of a transaction (View Highlight)