Building Beautiful Context

What I've been up to lately — and why I think it's the most valuable thing I've ever shipped.

For the past month, I've been building beautiful context in my working environment.

Not features.
Not another AI wrapper.

but a Context.

I know how that sounds. Everyone is talking about context right now. Context engineering is the new prompt engineering. Context windows keep getting longer, context is king, context is the moat. Every thread, every talk, every roadmap says the same thing: context matters.

But here's what I kept noticing: everyone tells you that context matters. Almost no one tells you what good context actually is. We talk about engineering it, stuffing it, compressing it, retrieving it — and we've never stopped to define the thing itself. What does beautiful context look like?

So let me offer a definition. I made a short film to launch a context agent inside the company I work with, and the whole film exists to earn its last line:

Beautiful context is a curation: the smallest set of high-signal things that make the right outcome plausible. Relevance over volume. Freshness over completeness. It's the right constraint.

The most beautiful context in human history

Before I tell you how we implemented this, let me show you where the inspiration came from — my personal favorite, and I'd argue the most beautiful context ever assembled.

In 1977, @NASA strapped a gold-plated record to the side of two spacecraft and threw it at the stars. It was not a backup of human knowledge. No encyclopedia. No textbooks. A small committee asked an impossible question — if you could only send the part that matters, what would it be? — and answered it: greetings in 55 languages, Bach, a heartbeat, whale song, 116 images of who we are.

A curation. The smallest set of high-signal things. Loaded by hand in a clean room, addressed to a foreign intelligence.

Sit with that phrase for a second, because it's the whole idea. Every AI your team works with is exactly that — a foreign intelligence. It arrives knowing everything in general and nothing about you. Not your strategy, not your decisions, not why you killed that feature in March, not what "good" means on your team. The model has knowledge. It does not have your context.

And context is the only part you own.

Why builders need a context layer

In product development, this gap shows up every single day. Designers, engineers, and stakeholders each hold a fragment of the truth. The strategy lives in a deck, the decisions live in someone's memory, the constraints live in a thread nobody can find. Traditionally, one person sits at the intersection and transmits all of it by talking — Brian Armstrong once told new product managers their job is to be the communication hub, the point of contact for everything about the product.

He's right. And in the AI era, that's the floor, not the ceiling. Communication routes information: push-based, synchronous, decaying the moment it's spoken. You repeat the same rationale in four meetings and it still evaporates. A communication hub scales with your calendar.

So we built the upgrade: a context layer — an AI agent that exposes the curated context to the whole team. Ours is an octopus that lives in Slack (there's a 1988 Konami game behind that choice — watch the film). Ask it one question and it answers for your role: the frontend engineer, the backend engineer, and the designer each get their slice of the same truth. And every AI tool the team uses — the coding agents, the design tools — speaks to it too. That's the real point: it doesn't just align the humans. It's the enterprise AI strategy in one move, because it enables the people who actually build.

Three design decisions shaped how we built it:

Context as a Service Layer. The dream of manufacturing software on an assembly line mostly failed — code turned out to be craft. But context can be manufactured: swept, distilled, reconciled, and quality-gated on a daily schedule. The factory doesn't build the product. It builds the shared understanding the product gets built from.

Backpropagation, for organizations. Borrowed straight from how neural networks learn: outcomes propagate backward and update the weights. Here, shipped code back-propagates into product context — every merged PR gets translated into "what this means for the product," and durable lessons get proposed upstream into ground truth. The context layer doesn't just flow forward from strategy to team. It learns backward from what actually shipped. That's what keeps it fresh instead of drifting into fiction. Inspired by @chamath 's @8090_Factory Backpropabagation.

Agentic tools over MCP. The fashionable move is to hand the model a pile of API surface. We went the other way: teach the agent processes — small, versioned recipes that encode how we do things here. A tool catalog gives a model capability. Agentic tools give it your team's judgment. It's the difference between handing someone the keys to the building and handing them the operations manual. Inspired by @Spotify 's Building a Natural Language Interface to the Spotify Ads API with Claude Code Plugins | Spotify Engineering: https://engineering.atspotify.com/2026/5/spotify-ads-api-claude-plugins

Here's the whole architecture, at the altitude I can share:

a LOOP curates context for product development in enterprise

Signals are born where work already happens — Slack, Google Docs, GitHub PRs. An agent distills them daily, everything cited, uncertain changes rejected. The output lands in two stores moving at two speeds: working context (what's true this week, auto-updated) and baseline context (what's durably true — and the agent may only propose changes there; a human approves every one). Both stores are just markdown in a GitHub repo — versioned, diffable, reviewable like code. Then the layer is served back to the team and every AI tool, the team ships with it, and what ships becomes tomorrow's signal.

Working context is automated. Ground truth is earned. And the loop is what keeps it true.

So how does the team actually touch this? Internally, we expose the layer through a Slack bot — the context agent. Before it answers any question or runs any agentic task, it loads the relevant project context first. That ordering is the whole trick: it never reasons from a blank slate, it reasons from the curated record. Ask it a product question, hand it a task, and it starts from what we know, what we've decided, and why.

And just as often, it doesn't do the work itself at all. It simply serves the context — engineers pull the relevant slice and feed it straight into Claude Code, GPT, or whatever AI tool they're building with that day. The agent in Slack is just one consumer of the context layer, the one with the friendliest face. The layer itself is tool-agnostic by design: curated once, consumed everywhere.

Notice what's not in the diagram: no new database, no new destination, no vendor's name in the load-bearing position. The models underneath are replaceable engines. The factory, the loop, and the recipes are ours.

What actually changed

Three things, and they surprised even me.

Alignment became ambient. The team stopped re-litigating priorities in meetings, because the answer is the same everywhere — it comes from one curated place, sliced per role.

Tokens got economic. Average token usage dropped significantly, because the AI tools stopped burning tokens rediscovering the same background every session. Beautiful context is literally cheaper — relevance over volume is a cost function. Engineers now spend tokens building features instead of funding archaeology.

Quality went up. The answers, the generated code, the PRs — dramatically better, because the models finally know the given: the metric definitions, the decisions, the constraints. Same engines, better fuel.

Cultivate your own

Here's the part I actually want you to take away, whether you run a company, a team, or just yourself and a laptop full of AI tools:

Cultivate your own context.

Models will keep changing — treat them as interchangeable engines. If your judgment lives in your context layer, you can swap engines freely. If it lives in your habits with one vendor's product, you're not their customer; you're their training data.

Every company, every team, every person should be curating their own golden record — the smallest set of high-signal things about how they work, what they've decided, and what matters — addressed to whichever foreign intelligence they build with next.

That's what I've been up to. Building beautiful context.

Next post: how it's actually built — the memory architecture, the pipeline mechanics, and what broke along the way. Bring coffee. 🐙

Originally published as an X Article on July 12, 2026. Read on X ↗