The lab

Nothing here is finished.

Half of this job is holding on to the questions you can’t answer yet. This is where I keep mine: open threads, half-formed opinions, and a few things I’ve changed my mind about.

Open threads
🤖
Thinking about

Where agent autonomy actually saves time, and where it just adds risk.

🛠️
Building

Experimenting with autonomous AI agents, custom skills, and multi-step flows. Currently exploring what an agentically run brand experience could look like beyond the conventional website.

📚
Learning

How multi-agent systems negotiate, delegate, and recover from failure.

Small discoveries

Questions I haven’t let go of.

No conclusions attached. I’m leaving them as questions on purpose. There’s a surprising amount going on under the surface of the everyday world.

  1. 01Why do airport signs all feel intuitively familiar?
  2. 02Why does every AI product suddenly need memory?
  3. 03Why are some interfaces easier to understand before you know how they work?
  4. 04And why does the golden ratio keep turning up in things nobody designed?
How I think

Three things building products has argued me into.

An AI answer isn't useful just because it sounds right.

The Developer Knowledge MCP server didn't ship because a demo looked convincing. We tested it with a blind evaluation: a technical writer scored answers without knowing which version produced them. The score improved from 7.6 to 8.5, surpassing the launch bar we'd set at 8. Good demos show what's possible. Rigorous evaluation tells you what's ready to ship.

The eval story

Most "ambiguous" problems just haven't been asked precisely enough yet.

Firebase Studio's Chat Unification charter arrived as an open-ended instruction: unify the experience. It only became buildable once it was scoped into two actual questions, unification then context sharing, each with its own milestone. Ambiguity usually isn't a property of the problem. It's a sign the question hasn't been cut in the right place yet.

How it was scoped

A model doesn't need to know everything. It needs to know where to look.

The interesting part is how different pieces work together: what an agent should retrieve, which tools it should invoke, what it should remember, and how it should decide what to do next. Less about making a model know more, more about giving it the right capabilities, context, and autonomy to get things done through orchestrated agent workflows.

The shift is from AI that answers questions to systems that can reason, act, and deliver outcomes.

How it's built

Got an answer to any of these? I'd like to hear it.

Tell me