My family and I enjoy the occasional meal of delicious slow-cooked meat, but every time we visit a barbecue joint, we can’t remember whether we like the beans and slaw on offer. Some beans are sweet; others are spicy. Some slaw is vinegar based; others creamy. We should keep track of this somehow, we always say but then never bother. I should make an app, I used to joke. But that was a ridiculous idea.
Thanks to generative artificial intelligence, it became less ridiculous. By last summer, I had been making small programs with AI for some time. AI’s adeptness at programming was helping me, a busy person with a professional programming background but limited reason to program, work creatively with computing for the first time in ages. I wanted to see how far I could push AI as a solo programmer. The barbecue-sides-preference problem, I reasoned, would serve as a perfect test case: building a fully featured iPhone app—Beanslaw, I called it—with esoteric utility that nobody would have bothered commercializing.
Two days of occasional programming were sufficient to make a professional-grade version of Beanslaw—an act that would have taken weeks of full-time dedication not long ago. The app displayed smoked-meat joints on a searchable map. It implemented sophisticated intelligence to filter out Korean barbecue, Brazilian churrasco, and other (no less delectable!) cuisines that entail barbecue of a different, bean-and-slawless variety. A user can assign assessments of beans (such as vegetarian and soupy) and slaw (including chunky and mustard), and filter the map by desired side-dish traits. I even built an onboarding tutorial. I was ready to ship.
Excited, I showed a friend. “Where are everyone else’s slaw and bean ratings?” he asked, tapping at his phone. He didn’t get the point of an app that amounted to a personal journal. Almost two decades of smartphone apps had trained him to understand software as a mechanism for collective intelligence. A program that only a few people would use is now alien. App has come to refer to a type of global, leveraged software business, not a computer program.
[Josh Tyrangiel: The secret to understanding AI]
Because AI is so good at writing software, in only an hour or so, I was able to add community ratings. Now Beanslaw does what my friend would expect it to—connect potentially billions of users. But doing so also turned an idiosyncratic app meant to satisfy me alone into a candidate (a hopeless one, at that) for the software attention economy.
I never released Beanslaw to the public. But during the year since, I have written, with AI’s aid, a dozen or more programs to solve anomalous problems, seeking to understand what AI programming—a practice some people call vibe coding—means for computing culture. AI-assisted coding could revive the old dream of ordinary people making software for themselves. But so far, in practice it amounts to a new trip down an old path that software development has been traversing for decades: one where a privileged few decide what computers are for, and the rest of us fall in line.
In the early 1960s, inspired by Vannevar Bush’s 1945 Atlantic essay “As We May Think,” a recent Swarthmore College philosophy graduate named Ted Nelson began conceptualizing a computer-publishing system for all global knowledge, accessible to anyone—work for which he coined the term hypertext. A decade later, in 1974, Nelson expanded his vision of computing’s populist power in a pamphlet manifesto called Computer Lib/Dream Machines.
At the time, computers were big, expensive machines used by corporations and government offices. Before the personal computer arrived in earnest, Nelson denounced the “appalling gap between public and computer insider.” He characterized the corporate and governmental actors with access to and expertise in computing as a “priesthood.” Nelson advocated for dismantling this priesthood and putting computing in the hands of ordinary people.
Nelson, along with other figures of the personal-computer revolution, saw their work as literally revolutionary: The Lib of Computer Lib referred to liberation, like “women’s lib,” and he and his allies understood their work as a part of the counterculture movement. Seymour Papert, who co-designed the programming language Logo, envisioned programming as a way for kids to control these machines rather than submit to them. Inspired by Papert, Alan Kay imagined the tablet-style Dynabook, a “personal computer for children of all ages.” And Steve Wozniak, who designed the first Apple (and co-founded Apple Computer with Steve Jobs), valued cheap, publicly shared software skills as a way to overthrow the corporate monopoly on computing.
For a time, that liberationist vision became reality. Early personal computers such as the Apple II and Commodore 64 booted up to a command prompt where users could immediately begin programming in BASIC, an intuitive language. Early advertisements pitched them explicitly as devices people could program themselves. Computer magazines of the era published code that readers typed into their machines by hand.
I learned Papert’s Logo as a first grader in the early 1980s, because my private school had invested in personal computers, labs to house them, and teachers to guide us. That head start gave me confidence with computer programming, which was presented as a normal activity akin to making art or reading. I picked up BASIC, assembly, Pascal, C, and other languages naturally. The machines couldn’t do much yet, and I could learn new things as they evolved—which was still slow enough that an ordinary person, even a child, could keep up.
Personal though they might have become, computers remained expensive and largely inaccessible. And the relatively well-off people who bought them were more likely to buy commercial software than to write their own. Within a few years, the graphical user interface popularized by Macintosh and Windows made the machines easier to use yet also more complicated. Business tools such as spreadsheets, word processors, and layout software made new kinds of computer-based creativity possible, but the results were far removed from the visions of Kay and Nelson. Computers, once envisioned as tools of self-actualization, became appliances.
In the 1980s and 1990s, ordinary people’s ability to construct their own software ebbed and flowed. Hypercard users made databases, cookbooks, and games on their Macs; gray-cubicle office workers used Visual Basic to build Windows programs to automate tasks, often for themselves alone. The World Wide Web let ordinary people publish websites for the whole world, rather than just themselves, their friends, or their office mates.
By the mid-2000s, the Web 2.0 economy had begun to roll back the web’s openness, shepherding people into using platforms such as Blogger, YouTube, and Facebook. The priesthood was back, and the wealthy tech giants served as its bishops.
AI programming does not challenge that power. It entrenches it. I encountered a characteristic, if humdrum, example of software authority during what I thought would be a straightforward vibe-coding task last winter. I had long been dissatisfied with the countdown-timer app on the Apple Watch, with its giant list of times and tiny stop button. I mostly time things in 30-second increments: hamstring stretches, grill sears, tea brews. So with AI’s help, I made a watch app I called Taptimer. I’d tap the screen repeatedly to add half minutes; the timer would run, and then it would buzz. Tapping anywhere on the screen would turn it off again. Sounds simple, right?
Except, Apple doesn’t let third-party programs issue the type of repeated-vibration notifications that its special “native” timer program uses. I had to settle on a single-buzz notification. It works—I use Taptimer every day—but the terms of what the software is allowed to do are set by the owners of the platforms that people must use to run it.
With reason, or at least excuse. Under the guises of usability, security, or control, the oligopolistic tech industry dictates what software can be and can do. The software industry began treating a program shared among friends like a product distributed to millions—in part because it cannot imagine why anyone would bother to make a program that didn’t aspire to wealth, power, or prestige. AI programming arrives during the most intensively exclusionary version of the computer priesthood. The software business has been pushing amateurs out of software creation for two decades, forcing us to use its own wares instead.
When I first started writing Mac programs, in the early 1990s, I could compile a program, put it on a disk, and give it to a friend. Apple’s documentation for how to do so came in printed volumes you could buy at a bookstore, and that didn’t change much across an entire decade. By the time I sat down to write Beanslaw, I needed a $99-a-year subscription to the Apple Developer Program, sufficient familiarity with Apple’s development tools to understand how to use ChatGPT’s code, and enough software-publishing experience to get the resulting software off of my computer and onto phones.
I had to know enough about making software that I could reason and negotiate with the AI about how to approach certain tasks. Some of this effort was not technical at all, such as building a whitelist of known barbecue joints (Rendezvous in Memphis, Pecan Lodge in Dallas) that the app would always display. Others required a deeper bureaucratic knowledge of software development as a practice, such as how to include restaurant images via a backend service provided by Yelp without accidentally spending thousands of dollars.
[Read: How long until AI hacks everything?]
The more I programmed with AI, the more I felt this tug-of-war between my own prior programming knowledge and the exciting, new coding capacities AI unlocked for me. On my own, I could have built the community ratings that my friend who tried Beanslaw had expected. But storing data in a scalable way across an internet service is complicated, and I wouldn’t have bothered for a program that was supposed to be for a handful of people. ChatGPT introduced me to an Apple programming feature called CloudKit, which made the process easy. Then AI made the implementation easy, too, by giving me the code.
In other cases, I had known what I wanted and how to do it, but I didn’t feel like investing time in the doing. AI made minor software excursions both reasonable and delightful. For example, the Ethernet switch in my home office kept dropping to a lower throughput. To monitor it, I made, with AI, a Mac program that performs an internet-speed test and displays the results in the menu bar. Or, when I had to rebuild my personal website before preorders for my latest book opened, I relied on 30 years of web-development experience to ask AI for the features I wanted (redirecting old URLs, presenting different content by geography) but that I couldn’t quite make time for amid the duties of my actual job and life.
To call this process vibe coding—as if one just types a prompt, waves their hands, and gets a complete and working computer program—amounts to a profound misconstrual of what’s going on.
Computer scientists sometimes talk about “high level” and “low level” programming. Low-level programming involves a lot of very small-scale, specific instructions; high-level programming abstracts that effort into simpler methods that are easier and more accessible. Low-level programming is sometimes considered more technical and therefore more righteous, but high-level coding is often understood to produce faster results. The latter value has prevailed, and over the years and decades, software development has moved to higher levels of abstraction because doing so streamlines output. Low-level work is used only when necessary—and often just to build tools or infrastructure to facilitate high-level programming.
Vibe coding continues this tendency. Coding has always involved a repeated process of giving a computer instructions for an intended outcome or experience, making the machine run them, and then revising the instructions based on the result. At first, those instructions were immensely basic: Move a number or perform a mathematical operation. Over time, the instructions became more complex and abstracted: Write a file to disk, draw a circle, plot a location on a map. Under the hood, computer programs often generate and run code at a lower level as a part of their work. AI programming does not disrupt that process at all. It extends the effort.
This makes the aesthetics of vibe coding entirely familiar to programmers. The moment-to-moment experience of coding feels the same, but you do so at greater remove. Realizing this made me understand why programmer types might find generative AI so immediately compelling, and also why they might not grasp the objections of people in other walks of life who oppose it. Using AI to create prose or illustrations seems to erase the experience of the writer or artist and their participation in the act of creation. It clobbers the process in favor of the outcome. But for a programmer, the outcome and the process improve all at once. Nothing about AI programming feels like a compromise or cheat. It just feels like programming.
Or perhaps it’s programming at its best. I could feel myself becoming a more generous and open-minded programmer when I coded with AI. Feature requests or suggestions seemed not like slights or gripes, but like opportunities worth considering. Likewise, bugs stopped bothering me. A defect no longer represented something I did wrong; it was a problem I could hurl back at the machinery to solve. Even dead ends or bad ideas felt good, both because I enjoyed carrying them out and because the prototyping experience seemed familiar, but faster and more deliberate.
For example, over a few weeks this summer, I became obsessed with a little $30 computer with a round screen and a dial, similar to a Nest thermostat. I was convinced that the thing could host a clever video game. So I bought one and tried a bunch of ideas: circular Pong, round Breakout, marble rolling, safecracking, tetherball, mini golf, driving a car, navigating a spaceship, mowing a lawn. All of them were cute, but none felt interesting enough to play more than once. I stopped trying, at least for the moment. That feeling is familiar: I’ve started and abandoned hundreds of software projects in my amateur and professional programming career. But the vibe-coded failures felt less bad, because the coding had produced instructive results without devouring my life.
All of this still relied on my accidental, if long-in-the-tooth, membership into the computing priesthood. When I first started using ChatGPT to code, the process was almost dialectical. I’d ask AI for something, it would present some code, and I would implement that code in my project. The process involved a lot of step-by-step, back-and-forth discussion and action.
And yet, during my year of AI programming, I could feel my sense of control and competence recede as the technology evolved. By this spring, something had changed. So-called agentic execution in Claude Code had made it possible to give the AI access to a directory and create a whole program on its own, even a complex one. This method, which seems more automatic and thus more desirable, has spread, and OpenAI has added a version of it called Codex. AI has shifted from facilitating programming—as a process of iteratively making stuff with computers—to solving a problem on its own. No programmer required.
This might seem to realize vibe coding as automation, and perhaps even defrock the coding priesthood. I doubt it, largely because industrial power has swallowed so many prior attempts to democratize coding. But automation is also the wrong goal for amateur programming. The most productive, interesting, and fulfilling AI-programming experiences I have had are the collaborative ones.
Earlier this year, I became interested in the unexplored design space in software-based reading. So I started making prototypes: an e-reader that meted out a story as if over the 15 hours of a transpacific journey; a similar one that dispensed text about a road trip gone awry as the reader moved through physical space; an aleatory story that subtly changed what happened to its characters every time the reader opened it. In each of these cases, my aesthetic, technical, and writerly goals were iterative: I hatched some plan, ChatGPT helped me implement it, and then I judged the results and repeated the process.
Unfortunately, during the year that I spent programming seriously with AI, that paradigm of creativity has been superseded. When I try to partner with ChatGPT to code, the software now urges me to use its automation tools instead. ChatGPT has made certain kinds of direct file editing, which I found particularly useful for iterative work, hard or impossible. The industry at large now seems to assume that a programmer’s end goal is known in advance, and the work just involves moving toward it: Build a game for me, or make a website, or generate an app. A lot of news coverage of the phenomenon takes this efficiency as an improvement, assuming AI programming to be a way for the software industry to become more productive. But I found AI to be most liberating when I treated it like a partner offering a feedback loop between my intention and the machine’s implementation, rather than a silicon priest delivering answers or a minion carrying out my bidding.
Reflecting on my vibe-coding journey, I now realize that I began the effort insufficiently aware of what I should have known to be true: that software had already mostly been captured by the high-tech industry long before AI-coding tools arrived, and that those tools were doomed to worsen as much as improve the situation. I fell into the ever-enlarging chasm between the small-scale, personal-software fantasy and its scaled-up, big-business reality. Even the AI services I use to write software change so frequently that the methods I used last week to make something might change next week when Claude or ChatGPT updates. The whole structure feels erected on a sheet of ice.
[David Brooks: AI is already changing what it means to be human]
Rather than fight the friction, I’ve sought out a software equivalent of crampons that can bite into it—resilient enough to resist the slide into commercial software, but sufficiently functional to persist beyond curiosity. That charge is difficult but still possible, although I still feel as if I am clinging precariously to a frosty crag when pursuing it.
As part of this clamber, I found an inexpensive, programmable e-ink display that I could hang on a wall. I have a home weather station in my yard, and I liked the idea of building a pretty, inconspicuous display for the hyperlocal data it produces. I wrestled with the new version of ChatGPT, but for the moment collaboration was still possible if I pushed the AI to converse with me as a partner. Even in the more esoteric, open-source electronics platforms I was using for the project, an accidental priesthood has arisen thanks to 20 years of chaotic, incremental work by global homebrew volunteers. AI helped me make sense of it all so that I—so that we—could get started. And then, together, we built the layout, slurped up the data from my weather station, and iterated on the appearance of the weather-condition icons. I got the idea to display the temperature from my pool heater and then the soil moisture from my lawn sensors, silly things that would have felt indulgent if a computer hadn’t made them easy. Now the little screen hangs next to the alarm panel, updating itself every 15 minutes.
When I pass by the thing on the way to the kitchen or the driveway, I feel a vibration of delight. The sensation isn’t quite pride, because I can hardly take sole credit for the accomplishment. But neither is it opportunism, as if I might package and resell weather-station displays as some kind of value-additive, hardware-accessory side hustle. Instead, I feel overcome by the modesty of the matter. A little black-and-white display is showing me the weather—one I made, if with AI help. How nice. For once, a computer doesn’t have to be connecting the world or saving it—or ruining it. Instead, it can simply hang humbly on a wall inside that world, doing something cute, and intentional, and perhaps even useful. The revolutionaries of computing’s counterculture, who mostly became its priests, once believed that would be enough.