Reimagining how people create at scale

overview

Years of complexity had made Reddit’s creation experience harder than it needed to be.

Contributors had to choose between rigid post types before they could simply begin creating, while thousands of community configurations and content rules made the underlying system difficult to evolve. I led the effort to replace that model with a universal composer and a reusable attachment logic system that could adapt around what contributors were creating.

Impact

The work replaced a fragmented creation model with a more flexible foundation for expression. We shifted significant complexity out of the interface and into reusable system behavior, created logic that could scale across Reddit’s diverse community configurations, and established a faster way for Design and Engineering to discover and validate complex product behavior together. We shipped the first modernization milestone within a quarter.

Team & Partners

Product, Web Engineering, Design Systems, User Research, Data Science, Product Leadership, Executive Leadership

Creation Had Accumulated Years of Complexity

As Reddit entered a new period of product leadership, our team had an opportunity to reconsider the foundation of posting.

People successfully created posts every day, but the experience had accumulated years of product decisions. Text, images, video, and links each opened slightly different creation experiences with their own behaviors and limitations. Before contributors could simply express themselves, Reddit asked them to decide what kind of post they were creating.

That model increasingly became a constraint. New capabilities had to fit within an existing post type or introduce another specialized workflow. Mixing formats was difficult, and the interface increasingly reflected the architecture underneath it rather than how people naturally create.

At first glance, this looked like a composer redesign. The deeper problem was that years of product complexity had become visible to contributors.

Making the Bet Legible

Modernizing the composer wasn't an obvious investment. Users were already successfully posting, there were opportunities elsewhere in the contributor journey, and new product leadership was still developing its perspective on where to invest.

We didn't need everyone to commit to a multi-year transformation. We needed to make the opportunity concrete enough to evaluate. So we connected the long-term vision to a meaningful first milestone we could ship within a quarter.

Instead of asking whether Reddit should rebuild creation, we could demonstrate whether a simpler, more extensible model was worth continuing to invest in.

Starting With a Different Model of Creation

I studied modern creation experiences to understand how other products handled increasingly complex forms of expression.

A consistent pattern emerged. The best composers didn't ask people to classify their intent before acting on it. They let people begin creating and adapted around them.

That led to three principles:

• Start with expression. Let people create before asking them to make unnecessary decisions.

• Reveal complexity progressively. Surface tools and controls when they become relevant.

• Design for what comes next. Create a system that can absorb future forms of expression without another foundational redesign.

The resulting interface looked significantly simpler. Making it work was anything but.

The Simpler the Interface Became, the Smarter the System Had to Be

Removing post types eliminated decisions from the interface. It didn't eliminate the decisions themselves.

The system still needed to understand what each community allowed, which formats could coexist, what someone had already created, what they could add next, and how to respond when their context changed.

Could an image be added? Could it coexist with a link? What happened if someone switched to a community that didn't allow the content they had already created?

Contributors no longer needed to manage that complexity themselves. The system did.

That became the real design problem.

I Turned the Edge Cases Into a System

As we explored the universal composer, what initially looked like hundreds of individual states began revealing a smaller set of recurring decisions.

Community rules determined what was possible. Existing attachments changed what could happen next. Some formats could coexist while others couldn't. Changing context could invalidate something already created.

Instead of designing every state independently, I began extracting the rules underneath them.

That became our attachment logic system.

Instead of specifying hundreds of interfaces, I could define a smaller set of rules capable of generating the right behavior.

The design artifact wasn't just the interface anymore. It was the logic underneath it.

Then I Built Against the Model

The matrix gave us a way to reason about the rules. Next, I turned those rules into a product architecture.

The core question became where the complexity should live: with the contributor up front, or in the system surrounding the act of creation.

The direction became increasingly clear. Instead of asking contributors to choose a format or capability before creating, I could keep the canvas stable and move more of the complexity into the system around it.

But static architecture couldn't tell me whether the model would hold up in use. So I began building much earlier.

Emerging AI development tools dramatically reduced the distance between an idea and something I could experience. That let me build earlier, test more configurations, expose broken assumptions, and keep refining the interaction model while it was still forming.

Reddit communities can allow completely different combinations of content. I connected the prototype to real community configurations so I could watch the same composer adapt as its context changed.

The same logic extended to individual controls. The question wasn’t only what tools the composer needed, but how much interface should be visible before those tools became relevant.

Different media no longer required different creation experiences. They could share the same underlying system while preserving the behavior unique to each format.

The final direction kept the canvas quiet by default and moved controls closer to the moment they became useful: focus, selection, object state, and community capability.

Instead of treating images, video, and links as separate creation modes, I began modeling them as objects that could enter the same composition system.

Each attachment behaved differently, but underneath those differences was the same interaction grammar.

The grammar stayed consistent while each object preserved the behavior unique to its format.

Different media no longer required different creation experiences. They could share the same underlying system while preserving the behavior unique to each format.

Prototypes Became a Shared Language With Engineering

Building earlier also changed how I collaborated with Engineering. Instead of resolving the design, documenting every state, and waiting for implementation to expose broken assumptions, we could encounter those questions together. I brought working prototypes and system logic into engineering conversations so we could manipulate the experience rather than speculate about it.

The prototypes weren't specifications to copy. They became shared environments for figuring out what the product needed to become, helping us develop the product and technical architecture with greater confidence before production implementation began.

Then We Put the System in Front of Reality

Eventually, prototypes couldn't answer the most important question: Would the new creation model hold up once people actually used it?

We initially saw a novelty effect, particularly among experienced contributors adjusting to an unfamiliar composer. It faded quickly, and adoption of the new model followed.

More interesting were the places where the system collided with behaviors the old experience had quietly trained.

Two issues stood out.

1. People pasted links instead of choosing them. Previously, some communities surfaced a dedicated link field by default. The universal composer removed that explicit affordance, but contributors showed us what they expected instead: they pasted URLs. Rather than teaching people how the composer wanted links added, we prioritized recognizing what they were already trying to do.

1. People expected pasted content to retain its structure. We also saw people paste richer content into the composer and expect more of its original structure to survive. Those failures showed us that flexibility alone wasn't enough. The system needed to interpret more of the intent contained in what people brought into it.

Both issues reinforced the same principle: Creation shouldn't require people to translate their intent into the product's internal model. The system should infer as much as it reasonably can from what they're already trying to do.

Those signals changed what we built next. Rather than reintroducing more explicit controls, we pushed the system further in the opposite direction: Make creation smarter by interpreting more of what people were already trying to do.

That led to two priority improvements.

Smart Link Detection: Recognize pasted URLs and automatically turn them into the right link experience without requiring contributors to choose a specific attachment type.

Richer Copy & Paste: Preserve more of the structure and intent when people bring content into Reddit from elsewhere.

Both moved the composer closer to the same goal: Less instruction for the contributor. More intelligence in the system.

Outcomes

The outcome was bigger than a redesigned web composer. We established a more extensible model for creation, proved contributors could adapt to a simpler experience, and shipped the first modernization milestone within a quarter. Usage also increased across richer formats, including a 4% increase in users creating video posts, providing early evidence that simplifying the entry point did not limit expression.

Underneath the interface, we defined reusable rules for attachment availability, compatibility, validation, and recovery across Reddit's diverse community configurations. Complexity that had previously lived across individual screens could now be handled through shared system behavior capable of supporting future creation formats.

The work also changed how we built. Working prototypes connected to real community configurations became shared environments for Design and Engineering to uncover edge cases, test assumptions, and reason about product and technical architecture together.

Key Learnings

• Sometimes the fastest way to understand a system is to build it. I couldn't anticipate every configuration or edge case in a design file. Each prototype exposed gaps in the model and made the underlying rules clearer.

• New tools matter when they change how you think, not just how fast you work. AI development tools let me test behavior, real data, edge cases, and architecture while ideas were still forming. They gave me a new medium for exercising design judgment.

• Leadership can happen through making. A prototype made an idea tangible. A working iteration exposed a constraint. A system model created shared language. Each artifact helped the team make the next decision with greater confidence.

More Featured Work