In the Vibe Coding Era, Why Do We Need RSS for Distributing Personal Apps?

When Building Apps Becomes as Easy as Publishing a Blog Post

An interesting trend is emerging: with the rise of Vibe Coding, more and more developers are rapidly producing various small tools and micro-applications. These apps are highly personalized, context-specific, and created at an extremely high frequency. Matt Webb recently raised a thought-provoking point—we need an RSS-like mechanism for sharing these applications.

The concept of Vibe Coding was first coined by Andrej Karpathy, former OpenAI researcher and former head of Tesla AI, in a February 2025 tweet. It refers to a development approach where developers describe their requirements in natural language to AI coding assistants, which then generate most or even all of the code. The specific scenario Karpathy described was using the Cursor editor paired with Claude Sonnet—he found himself increasingly just describing desired features in English, accepting all AI-generated code, and no longer even carefully reading diffs. The developer's role shifts from writing code line-by-line to describing intent, reviewing output, and guiding direction. It's called "Vibe Coding" because developers are more about "feeling" and "guiding" the overall direction rather than precisely controlling every line of implementation—Karpathy himself described the experience as "fully giving in to the vibes, embracing exponentials, and forgetting that the code even exists." The tweet quickly sparked widespread discussion in the tech community because it precisely named a phenomenon many developers were already experiencing but hadn't found the words to describe. Today, Cursor, GitHub Copilot, Windsurf, Bolt, Lovable, and other AI coding tools have formed a vast ecosystem, enabling everyone from professional developers to people with zero programming experience to "write" applications using natural language.

"As Vibe Coding accelerates app development, applications become more personal, more contextual, more frequent. Publishing a tool or micro-app no longer feels like launching a website—it's more like publishing a blog post."

This analogy precisely captures the current shift: AI coding assistants are dramatically lowering the barrier to application development, and the cost of producing a useful small tool has approached that of writing an article.

From Scarcity to Abundance: A Paradigm Shift in App Distribution

Traditional app distribution models—whether the App Store, Chrome Web Store, or GitHub—were all designed for "scarcity" scenarios. The birth of an application meant weeks or even months of development, and publishing was a solemn event. The review processes, metadata requirements, and listing mechanisms of these platforms all carry an implicit assumption: apps are heavyweight, low-frequency digital products. Take the Apple App Store as an example—an app typically requires a 1-7 day review cycle from submission to listing. Developers need to prepare app screenshots, privacy policies, content rating descriptions, and extensive metadata, plus pay an annual $99 developer account fee. Even the relatively lenient Chrome Web Store requires developers to pay a one-time registration fee and pass automated review. These processes serve as reasonable quality assurance mechanisms when app output frequency is low, but when a developer is producing new tools weekly or even daily, they become unbearable friction costs.

But Vibe Coding has changed all of this. With AI coding assistants like Claude and GPT, developers can complete a fully functional small tool in minutes to hours. Simon Willison maintains a site at tools.simonwillison.net that aggregates numerous tools he's developed with AI assistance. Willison is the co-creator of the Django web framework and the author of Datasette, an open-source data exploration tool. He's one of the most active practitioners and evangelists in the AI-assisted programming space. His tools site brings together dozens of pure frontend tools covering data visualization, text processing, image editing, and many other use cases—each tool is a standalone HTML file that runs without a backend. This "single-file app" pattern is itself a quintessential product of the Vibe Coding era.

Single-file apps can achieve surprisingly complex functionality thanks to the enormous leap in modern browser capabilities. Today's browsers come with Canvas and WebGL graphics rendering engines, Web Audio API for audio processing, File System Access API for local file read/write, Web Workers for multi-threaded computation, and even WebGPU for GPU-based parallel computing. Combined with frontend libraries available via CDN (such as D3.js for data visualization, FFmpeg.wasm for video processing, TensorFlow.js for machine learning inference), a single HTML file can achieve what previously required a full client-server architecture. This means a vast number of useful tools need no backend server, no database, no deployment pipeline—just open a browser to run them, share a URL to use them.

When the speed and frequency of producing such tools changes by orders of magnitude, existing distribution infrastructure feels cumbersome.

What we need is a lightweight, decentralized, subscribable distribution method—which is precisely where RSS/Atom excels.

RSS as an App Distribution Protocol: Is It Feasible?

Matt Webb's vision is straightforward: provide RSS feeds for personal tool and app pages, with each entry accompanied by an "install" button. While simple, this idea touches on several critical questions.

A brief look at RSS history: RSS (Really Simple Syndication) was first born in 1999, developed by Netscape for its web portal, and later evolved through multiple versions. Atom was standardized by the IETF in 2003 as an alternative that resolved compatibility issues caused by RSS's multiple coexisting versions. Both share the same core philosophy: content publishers provide a structured XML file (feed), and subscribers pull updates periodically through readers. The key advantage of this model is complete decentralization—no intermediary platform is needed. Publishers simply maintain a feed file on their own server, and subscribers independently choose whom to follow. Although the rise of social media once marginalized RSS (the landmark event being Google shutting down the beloved Google Reader in 2013), it has maintained vitality in tech communities and independent blog circles, and has seen a resurgence in recent years as people reflect on algorithmic recommendations.

The RSS revival is closely tied to the broader IndieWeb movement. The IndieWeb movement advocates individuals owning their online identity and content, with one of its core principles being POSSE (Publish on your Own Site, Syndicate Elsewhere)—publish on your own site first, then syndicate to other platforms. This philosophy aligns perfectly with tool distribution needs in the Vibe Coding era: developers publish tools on their own sites and let interested people automatically receive updates via RSS. The rise of decentralized social networks like Mastodon is also rebuilding user trust in open protocols—Mastodon's underlying ActivityPub protocol shares the same design philosophy as RSS: decentralization, open standards, and user autonomy. These trends converge to make the idea of RSS as a micro-app distribution protocol feel less like fantasy and more like a natural technological evolution.

Discovery Mechanism: No More Scattered Personal Tools

Currently, individual developers' small tools are scattered across their blogs, GitHub repositories, and personal websites, lacking a unified discovery channel. RSS natively supports aggregation and subscription—users can follow a developer's tool output just like following a blog. For users accustomed to RSS readers, this is virtually a zero-learning-cost experience. Furthermore, RSS's openness means anyone can build aggregation services—just as Google Reader or today's Feedly aggregates blog content, the future may see platforms that specifically aggregate personal micro-apps. Such aggregation platforms could organize by functional category, use case, or developer, and could even introduce community ratings and recommendation mechanisms while maintaining the openness of the underlying protocol—anyone can consume these feeds with their preferred client without being locked into any particular platform.

Install to Where? The Biggest Unsolved Challenge

Matt Webb himself raised this core question: "Install to where?" This is currently the biggest challenge. For pure frontend web tools, they can run directly in the browser; but for applications requiring backend support or data storage, we still lack a universal "personal app runtime."

This question involves multiple evolving technical directions. WebAssembly (Wasm) allows complex applications to run in the browser at near-native performance and is becoming a universal runtime for client-side applications. WebAssembly's core principle is defining a compact binary instruction format that can serve as a compilation target for multiple programming languages including C, C++, Rust, and Go, executing at near-native machine code speed within the browser's sandbox environment. More noteworthy is the development of the WASI (WebAssembly System Interface) standard—it defines a set of standard interfaces for WebAssembly to interact with the operating system, enabling Wasm programs to run not only in browsers but also on servers, edge nodes, and even embedded devices. This means a future micro-app packaged in Wasm could truly achieve "write once, run anywhere"—whether in a user's browser, on a personal NAS, or on an edge computing node. Docker founder Solomon Hykes once said: "If WASM+WASI existed in 2008, we wouldn't have needed to create Docker." This statement hints at WebAssembly's enormous potential as a universal application runtime.

Progressive Web Apps (PWA) technology lets web applications be installed on devices like native apps, supporting offline operation and system-level notifications. On the server side, edge computing platforms like Cloudflare Workers and Deno Deploy make deploying a lightweight backend nearly free—Cloudflare Workers' free tier allows 100,000 requests per day, more than sufficient for personal micro-apps. Additionally, platforms like Val Town and Replit are exploring the concept of "shareable runtime environments," where users can fork and run others' applications with one click. Val Town is particularly noteworthy—it treats each function as an independently runnable, HTTP-accessible endpoint. Users can fork others' functions like retweeting and run them under their own accounts—a model with natural affinity for the RSS micro-app distribution concept. These technological puzzle pieces haven't fully come together yet, but they collectively point to a future where running a personal micro-app should be as simple as opening a webpage.

This perhaps points to a future need for some kind of personal cloud environment or local AI runtime—a personal infrastructure layer capable of receiving, running, and managing numerous lightweight applications.

Practice First: Simon Willison's Rapid Response

After seeing Matt Webb's article, Simon Willison immediately took action—he had Claude add an Atom feed to his tools page. This detail itself is a perfect embodiment of the Vibe Coding spirit: see a good idea, implement it quickly with AI, publish immediately. From conception to deployment, the entire process likely took just minutes—almost unimaginable in traditional development workflows, but now routine in the AI-assisted programming era.

AI Is Bringing Software Back to the Craft Era

Behind this discussion lies a larger trend: AI is bringing software development back to a "craft" era. Under the industrialized software development paradigm, we've grown accustomed to large teams, long development cycles, and standardized products. Software engineering has spent decades pursuing scale and standardization—from waterfall to agile, from monolithic architecture to microservices, each methodological evolution has tried to make larger teams collaborate more efficiently.

Vibe Coding restores individual developers' ability to create rapidly, producing highly customized small tools that solve specific problems. It's somewhat like the pre-Industrial Revolution artisan workshop era—each product bears the maker's personal imprint, tailor-made for specific users and scenarios. The difference is that AI grants individual craftspeople industrial-grade production efficiency.

This return actually echoes a long-unfulfilled vision in computer science: "end-user programming." As early as the 1960s, computer pioneers envisioned everyone being able to create their own software tools. Alan Kay's Dynabook concept at Xerox PARC in the 1970s envisioned a personal computer on which every user could program. HyperCard, Visual Basic, Excel macros—all were attempts in this direction, but they never truly broke through the cognitive barrier of "programming." Vibe Coding's revolutionary aspect is that it makes "describing requirements in natural language" a truly viable programming method for the first time—users don't need to learn the syntax of any programming language, they just need to clearly express what they want. This isn't merely lowering the barrier; it fundamentally changes the creative relationship between humans and computers. The Software Craftsmanship movement that emerged in 2009 tried to preserve craft spirit within industrialized development, emphasizing code quality and personal skill; today's Vibe Coding goes further—it makes "craftsmanship" no longer the privilege of a technical elite, but a creative activity anyone with ideas can participate in.

This "abundant apps" ecosystem needs matching infrastructure. RSS, as an open protocol validated over more than two decades, has decentralized, subscribable, lightweight characteristics that align perfectly with this new scenario. There's still a long way to go from "subscribing to tool updates" to "one-click install and run," but the direction is clear.

Perhaps in the near future, our RSS readers will contain not just articles and podcasts, but a steady stream of personal app notifications—each one an elegant tool crafted by some developer with AI on a random afternoon.

Key Takeaways

• Vibe Coding has qualitatively changed the frequency and speed of app development, making publishing tools as lightweight as publishing blog posts
• Existing app distribution infrastructure (App Store, GitHub, etc.) was designed for scarcity scenarios and cannot adapt to an era of abundant apps
• RSS/Atom's decentralized, subscribable nature makes it naturally suited as a distribution protocol for personal micro-apps, aligning closely with the IndieWeb movement's philosophy
• "Install to where" is the core unsolved problem, with WebAssembly/WASI, PWA, and edge computing approaching answers from different directions
• AI is realizing the long-standing vision of "end-user programming," bringing software development back to a personalized craft era that needs matching new infrastructure