yogurtships with live cultures

Use yogurt in a project

OpenBoa projects share a vocabulary, a visual identity and familiar ways to interact. Each project owns what its product does and the words that describe its work.

Available today   English terms, artwork and fonts, tokens and web controls. The product playbook and pattern lookup work from this kit. The versioned distribution, project configuration and consumer CI below are proposed.

Bring a product task

Start with the person, the task and the facts the product owns. In the playbook, Meatball reviews a scoped decision and Sourdough inspects an authorized company record. Change a condition and see the wording, next step and acceptance case change with it.

Review a Meatball decision · Inspect Sourdough company work · Repository blueprint · Agent entry

What travels together

Publish yogurt from its own repository under one version. Meatball’s app, an OpenBoa website and an independent client would each consume that release directly. A project can use yogurt with any planning tool.

Identity and words
Ship the logo masters, project emoji, approved company copy, contextual English terms and examples for names, product actions and recovery. Keep the company symbol distinct from the named agents. Names and voice
Design and behavior
Ship one hue-and-lightness palette, type, dimensions and the expected states and interactions of each component or pattern. Web and native renderers would draw from that source. Motion guidance for agents belongs here as it is approved. Working roster
Authoring and checks
Include readable rule IDs, examples and a checker in the release. An editor, design tool or agent plugin can surface them while someone works. The same checker runs in project CI without a plugin or a running agent.

Bind a project once

For a mixed-target client, yogurt.config.json lives at the project root. Name the surfaces to check and where people keep the English copy and intents. Run yogurt check in the consumer to verify its declared surfaces, palette references and imports. These paths belong to the consumer. This illustrative project has both a website and a desktop app.

{
  "surfaces": {
    "site": { "target": "web", "root": "apps/site" },
    "desktop": { "target": "native", "root": "apps/desktop" }
  },
  "englishCopy": ["content/en"],
  "intents": ["docs/intents"]
}

Resolve the release once into a committed yogurt.lock with its version, artifact source and digest. Web package locks and native build inputs must match that release. A web-only project can use its existing package lock when it resolves that same design manifest for the build, guide and checks.

With or without Meatball

Meatball’s own app would have the same root binding as any other client. A project already using Meatball could expose its yogurt references to the intent editor through an optional integration. A project using Markdown and a build script could read the same references directly. Both build with the pinned yogurt files.

Reference it in an intent

Start with the person, the task and what success looks like. Refer to the few yogurt entries that affect that experience. The project pin resolves those references, so an intent can survive a release upgrade.

Find an agent again

Someone returning to the roster can find Kai by name or ID, then recover if their filters hide every match.

Shared references
roster.agent in English terms, voice in recovery and the roster pattern.
Product decision
The project defines which agents the person can see and when an agent counts as working.
Acceptance
Find ID 014, combine it with a status that hides Kai, then clear the filters. Both agents return and the search field receives keyboard focus.

For a Meatball workflow, its intent defines exactly when work is Stopping and when it is Stopped. Yogurt supplies how to present a readable status and how a control returns focus. The product’s own test proves the transition.

Build the client

Next.js and Vite
Publish a web entry for CSS, local font files and accessible controls. Both web clients can share React DOM implementations. Keep interactive entry points small so a static website can render on the server. Serve fonts and artwork with the app at its pinned version. Use the current CSS
Vercel Native SDK
OpenBoa uses this stack by default for app clients. Native stack and first fixture. At build time, translate the same token values into native theme values. Bundle the TTFs and implement the interaction contract with the SDK’s native views. Check the intended OS and SDK version before marking a component supported. Measure the packaged app on that OS. Native SDK component model
Embedded web content
A screen deliberately rendered in a WebView can use the web entry. Its host still owns native navigation, focus handoff and performance.

Keep the catalog, rule checker and authoring plugin in development. Package each client with only the runtime assets and controls it uses. The brand website can serve a readable guide for each released version.

What a release must prove

Run the same checks locally and in the consumer’s pull request. Required CI can enforce repeatable rules once the consumer has adopted them. Give a failure a rule, file or screen, and a repair someone can act on.

Build inputs
Verify the pinned release, digest, supported target and notices. Flag unknown token IDs, raw color values in first-party UI styles, copied or altered master artwork and undeclared fonts. Check assets before bundling or transforming them.
Words
Read localized strings and user-visible literals from declared web and native source roots. Check spellings against the vocabulary for that context. For example, credit the company as OpenBoa. Repository identifiers, code, URLs, quoted text and customer content have their own spelling. Flag a questionable joke for a writer to read in context.
Behavior and appearance
Exercise the default, empty and recovered states. Check accessible names, keyboard access, visible focus and foreground/background contrast. Review light and dark screenshots on each renderer. Compare images made on the same OS, renderer and font version.
Shipping performance
On the web, compare shipped JS and font bytes, layout shift and input responsiveness. On desktop, compare cold launch to first usable input, idle memory and p95 input-to-paint on the same machine and fixture. Set budgets from that product’s measured baseline.
Human judgment
Review the tone of a difficult message and the optical balance of a signature in the actual screen. Let the product owner verify that the UI tells the truth about the underlying state.

Adopt and upgrade

  1. Publish one compatible set. A release manifest would list the supported targets, artifacts with digests, notices, rule IDs and versioned guide. Include a changelog and replacements for renamed tokens, terms or components.
  2. Pilot one real task. Render the same small roster journey in a packaged Vercel Native app and the Next.js and Vite web hosts. Record results by target. Use a project-owned screen as a second test, such as a decision being closed in Meatball.
  3. Turn on checks per project. Report existing drift first. Verify clean and intentionally broken examples before making checks required for new or changed UI. An intent-writing plugin can explain a finding using the very same release.
  4. Upgrade through a reviewed change. Update the project lock, compare before and after on the affected screens, and serve the assets in the same build as the client. An incompatible target, unknown required reference or mismatched digest stops the candidate build. The last working release stays available for rollback.

Improve yogurt itself

A product designer who finds a recurring problem brings the screen, the task and a reproducible example to yogurt. For example, if a closed decision leaves keyboard focus behind, the product owns the decision’s meaning and yogurt can improve the shared focus behavior.

  1. Record the user need as a yogurt-owned intent. Preserve a before example from the affected product.
  2. Define the expected behavior and a counterexample, update the shared source and test it on the affected renderers.
  3. Review the change in the catalog, release it with an upgrade note, and confirm the result in the reporting product after it upgrades.

When Meatball’s target format settles, the yogurt repository can add its own .meatball/ project descriptor to manage that work. In the other direction, Meatball’s client can consume a published yogurt version alongside every other OpenBoa project. Either repository can build using its last compatible inputs.