Start here

The invisible half

Take any app you used today. The screen is the half you see. Behind it there is a whole invisible product: a server taking every click, a database with users and orders, a waiting line for the heavy jobs, machines running the AI features, storage for the uploads, and billing charging the card.

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

That invisible half is cloud infrastructure. It is described in code, engineers change it every week, and a company usually has hundreds of these pieces across AWS, Azure and Google Cloud. One wrong change can take the product down.

For a couple of years I was the founding product designer at Bluebricks, designing tools for the engineers who run this half.

Recipe, notebook, kitchen

Bluebricks is an AI agent for cloud infrastructure. The easiest way to explain it is a kitchen.

Engineers write code that says: I want three servers and a database. That code is a recipe: instructions on paper, nothing exists yet. When a tool like Terraform cooks the recipe, it writes into a notebook: I built server A, database B. The notebook is the tool's memory. And the kitchen is what actually runs in the cloud right now.

All the trouble lives between the three. The notebook says one thing, the kitchen has another: that is drift, someone changed the kitchen by hand, and the next deploy can silently undo it. Or there is food with no recipe at all: unmanaged, nobody can safely rebuild it. Finding both is the cloud graph case.

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

Bluebricks connects recipe, notebook and kitchen into one live context graph. A user asks in chat, the agent reads the graph and cooks in this kitchen. A chef that never cooks without showing you the plan first.

Designing that chef filled my final year there. But the chef is the newest part of the story. The recipes came first.

LEGO for infrastructure

Back then, Bluebricks was the recipe book. Its unit is a word you will meet again and again: the blueprint. A blueprint is a recipe for a whole piece of infrastructure. The invisible half from the first answer, folded into one card:

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

Inside, every piece is an artifact with its own properties, and the values come in three kinds. Plain ones, like postgres: just set. Teal ones are references: the server does not invent the database address, it points at it. Teal means dependency, and the dependencies define what must run before what. And open ones: region says "to be set by deployer", somebody fills it later, while "known after apply" is a promise, the value exists only once the deploy runs.

The blueprint is versioned, and every ingredient inside is pinned to its own version. Yesterday's recipe still cooks the same dish, and if an upgrade breaks, you roll one piece back. Versions are what make people brave.

And blueprints compose: this whole application is one blueprint, and it could be an ingredient inside a bigger one. Built once, deployed again and again. That is when it pays off big: a region goes down, you relaunch everything in another region fast. Or you move from one cloud to another in one run, because the recipe is the source of truth, not the kitchen.

The place where blueprints get made is its own story: the blueprint composer case.

The pivot, and one question

Two honest reasons.

Adoption speed. With blueprints, an enterprise first had to turn all its existing code, millions of lines, into blueprints. Only then came the magic. Great endgame, very slow start.

And the context graph made a better start possible. Connect your git, connect your cloud, and the agent can act from day one.

So Bluebricks became the AI agent for cloud infrastructure, and my year became one question: how do you trust an agent that touches production? I designed three answers.

1. The agent never acts silently. It proposes a change, and nothing applies until you approve.
2. Changes land as pull requests: real changed lines of code, with the agent's explanation written next to them, so engineers review with their normal tools.
3. For its answers: the evidence graph. People did not trust what the agent said, so it shows its receipts, a live view of it reading the company's graph, where every node is a clickable citation.

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

The evidence graph case tells the third answer in full, and the cost-spike demo shows the first one running live, sounds included.

That is the product story.

Where I sat

I was the only designer, so everything routed through me. My seat, drawn as a workflow:

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

The purple stream is product: our CPO, a solution architect who lived with clients, and the users themselves through interviews, recorded sessions, Mixpanel and client Slack channels. That is where the why came from.

The green stream is engineering: VP Engineering, the backend team, the frontend team. That is where the how lived: constraints, feasibility, handoff.

Both streams merge in me. I took features end to end: flows and polish in Figma, live prototypes by directing Claude Code inside the real app, handoff through a design system I built from scratch, and every release passed my visual and functional QA. And notice the wire going back: roadmap work with our CPO and VP Engineering, deciding what we build next and why.

How I design

Inside, it is another workflow. A feature enters and goes through five nodes.

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

1. Understand. Many whys, and one above all: if my design is wrong, what can the user break? In my world a confusing screen can end with someone deleting production in one click. I start with the risks.
2. Explore, in Figma. A few directions side by side: still the cheapest place to compare, and the best place to see the whole picture.
3. Prototype. I direct Claude Code and build the winner inside the real app, on real data. A working thing beats a debate.
4. Ship, through the design system and my visual and functional QA.
5. Learn: sessions, Mixpanel, feedback channels.

And notice what I did not draw: a loop arrow back. A workflow does not loop, it runs again. Learn's output becomes the input of the next run, so the cycle lives in time, not in the wires. And inside a run, every node is redoable: when the prototype proves a design wrong, I re-run from Explore, not from zero.

terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 planstate + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9 vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { }vpc deny state + ~ terraform module ingest lock 0 1 apply drift graph { } 9fa3 plan iam helm => b4f aws_s3 allow k8s == 2f9

Generated in Figma Weave. Approved by a human, of course.