Built with Claude

Builder Hub

Role Designer · self-initiated · built it end to end
Scope Salesforce Builder org · 12 team sites
Built with Claude Code · Slack MCP
Status In use internally · 2026

A knowledge system I built to onboard myself, then the whole org.

I joined Salesforce's Builder org during a transition, ramping on a product that spans no-code, low-code, and pro-code experiences built by many teams. The hardest part wasn't the work. It was finding it: resources, links, and decisions scattered across Slack canvases, Figma files, and research docs that no one had time to gather in one place. I decided to build that place.

Builder Hub started as a site to onboard myself and grew into a knowledge system for twelve builder teams. It has an agent you can ask, feeds that keep themselves current, and one way to search across all of it. I designed and built the whole thing end to end, including the parts a designer isn't expected to touch.

It's the clearest example of how I work now: when the tool I need doesn't exist yet, I build it, all the way to something running and in use.

Onboarding shouldn't mean a scavenger hunt.

Give every builder team, and anyone joining one, a single place to find the work, see how it fits together, and search across all of it.

I had time in the transition and a choice about how to spend it. I could read scattered docs until I'd pieced the picture together for myself, or I could build the thing that pieced it together for everyone after me. I went with the second. My bet was that onboarding pain is a symptom of a missing system, not a missing wiki page, and that a designer is well placed to build that system, because the whole job is making complex information findable and clear.

From a personal onboarding site to a cross-team system.

It grew in layers, and each one solved the next problem the last one surfaced. Jump into any part.

Everything existed. Nothing was findable.

The Builder product is genuinely complex, spanning no-code, low-code, and pro-code experiences across many teams. The information to understand it was real, but scattered: Slack canvases, channel threads, Figma files, research readouts. To answer a basic question, who owns this, what's the latest research, where's the current design, you had to know which of a dozen places to look and who to ask.

For someone new, that's a wall. For the teams themselves, it's a quiet tax: the same questions re-answered, the same links re-shared, work duplicated because no one could see what already existed. The resources were never the problem. The missing system around them was.

A site for my team, and for me.

I started small, and a little selfishly, in the best way. I built one site for my new team that pulled together everything I needed to ramp: the canonical links, the design files, the research, the people and what they own. Building it was how I learned the product. Every resource I tracked down and placed was something I now understood, and something the team could reuse instead of rediscovering.

The principle I held: it had to be lower-effort to use than to ignore.

If keeping it current was manual, it would rot like every wiki before it. That one constraint shaped everything that came next.

Resources and canonical links in one place, so "where's the doc for X" stops being tribal knowledge.
Design files and architecture gathered per team, so the current thinking is visible instead of buried in someone's Figma.
Research readouts collected together, so findings live somewhere durable instead of scrolling out of a channel.
People and ownership, so a newcomer can see who works on what without asking around for a week.

A feed that keeps itself current.

A knowledge site is only worth trusting if it's current, and current is exactly what people are worst at keeping up. I made the site maintain itself. A scheduled job runs three times a week, scans the team's Slack, and pulls in anything new, fresh research, new Figma files, updated resources, then surfaces it in a live feed so the team sees what changed without going looking.

This is where I stopped requesting tools and started building them. It runs on Claude Code with the Slack MCP, on a schedule, with no one in the loop. The design decision underneath it is about attention: the feed shows what's new since you last looked, not an undifferentiated dump, because the value is saving people the hunt, not relocating it.

From a pile of links to something you can interrogate.

Gathering isn't understanding. The next layer turned the collection into something you could reason over. I added a place to synthesize research across sources, so shared findings and contradictions surface instead of staying buried in separate readouts, and a way to look across the architecture and designs themselves.

The piece that ties it together is an "Ask the Hub" agent. Instead of knowing which canvas to open, you ask a question and it routes you to the right tool, pulls cross-team research into one view, and can even check a PRD against our trust and autonomy principles. It's the difference between a library and a librarian.

Wireframe of the Builder Hub home page with the Ask the Hub assistant A wireframe of the hub's front door: a top navigation bar, a central hero with an "Ask the Hub" input and suggested questions, a quick-access row of four destinations, a counts row shown as placeholders, and a right-hand assistant panel whose answers are grounded in hub data only. Builder Hub Directory Principles Architecture Reference BUILDER HUB Building the experiences of the future One directory for every builder team, from no-code to pro-code. Ask QUICK ACCESS Directory Principles Architecture Demos TEAMS Hub Assistant SUGGESTED QUESTIONS source source Sourced from Builder Hub data only The agent only answers from hub data, and cites the team it came from.
Wireframe of the hub’s front door. Ask the Hub sits above the directory, not beside it, and every answer carries the team it came from. Internal UI redrawn as a wireframe.

One hub across every builder team.

Once it worked for one team, the obvious question was why stop there. Every builder team had the same problem, and we were all heading to an internal builder summit where the whole ecosystem would be in one room. I scaled it. I built a separate site, with its own repo, for every builder team we knew of, seeded with all the resources I could reach, and handed each one off to its team to own and grow.

Above them sits the Builder Hub: a parent that pulls from all twelve team sites and lets you search across the entire ecosystem at once. Compare how different teams approach the same problem. See the architecture side by side. Find who works on what. As each team fills its site with richer research and design files, the whole system gets sharper, and the places where we should be driving consistency get easier to see.

Builder Hub connected to twelve builder team sites A parent Builder Hub at the top connects to twelve builder team sites, all on the same level and seeded from shared Slack canvases. Rich information flows up into the hub, and search and navigation flow back out to every team. Builder Hub Ask the Hub · searches every team 12 builder team sites, seeded from shared Slack canvases Rich information flows in; search and navigation flow back out.
The shape of the system: one Builder Hub over twelve team sites, each seeded from shared Slack canvases. Rich information flows up into the hub; search and navigation flow back out to every team.
Wireframe of the Builder Hub team directory A wireframe of the directory screen: a row of filter tabs, then a grid of eight team cards. Each card carries the team name, the persona range it serves from no-code to pro-code, a short description, and counts of linked PRDs and live demos. Team names are shown as neutral placeholders. Builder Hub Directory Principles Architecture Reference Team Directory Every builder team, filterable by persona All TEAMS Team A Open site No code Low code PRD 1 demos Team B Open site No code Pro code PRD 2 demos Team C Open site No code Low code PRD 3 demos Team D Open site Low code Pro code PRD 1 demos Team E Open site No code Low code PRD 2 demos Team F Open site No code Low code PRD 3 demos Team G Open site Pro code PRD 1 demos Team H Open site No code Pro code PRD 2 demos Every card answers the same question: who owns this, and who is it for?
Wireframe of the directory. Team names are neutral placeholders; the persona range and the ownership signals are the structure that mattered. Internal UI redrawn as a wireframe.

A designer on the full build, not just the brief.

I built Builder Hub end to end, including the parts a designer usually hands off. That's why it's here. The judgment that used to stop at a spec now runs all the way to a working, governed, deployed system.

1

Claude Code + Slack MCP

Wrote the scheduled jobs that scan Slack and refresh every site on their own, three times a week, with no one in the loop.

2

The “Ask the Hub” agent

Built the cross-team agent to run client-side against the hub’s own data, so a question routes across every team’s content instead of dead-ending in a single doc, with no backend to keep alive.

3

A repo per team

Stood up a separate site and GitHub repo for each team, then handed them off individually, so every team can own and extend their own.

4

Authentication and access

Wired up OIDC auth so the right people get in and internal content stays protected.

5

Enterprise AI governance

Cleared the full enterprise AI governance path myself: AI Council, RFC, and legal review. At a company this size, the design isn't done until it's allowed to exist.

The automation commits. It still doesn’t get to speak for me.

Between April and August the repo took 223 commits. 124 came from automation and 99 from people. The two paths are deliberately different. People branch, open a PR, and wait: main is protected, CODEOWNERS puts me on every one, and I batch reviews Monday and Thursday. The scrapers skip that gate on purpose and commit content straight to main, so the bot never sits waiting on me. Content flows. Code gets read.

Building an agent that runs unattended means deciding what it’s allowed to do quietly, and two calls did most of that work. The decision-log scrape still times out. Rather than retry in silence, it reports the failure in the morning summary every day, where I have to look at it. A silent failure should never get to look like success.

The second is the PR-review nudge. It writes the Slack message and stops. It can’t clear the approval gate on its own, so the draft sits in my queue until I send it. The agent prepares the work. Sending it is still mine.

223
Commits, April to August
124
Committed by automation
99
Committed by people
Mon + Thu
Every human PR reviewed by me

A foundation the whole ecosystem can build on.

Builder Hub is in use internally. It started as my own onboarding and became shared infrastructure for the builder org:

12
Builder team sites, one per team
3× / wk
Each site refreshes itself
1
Search across every team
End to end
Designed, built, and governed solo

The return compounds. Every team that enriches its site makes cross-team search, architecture comparison, and the case for consistency stronger for everyone. That case is being made now beyond the builder org: adoption across our wider UX org is being promoted with executive buy-in behind it.

Build the system, not the workaround.

The honest limitation is that a shared system is only as good as what teams put into it. The scaffolding, the feeds, the agent, the search, those I could build. Whether each team keeps its site rich with their latest thinking is a habit, and habits take longer to change than code does.

What I'd carry forward is smaller and more personal. I almost talked myself out of building this, because gathering links felt like below-the-line work, not "real design." It turned out to be some of the most useful work I've done. Making complex information findable and current is the heart of the job. The tools just finally let a designer build the answer instead of filing a request for it.

Built with Claude
Want the build details?
Builder Hub is internal, so the screens stay behind the firewall, but I'm happy to walk through how it works: the scheduled Slack jobs, the "Ask the Hub" agent, the per-team repos, and the governance path I cleared to ship it.
Next Project
Agentforce Coworker →
Designing the setup layer for platform-wide agentic search.