Design systems are becoming agent infrastructure, whether you meant them to or not

There's a pattern in this week's links that's easy to miss if you read them one at a time: design systems are quietly becoming a second kind of API, one where the client isn't a developer copying a component but an agent trying to infer your intent from whatever documentation, tokens, and prompts it can scrape together. Manufact's launch on Hacker News framed itself as "MCP Cloud," which sounds like plumbing, but the plumbing is the point — someone finally built hosting infrastructure for the protocol that lets agents call tools reliably, and the fact that it landed at 108 points says the market agrees this is no longer a side quest.

The more interesting artifact, though, is the Claude Design System Prompt repo that hit HN the same week. It's a deceptively simple idea: a structured prompt that forces Claude to actually respect your design tokens, spacing scale, and component contracts instead of inventing plausible-looking CSS from scratch. That it needed to exist at all is the real story. We spent a decade writing design system documentation for humans who could ask a Slack channel when something was ambiguous. Now the reader is a model with no channel to ask, and ambiguity just gets silently resolved in whatever direction the training data leans. GolemUI's declarative form engine is solving an adjacent version of the same problem from the other direction — instead of prompting a model to behave, it constrains the surface area so there's less room for an agent (or a developer, or Figma's own AI features) to improvise incorrectly. And Attio's engineering writeup on building their own MCP server is worth reading precisely because it's not theoretical: they document the actual failure modes of exposing a real, stateful product to tool-calling agents, which is a more honest source of lessons than any conference talk on "AI-ready design systems" will give you.

the vibe shift from prompting to architecting

Run this alongside Valmis, the open-source alternative to Claude's Cowork that appeared on HN this week, and a theme snaps into focus: the interesting work isn't happening in the chat window anymore. It's happening in the scaffolding around the chat window — the tool definitions, the schemas, the guardrails that decide what an agent is even allowed to attempt. This is exactly the argument buried in "Never mind the prompts, here's the thinking" on UX Collective, where the author describes a year spent rebuilding a studio's process around AI and concluding that speed was never the bottleneck — judgment was. The fastest part of any AI-assisted workflow is generation. The part that actually needs a human is deciding what should never have been generated in the first place. That's not a prompting skill. It's an editorial and architectural one, and it maps directly onto what Manufact, the Claude Design System Prompt, and GolemUI are all trying to encode structurally instead of conversationally.

separating the things that actually vary

The clearest non-AI piece this week, ironically, makes the same point in miniature. Always Twisted's argument for separating themes from modes — themes as identity, modes as brightness and accessibility state — is a small, almost obvious idea until you notice how many design systems still conflate the two and pay for it every time someone asks for a new brand skin or a system-level contrast mode. The fix isn't cleverness, it's just refusing to let two independent axes share one variable. That's the same discipline Smashing Magazine is asking for in "Why Accessibility Is An Operational Capability, Not a Feature" — accessibility stops being an end-of-sprint audit only once it's treated as an orthogonal, continuously-checked axis rather than a property bolted onto a finished component.

The AI-interface pieces converge on the identical lesson from the UX side. UX Collective's "39 principles for designing human-AI interaction" is essentially a taxonomy of what happens when you don't separate concerns: reliance, control, transparency, and autonomy get smeared together into one undifferentiated "AI experience" instead of being designed as independent, composable dimensions. Smashing's piece on matching AI modality to user intent makes the sharpest version of this argument — chat became the default interface for everything not because it's right for everything, but because it's the shape the training data came in, and defaulting to it is exactly the kind of unseparated-concerns mistake that themes-vs-modes and accessibility-as-checklist warn against. And the companion piece on seamless integrations over more tools is the product-strategy version of the same idea: users don't want another surface to learn, they want the capability slotted into a mental model they already have — which is, again, an argument for designing the seams rather than the feature.

None of this is really about AI. It's about the fact that every system — a component library, a chat interface, an accessibility program, a form engine — degrades the moment two things that vary independently get bundled as one. The agents are just the newest, least forgiving reader of your architecture, which makes this a genuinely good week to go find the place in your own system where two concerns are still tangled and pretend an unreasonable client is about to consume it.