I've spent fifteen years practising design on the Double Diamond: discover, define, develop, deliver. This year I ran it as a founder on Spades Audio, the per-app audio mixer for macOS that Sasi and I are building, with AI design tools now part of the kit. The diamond didn't change; the tempo did. Synthesis that took me a fortnight now takes an afternoon, and product decisions land days after the evidence. We put two features on the roadmap that had nothing in common on paper: one lets AI assistants drive the mixer, the other lets macOS Focus Modes switch audio presets automatically. The first had no interface to design at all; the second had an interface Apple had already half-designed for us. Neither fit through a tidy diamond, and both shipped anyway. Here's where each phase went.
The feature with no screens
The MCP integration started as a spec: audio control tools over a local socket for system volume, output devices, listing audio apps, per-app volume, mute and routing. There was nothing to draw. The whole design surface was language. What the tools are called, how their descriptions read, what the parameters accept. Get those wrong and the assistant on the other end reaches for the wrong tool, or none at all.
Which meant discovery ran backwards. The moment the first build worked, the MCP server became our research instrument. Open Claude, say "drop Spotify to twenty per cent and route the call to my AirPods", and the engine just did it. Real use started correcting the spec almost immediately. Nobody asks for twenty per cent. They say "mute everything except the meeting." Watching early testers (and, honestly, ourselves) phrase audio intent in plain language changed the tool descriptions, the defaults, and the build order of everything after. The synthesis loop was the quiet win. I fed session notes and tester asks into Claude, patterns came out the same afternoon, and the next build usually answered them within the week. Same story on the market side: the competitive scan behind the original spec took me a day, not a fortnight of tabs. Our tool list has since grown well past the original eight (EQ, balance, per-app mic control, playback) and almost all of it came from "why can't I also..." moments that no upfront discovery would have caught. Apple wiring MCP support into App Intents since the 26.1 betas makes the bet look early rather than odd.
The feature that was all constraints
Presets were the opposite problem. Convergence arrived before we'd diverged at all. The feature connects Spades to Focus Modes through Apple's SetFocusFilterIntent, and that API hands you three non-negotiables before you've drawn a single rectangle. An app cannot create the link between a preset and a Focus; only the user can, inside System Settings. An app cannot ask which Focus is currently active. It only learns which preset was invoked. And the activation code runs in an extension process, not the app, so state has to live in a shared container.
Almost every screen decision fell out of that fence. The info card that deep-links to System Settings exists because we can't make the link for you. The per-preset "last activated" line exists because we can't read Focus state and still needed some way to show the automation is alive. Divergence only happened where options genuinely existed, which turned out to be the three-column presets screen and the route override popover. Those were the only things that touched Figma. Everything else lived in a build-ready spec carrying the data model, the copy strings and the acceptance criteria in one document. The spec did the job the mockup used to do, and did it closer to the code.
The rhythm that held both together
Two opposite problems, one working method, and it holds because of how the labour splits. Sasi owns the driver, the DSP and the clock sync: careful engineering, deliberately isolated so no single piece can take the whole system down. I iterate on top of it with Claude in a tight loop: a variant in code, in front of early-access testers, keep or kill. Because we're founders as well as the hands making the thing, the same evidence settles the product calls too, like what the free tier gives away, what stays Pro, and which feature ships first. No translation layer. And because everything routes through one service layer, design churn never destabilises the engine, so every prototype tests real behaviour rather than a simulation of it.
That loop rearranged my time without asking. Mockups have gone from most of my design work to maybe a third of it; the rest goes into specs and live builds with Sasi. What remains splits into two modes: polishing what already exists, and prototyping just ahead of it, like scheduled profiles and scene-based automation for presets. Far enough to steer, close enough to stay honest.
The diamond, redistributed
Stepping back from the recent experiences of adapting to this new world, I can still trace the diamond. Every phase is there, just not where I was taught to look for it. Discovery lives in real usage now, synthesised quickly instead of through extended deliberation. Divergence happens in code, in variants that cost days rather than weeks of engineering sprints. Convergence is a keep-or-kill call backed by real behaviour instead of a workshop wall. During the build of Spades, one thing became very clear. The process was never the value; knowing what a product should be and how it should feel is still the whole job. A sharper diamond just gets the evidence in front of our instincts sooner. That's what these two features were actually built on: real use, quick evidence, and the two of us backing our read of it. Spades is out now, and you can check it out at spadesaudio.com.