Disclosure: I’m on the board of Bluesky, which was inspired by my “Protocols, Not Platforms” paper. But this post isn’t about Bluesky the app. It’s about the underlying protocol and what it enables for anyone who wants to build technology (even competitive to Bluesky) that actually respects users.

Last month, I helped release the Resonant Computing Manifesto, which laid out a vision for technology that empowers users rather than extracting from them. The response was gratifying—people are genuinely hungry for an alternative to the current enshittification trajectory of tech. But the most common piece of feedback we got was some version of: “Okay, this sounds great, but how do I actually build this?”

It’s a fair question. Manifestos are cheap if they don’t connect to reality.

So here’s my answer, at least for anything involving social identity: build on the ATProtocol. It’s the only available system today that actually delivers on the resonant computing principles, and it’s ready to use right now.

The Resonant Computing Manifesto laid out five principles for building technology that works for people:

1. Private: In the era of AI, whoever controls the context holds the power. While data often involves multiple stakeholders, people must serve as primary stewards of their own context, determining how it’s used.
2. Dedicated: Software should work exclusively for you, ensuring contextual integrity where data use aligns with your expectations. You must be able to trust there are no hidden agendas or conflicting interests.
3. Plural: No single entity should control the digital spaces we inhabit. Healthy ecosystems require distributed power, interoperability, and meaningful choice for participants.
4. Adaptable: Software should be open-ended, able to meet the specific, context-dependent needs of each person who uses it.
5. Prosocial: Technology should enable connection and coordination, helping us become better neighbors, collaborators, and stewards of shared spaces, both online and off.

If you’re building anything that involves users having identities, connecting with other users, or creating content that belongs to them—which describes basically every interesting app—you need infrastructure that makes these principles achievable rather than aspirational.

ATproto delivers all five.

Private and Dedicated come down to who controls your data. In the current paradigm, you’re rows in somebody else’s database, and they can do whatever they want with those rows. Dan Abramov, in his excellent explainer on open social systems, describes the problem perfectly:

The web Alice created—who she follows, what she likes, what she has posted—is trapped in a box that’s owned by somebody else. To leave is to leave it behind.

On an individual level, it might not be a huge deal.

Alice can rebuild her social presence connection by connection somewhere else. Eventually she might even have the same reach as on the previous platform.

However, collectively, the net effect is that social platforms—at first, gradually, and then suddenly—turn their backs on their users. If you can’t leave without losing something important, the platform has no incentives to respect you as a user.

With ATproto, your data lives in your own “personal repository” (the PDS)—think of it as your own storage container on the social web. You can host it with a free service (like Bluesky), a paid provider, or on your own server. If your current host turns evil or just annoys you, you pack up and move without losing your identity, your connections, or any of your content. The protocol handles the redirection automatically.

This isn’t theoretical. People are doing it right now. The infrastructure exists. You can literally move your entire social presence from one host to another and nobody who follows you needs to update anything (or even realize that you’ve moved).

You don’t need to figure out ways to extract data from an unwilling billionaire’s silo. It’s already yours.

And that’s beneficial for developers as well. If you’re trying to build a system, setting up the identity and social connections creates all sorts of challenges (and dangerous temptations) regarding how you deal with other people’s data, and what games you might play to try to juice the numbers. But with ATproto, the incentives are aligned. Users control their own data, their own connections, and you can just provide a useful service on top of that.

Plural is baked into the architecture. Because your identity isn’t tied to any single app or platform, you can use multiple apps that all read from and write to your personal repository. Abramov explains this clearly in that same post:

Each open social app is like a CMS (content management system) for a subset of data that lives in its users’ repositories. In that sense, your personal repository serves a role akin to a Google account, a Dropbox folder, or a Git repository, with data from your different open social apps grouped under different “subfolders”.

When you make a post on Bluesky, Bluesky puts that post into your repo:

When you star a project on Tangled, Tangled puts that star into your repo:

When you create a publication on Leaflet, Leaflet puts it into your repo:

You get the idea.

Over time, your repo grows to be a collection of data from different open social apps. This data is open by default—if you wanted to look at my Bluesky posts, or Tangled stars, or Leaflet publications, you wouldn’t need to hit these applications’ APIs. You could just hit my personal repository and enumerate all of its records.

This is the opposite of how closed platforms work. You’re not locked into any single company’s vision of what social software should be. Different apps can disagree about what a “post” is—different products, different vibes—and that’s a feature, not a bug. Your identity travels with you across all of them.

Indeed, we’re seeing some really cool stuff around this lately, such as with the new standard.site lexicon for long form publishing on ATproto. It’s been adopted by Leaflet, Pckt, and Offprint, with others likely to come on board as well.

Tynan Purdy, writing via the brand new Offprint (itself an ATproto app), captures the mindset shift that I think more developers need to internalize:

I have no more patience for platforms. I’m done.

Products come and go. This is a truism of the internet. Do not expect any particular service to exist forever, or you will be burned. It can be a depressing thought. So much of our lives are lived online. Communities and culture are created online. The play is performed on stages we call “social media”. But then they go away.

We make our homes on these platforms. Set up shop. Scale a business. Connect with our friends. Build a following. Then something changes. A change in corporate strategy. An IPO. A private equity takeover. A merger with AOL. And it’s never the same after that. All that work, all that culture, now painted in a different light. Sometimes locked away entirely.

His solution? Never build on closed platforms again:

I write to you now on a new kind of place on the internet. This place is mine. Or rather, what I create here is mine. This product (a rather fine one by @btrs.coif I say so myself), belongs to @offprint.app. They might go away. Someday they will. But this, my words, my creation. The human act of creating culture. This is mine. It lives in my personal folder. I keep my personal folder at @selfhosted.social. They will go away someday too, and that’s okay. I’ll move my folder somewhere else. You’ll still be able to read this. Offprint is just an app for reading a certain kind of post I publish to the ATmosphere. When Offprint inevitably dies, hopefully a long time from now, this post will still just be a file in my personal folder. And when that day comes, perhaps even before, there will be other ways to read this file from my personal folder. You can even do so right now.

That’s not idealism. That’s how ATproto actually works today.

Purdy mentions above his “personal folder” and in another post Abramov digs deeper into what that means:

This might sound very hypothetical, but it’s not. What I’ve described so far is the premise behind the AT protocol. It works in production at scale. Bluesky, Leaflet, Tangled, Semble, and Wisp are some of the new open social apps built this way.

It doesn’t feel different to use those apps. But by lifting user data out of the apps, we force the same separation as we’ve had in personal computing: apps don’t trap what you make with them. Someone can always make a new app for old data:

Like before, app developers evolve their file formats. However, they can’t gatekeep who reads and writes files in those formats. Which apps to use is up to you.

Together, everyone’s folders form something like a distributed social filesystem:

This is a fundamentally different relationship between users and services. And it breaks the economic logic that makes platforms turn against their users.

It’s an enshittification killswitch.

Cory Doctorow’s framing of enshittification notes that the demands (often from investors) for companies to extract more and more pushes them to enshittify. Once they have you in their silo, they can begin to turn the screws on you. They know that it’s costly for you to leave. You lose your contacts. Your content. Your community. The switching costs are the leverage.

ATproto breaks that leverage.

Because you control your data, your identity, and your connections, whichever services you’re using have strong incentives to never enshittify. Turn the screws and users just… leave. Click a button, move to a different service, take everything with them. The threat that makes enshittification profitable—”where else are you gonna go?”—has no teeth when the answer is “literally anywhere, and I’m taking my stuff.”

Paul Frazee, Bluesky’s CTO, talks about how this works in a post he recently did on the concept of “Atmospheric Computing.”

Connected clouds solve a lot of problems. You still have the always-on convenience, but you can also store your own data and run your own programs. It’s personal computing, for the cloud.

The main benefit is interoperation.

You signed up to Bluesky. You can just use that account on Leaflet. Both of them are on the Atmosphere.

If Leaflet decides to show Bluesky posts, they just can. If Leaflet decides to create Bluesky posts, they just need to use the right schema. The two apps don’t need to talk to directly to do it. They both just talk to the users’ account hosts.

Cooperative computing is possible.

The most popular algorithm on Bluesky is For You. It’s run by Spacecowboy on *squints* his gaming PC.

He ingests the firehose of public posts and likes and follows. Then the Bluesky app asks his server for a list of post URLs to render. The shared dataset means we can do deeply cooperative computing. An entirely third party service presents itself as first-party to Bluesky.

The “cold start” problem is resolved.

Tangled made a Git and Jujitsu code hosting app that uses the same user accounts as a Bluesky. You could choose to run Tangled yourself since it’s open source.

Because Tangled is Atmospheric, your self-hosted instance would see all of the same users and user activity as the first instance would.

The garden is unwalled.

SelfHosted.social is an account hosting service. The self-hosted users show up like any other user. If I had to guess, most of them started on Bluesky hosts, and then used something like PDS Moover to migrate.

It’s an open network.

In the Atmosphere, it does make sense to run a personal cloud, because your personal cloud can interoperate with other people’s personal clouds. It can also interoperate with BobbyCorp’s Big Bob Cloud, and the corner pie shop’s Pie Cloud, and on it goes.

There’s no silo to lock you in, and thus trying to turn the screws on users should backfire. Instead, services built on ATproto have “resonant” incentives, to keep you happy, to keep you feeling good about using the service, because it enables a plurality of other services as well.

In many ways it’s a rethinking of the entire web itself and how it can and should work. The web was supposed to be interoperable and buildable, but all our data and identity pieces got locked away in silos.

ATproto breaks all that down, and just lets people build. And connect. And share.

Adaptable is where the developer ecosystem comes in. Because the protocol is open and the data formats are extensible, anyone can build whatever they want. We’re already seeing this explosion right now: Bluesky for microblogging, Leaflet for long-form publishing, Tangled for code collaboration, Offprint for newsletters, Roomy for community discussions, Skylight for shortform video, Semble for organizing research, teal.fm for music scrobbling and dozens more. Some of these are mere “copycats” of existing services, but we’re already starting to see some others that are branching out beyond what was even possible before.

The key: these apps don’t just coexist—they can actively benefit from each other’s data. Abramov again:

Since the data from different apps “lives together”, there’s a much lower barrier for open social apps to piggyback on each other’s data. In a way, it starts to feel like a connected multiverse of apps, with data from one app “bleeding into” other apps.

When I signed up for Tangled, I chose to use my existing @danabra.mov handle. That makes sense since identity can be shared between open social apps. What’s more interesting is that Tangled prefilled my avatar based on my Bluesky profile. It didn’t need to hit the Bluesky API to do that; it just read the Bluesky profile record in my repository. Every app can choose to piggyback on data from other apps.

An everything app tries to do everything the way they tell you to do it. An everything protocol-based ecosystem lets everything get done. How you want. Now how some billionaire wants.

It’s becoming part of the motto of the Atmosphere: we can just do things. Anyone can. For years I’ve written about how much learned helplessness people have regarding social systems—thinking their only option is to beg billionaires or the government to fix things. But there’s a third way: just build. And build together. That’s what ATproto enables.

And it’s doable today. Yes, there are reasonable concerns about the hype machine around AI and vibe coding—but the flip side is that in the last couple of months, I, a non-professional coder, have built myself three separate things using ATproto. Including a Google Reader-style app that mixes RSS and ATproto together. That’s what “adaptable” actually means: tools malleable enough that regular people with little to no experience can shape them to their needs. The vibe coding revolution will enable even more people to just build what they want, and they can use ATproto as a foundational layer of that. 

This used to be close to impossible. The big centralized platforms learned to lock everything down—sometimes suing those who sought to build better tools. ATproto doesn’t have that problem. We don’t need permission. We can just do things. Today. And with new AI-powered tools, it’s easier than ever for anyone to do so.

Prosocial is where this all comes together. Not “social” in the Zuckerbergian sense of harvesting your social graph to sell ads, but social in the human sense: enabling connection and coordination between people, without a controlling body in the middle looking to exploit those connections. The identity layer handles the hard problems—authentication, verification, portability—so developers (or, really, anyone—see the adaptable section) can focus on building things that actually help people connect.

Remember why people flocked to social media in the early years? They got genuine value out of it. Connecting with friends and family, new and old. But once the centralized systems had you trapped, those social tools became extraction tools.

The open social architecture of the Atmosphere means that trap can’t close. We can engage in prosocial activities without fear of bait-and-switch—without worrying that the useful feature we love is just bait to drag our data and connections into someone’s locked pen.

The protocol itself is politically neutral infrastructure, like email or the web. The point isn’t any particular app—it’s that we finally have a foundation for building social tools that don’t require users to surrender control of their digital lives.

If you’re building an app that needs user identity, or user-generated content, or any kind of social graph, you don’t have to build all that infrastructure yourself. You don’t have to trap your users’ data in your own database (and worry about the associated risks). You don’t have to make them create yet another account and remember yet another password. You can just plug into ATproto’s identity layer and get all of the resonant computing principles essentially for free.

Your users keep control of their identity. Their data stays under their control, but available to the wider ecosystem. Your app becomes part of that larger ecosystem rather than just another walled garden, meaning you’ve also solved part of the cold start problem. Over 40 million people already have an account that works on whatever it is that you’ve built. And if your app dies—let’s be honest, most apps die—the data and connections your users created don’t die with it.

The Resonant Computing Manifesto talked about technology that leaves people “feeling nourished, grateful, alive” rather than “depleted, manipulated, or just vaguely dirty.” That kind of technology can’t exist when the fundamental architecture treats users as resources to be extracted. But it can exist when users control their own data, when developers can build without permission, when leaving doesn’t mean losing everything.

That’s not a future we need to wait for. That’s ATproto. Today.

So when people ask “how do I actually build resonant computing?” this is a key part of the answer. Stop building on platforms. Stop begging billionaires to be better. Stop waiting for regulators to save you.

The tools are here. The infrastructure exists. We can just do things.