Bluesky: Designing Algorithmic Transparency
How Bluesky's custom feeds, AT Protocol, and moderation tooling make algorithmic choice a first-class UX pattern for decentralized social.
Bluesky: Designing Algorithmic Transparency
“We don’t think there should be one algorithm that rules them all. The algorithm should be something you choose, like choosing a radio station.” — Jay Graber, CEO
Bluesky is the first social network to make algorithmic choice a core UX primitive rather than a settings toggle buried three levels deep. Built on the AT Protocol (Authenticated Transfer Protocol), it separates identity, data, and algorithms into independent layers — then surfaces that architecture as user-facing design. You do not just use Bluesky’s feed. You browse a marketplace of feeds built by anyone, pin the ones you like, and switch between them with a single tap. This is not a technical novelty; it is a fundamentally different interaction model for social media.
What makes Bluesky a design study rather than just an engineering project is that the protocol-level decisions manifest as interface patterns. Identity portability, custom feeds, composable moderation, and labeling services are all protocol features that required new UX paradigms. Bluesky had to invent interaction patterns for concepts that no prior social network exposed to users.
Why Bluesky Matters
Bluesky grew from zero to 25 million users in under a year, proving that protocol-level design choices can translate into consumer-grade UX when the interface work is done well.
Key achievements: - 25+ million users with no algorithmic lock-in - Custom feed marketplace with thousands of community-built algorithms - First major social network with portable identity (move your account, keep your followers) - Composable moderation: users choose their own moderation services - Open-source clients and feed generators from day one - AT Protocol adopted by third-party apps beyond Bluesky itself
Key Takeaways
- Make infrastructure choices visible - Bluesky surfaces protocol architecture as user-facing features; feed selection, identity portability, and labeling are not settings — they are primary interactions
- Feed-as-product creates ecosystem value - By letting anyone build and publish a feed algorithm, Bluesky turned content curation from a company monopoly into a community marketplace
- Moderation is a design problem, not just a policy problem - Composable moderation services let users choose their own content boundaries rather than imposing a single corporate standard
- Identity portability requires new mental models - Users needed to understand handles, DIDs, and server migration; Bluesky’s design work made these concepts approachable through domain-based identity
- Familiar patterns reduce adoption friction - Despite radical protocol differences, the core posting and timeline experience intentionally mirrors Twitter’s established patterns
Core Design Principles
1. Feed Selection as Primary Navigation
The most radical UX decision in Bluesky is placing feed selection at the top level of navigation. Feeds are not a setting you configure once — they are tabs you switch between throughout the day.
TRADITIONAL SOCIAL MEDIA
┌─────────────────────────────────────────────┐
│ [Home] [Explore] [Notifications] │
│ │
│ ┌─────────────────────────────────────┐ │
│ │ One algorithm decides everything │ │
│ │ You see what we show you │ │
│ │ "For You" = black box │ │
│ └─────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
BLUESKY'S APPROACH
┌─────────────────────────────────────────────┐
│ [Following] [Discover] [Quiet Posters] │
│ [Science] [Art] [What's Hot] [+ Add Feed] │
│ ← swipe horizontally to switch → │
│ │
│ ┌─────────────────────────────────────┐ │
│ │ Each tab = different algorithm │ │
│ │ You choose which ones appear │ │
│ │ Anyone can build a new one │ │
│ └─────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
The design insight: Feed tabs use the same mental model as browser tabs or TV channels. Users already understand “switch to see different content.” Bluesky just applied that pattern to algorithms.
/* Feed tab bar: horizontal scroll with active indicator */
.feed-tabs {
display: flex;
overflow-x: auto;
scrollbar-width: none;
gap: 4px;
padding: 8px 16px;
border-bottom: 1px solid var(--border-color);
}
.feed-tabs::-webkit-scrollbar {
display: none;
}
.feed-tab {
flex-shrink: 0;
padding: 8px 16px;
border-radius: 20px;
font-size: 14px;
font-weight: 500;
color: var(--text-secondary);
background: transparent;
border: none;
cursor: pointer;
white-space: nowrap;
transition: color 0.15s ease, background 0.15s ease;
}
.feed-tab:hover {
background: var(--hover-bg);
}
.feed-tab.active {
color: var(--text-primary);
font-weight: 600;
background: var(--active-bg);
}
/* Active indicator underline */
.feed-tab.active::after {
content: "";
display: block;
height: 3px;
background: var(--accent-blue);
border-radius: 1.5px;
margin-top: 6px;
}
2. Domain-Based Identity as Trust Signal
Bluesky’s handle system lets users set their handle to any domain they control. A journalist at the New York Times can be journalist.nytimes.com. A developer can be alice.dev. This turns DNS — invisible internet infrastructure — into a visible trust signal.
HANDLE SYSTEM
Default: @alice.bsky.social
Custom domain: @alice.dev
Organization: @journalist.nytimes.com
@researcher.mit.edu
WHAT THE USER SEES:
┌─────────────────────────────────────────────┐
│ ┌────┐ │
│ │ AV │ Alice Chen │
│ └────┘ @alice.dev │
│ ↑ │
│ Domain IS the verification. │
│ No blue checkmark needed. │
│ If you control the domain, │
│ you own the identity. │
└─────────────────────────────────────────────┘
VS TWITTER/X VERIFICATION:
- Pay $8/month for a checkmark
- Checkmark means "paid" not "verified"
- No cryptographic proof of identity
- Platform controls the checkmark
VS BLUESKY VERIFICATION:
- Set your handle to your domain
- DNS TXT record proves ownership
- No payment, no platform approval
- You control the proof
Why this matters for design: Bluesky eliminated the “verified badge” design problem entirely. The handle IS the verification. Designers do not need to create badge hierarchies, explain what badges mean, or handle user confusion about paid vs. earned verification.
3. Composable Moderation as User Choice
Instead of one moderation team making all content decisions, Bluesky lets users subscribe to moderation services (called “labelers”) that tag content according to different standards.
TRADITIONAL MODERATION
Platform → Single policy → Applied to all users
User has: "See less" / "Block" / "Report"
BLUESKY'S COMPOSABLE MODERATION
┌──────────────┐
│ Labeler: A │ → Tags NSFW content
│ Labeler: B │ → Tags misinformation
│ Labeler: C │ → Tags spoilers
│ Labeler: D │ → Community-specific rules
└──────────────┘
↓
User subscribes to labelers they trust
↓
Content tagged by subscribed labelers
gets: hidden / warned / labeled
↓
User controls: which labelers, what actions
SETTINGS UI:
┌─────────────────────────────────────────────┐
│ Content Moderation │
│ │
│ ┌─────────────────────────────────────┐ │
│ │ Bluesky Moderation (default) │ │
│ │ ✓ Subscribed │ │
│ │ Labels: NSFW, spam, impersonation │ │
│ └─────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────┐ │
│ │ Science Community Labels │ │
│ │ ✓ Subscribed │ │
│ │ Labels: unverified claims, preprint│ │
│ └─────────────────────────────────────┘ │
│ │
│ For each label type: │
│ [Hide] [Warn] [Show] [Ignore] │
└─────────────────────────────────────────────┘
Design Patterns Worth Stealing
Feed Marketplace Discovery
The feed marketplace is where Bluesky’s protocol architecture becomes a consumer feature. Users browse, preview, and pin feeds the way they might browse apps in an app store.
FEED MARKETPLACE
┌─────────────────────────────────────────────┐
│ Discover New Feeds [🔍] │
│ │
│ Popular Right Now │
│ ┌──────────────────────────┐ │
│ │ 🔬 Science │ │
│ │ Posts about science │ │
│ │ by @science-feed.bsky │ │
│ │ ♥ 45.2K likes │ │
│ │ [Preview] [+ Add Feed] │ │
│ └──────────────────────────┘ │
│ │
│ ┌──────────────────────────┐ │
│ │ 🎨 Art Feed │ │
│ │ Curated art posts │ │
│ │ by @art.bsky.social │ │
│ │ ♥ 32.1K likes │ │
│ │ [Preview] [+ Add Feed] │ │
│ └──────────────────────────┘ │
│ │
│ Categories: │
│ [News] [Tech] [Art] [Science] [Sports] │
└─────────────────────────────────────────────┘
The design decision: Feed cards show the creator’s handle, a like count for social proof, and a preview button before committing. This mirrors app store patterns that users already understand, reducing the cognitive cost of a novel concept.
/* Feed card in marketplace */
.feed-card {
padding: 16px;
border: 1px solid var(--border-color);
border-radius: 12px;
background: var(--card-bg);
transition: box-shadow 0.15s ease;
}
.feed-card:hover {
box-shadow: 0 2px 12px rgba(0, 0, 0, 0.08);
}
.feed-card-header {
display: flex;
align-items: center;
gap: 12px;
margin-bottom: 8px;
}
.feed-card-avatar {
width: 40px;
height: 40px;
border-radius: 8px;
background: var(--accent-blue);
display: flex;
align-items: center;
justify-content: center;
font-size: 20px;
}
.feed-card-meta {
font-size: 13px;
color: var(--text-tertiary);
margin-bottom: 12px;
}
.feed-card-actions {
display: flex;
gap: 8px;
}
.btn-add-feed {
padding: 6px 16px;
border-radius: 20px;
background: var(--accent-blue);
color: white;
border: none;
font-size: 13px;
font-weight: 600;
cursor: pointer;
}
.btn-preview {
padding: 6px 16px;
border-radius: 20px;
background: transparent;
color: var(--text-secondary);
border: 1px solid var(--border-color);
font-size: 13px;
cursor: pointer;
}
Threading and Quote-Post Conversation Design
Bluesky’s thread visualization handles a design problem that Twitter never fully solved: showing conversation context without losing the reader’s place. Reply threads indent with connecting lines, and quote posts render as embedded cards with clear visual hierarchy.
/* Thread connector lines */
.thread-reply {
position: relative;
padding-left: 52px; /* avatar width + gap */
}
.thread-reply::before {
content: "";
position: absolute;
left: 20px; /* center of parent avatar */
top: -8px;
bottom: 0;
width: 2px;
background: var(--border-color);
}
/* Quote post embed */
.quote-embed {
margin-top: 8px;
padding: 12px;
border: 1px solid var(--border-color);
border-radius: 8px;
background: var(--card-bg);
font-size: 14px;
}
.quote-embed-author {
display: flex;
align-items: center;
gap: 6px;
margin-bottom: 4px;
font-size: 13px;
}
.quote-embed-avatar {
width: 16px;
height: 16px;
border-radius: 50%;
}
.quote-embed-handle {
color: var(--text-tertiary);
}
The Verdict
Bluesky is the first social network to prove that protocol-level architecture can be a consumer-facing design feature. Feed selection as primary navigation, domain handles as trust signals, and composable moderation as user preference are all patterns born from the AT Protocol’s separation of concerns. The design team’s achievement is not the protocol itself — it is making concepts like “algorithmic choice” and “identity portability” feel as natural as switching between tabs. For designers, Bluesky demonstrates that the hardest UX problems are not about pixels but about making invisible infrastructure legible to humans.
Best for learning: Surfacing backend architecture as UX features, marketplace patterns for abstract concepts, trust signal design without badge systems, and moderation UX beyond the binary of “allowed” and “removed.”
Frequently Asked Questions
How does Bluesky’s feed system differ from Twitter’s “For You” tab?
Twitter offers one proprietary algorithm alongside a reverse-chronological timeline. Bluesky lets anyone build and publish a feed algorithm, and users can pin multiple feeds as tabs they switch between. A user might have “Following” (chronological), “Science” (topic-filtered), “Quiet Posters” (surfacing accounts that post rarely), and “What’s Hot” (trending) all accessible as swipeable tabs. Each feed is built by a different developer or community.
What is a DID and why should designers care about it?
A DID (Decentralized Identifier) is a permanent identity that persists even if a user changes their handle or server. Designers care because it enables patterns like domain-based verification (your handle IS your domain), server migration without losing followers, and cross-app identity. The UX challenge was making this invisible — users set a custom handle and it “just works” without understanding the cryptographic infrastructure.
How does composable moderation work in practice?
Users subscribe to “labelers” — services that tag content with labels like NSFW, spoilers, or misinformation. Each user controls which labelers they trust and what action to take per label (hide, warn, show). This means a parent and a researcher can use the same platform with different content boundaries, without either being “wrong.” The design challenge was making this feel like a preference rather than a chore.
Can Bluesky’s feed marketplace pattern apply to non-social products?
Absolutely. Any product with content curation — news aggregators, e-commerce, learning platforms, music services — could offer user-selectable algorithms. The key Bluesky pattern is treating the algorithm as a swappable, visible component rather than a hidden infrastructure decision. Even dashboards and analytics tools could let users choose between “curated for me” and “community popular” views using this same tab-based selection model.
How does Bluesky handle the cold start problem for new feeds?
Feed creators can set their feed to be publicly listed in the marketplace with a description, preview, and like count. Popular feeds get social proof through likes and subscriber counts. New users see a curated “Discover Feeds” screen during onboarding that highlights popular and category-relevant feeds. The preview button lets users see sample content before committing, reducing the risk of adding a bad feed.