Wigley Studios sells serious interface tooling—PromptUI for AI-assisted UI generation, the UI Kit Generator for full kit builds, and UI Kit Packs as production-ready Tailwind and React collections. Those products exist because teams routinely pay for speed, consistency, and outcomes they can ship. At the same time, a lot of daily engineering work does not need a checkout flow: you need a token sheet, a mock that matches your schema, or a curl that matches your OpenAPI file. That is why we run Developer Labs—three browser-based utilities that are genuinely free to use, backed by the same FastAPI stack as the rest of our API, with persistence for people who create an account.
This article is a straight walkthrough of what each lab does, how they fit together, and how they point toward the paid lineup when you are ready to go from “structured output” to “shipped product UI.” No hidden trial timers on the tools themselves; the model is simpler than that.
Free utilities next to paid software can sound contradictory if you assume every hour of engineering must map to a price tag. In practice, narrow, well-scoped tools earn trust: you can verify exports in your own repo, compare them against hand-written equivalents, and decide whether the paid products deserve a look. The labs also reduce repetitive work that would never justify a subscription on its own—nobody should invoice a client for “typed a third curl variant because the first two were wrong.” Automating that class of task keeps attention on product decisions.
What “Free” Means Here
The labs run in your browser and do not require payment. You can define tokens, parse specs, and generate mock payloads without subscribing to anything. Saving named projects to your account is optional but recommended if you do not want to lose work when you close the tab.
Brand Token Studio: Design Tokens Without the Spreadsheet Chaos
Most teams eventually centralize color, type, spacing, and elevation into design tokens. The hard part is rarely the concept; it is keeping a single source of truth that designers and developers can both edit without duplicating files. Brand Token Studio gives you a visual token editor in the browser: you adjust values, see the relationships, and export artifacts your codebase can consume.
/developer-labs/brand-token-studio/app/
Define tokens for colors, typography, spacing, and shadows. Export as CSS custom properties, JSON token files, or a Tailwind configuration snippet. The same session can hand off cleanly to the UI Kit Generator so you are not retyping palette steps when you want components generated from your system.
If you have lived through “designer PDF, developer guesses hex codes,” this is the opposite end of the spectrum: structured data, editable in one place, with exports that match how modern front ends actually load theme values. For teams already using our UI Kit Packs article as a buying guide, Brand Token Studio is the free companion that helps you normalize tokens before you commit to a pack or a generated kit.
Choosing between CSS variables, JSON tokens, and Tailwind config output is not cosmetic. CSS custom properties slot straight into runtime theming and design-system documentation sites. JSON aligns with design-tool pipelines and token transformers some teams already run in CI. Tailwind config fragments help when your components are utility-first and you want spacing and color scales co-located with the rest of your tailwind.config story. The studio keeps those paths parallel so you are not manually transcribing the same numbers three times.
API Contract Lab: OpenAPI In, Mock Responses and Snippets Out
Once an API contract exists as OpenAPI (or JSON in the shapes the lab accepts), the boring work multiplies: sample responses for QA, curl examples for docs, fetch snippets for the frontend, and Postman collections for manual testing. API Contract Lab ingests those specs and gives you outputs you can paste into real workflows instead of rewriting the same boilerplate by hand.
/developer-labs/api-contract-lab/app/
Parse OpenAPI and JSON API descriptions. Generate mock responses aligned to your schema so front-end work is not blocked on a staging deploy. Produce code snippets in common shapes: fetch, curl, Python, and React Query. Export a Postman Collection when you need a portable test bundle for the team.
The point is not to replace your integration tests or contract testing in CI. It is to shrink the gap between “we agreed on the shape” and “everyone has runnable examples.” When product and engineering share one artifact, arguments shift from formatting details to behavior—which is where the time should go.
Parallel frontend and backend tracks are normal when delivery dates do not wait for perfect sequencing. Mock responses that respect your declared schema let the UI team wire loading states, error handling, and pagination against believable payloads while the service is still in flux. Snippets in fetch, Python, or React Query reduce the copy-paste tax when you paste examples into tickets, internal wikis, or onboarding docs for new hires. Postman exports matter when QA or a partner team needs a repeatable click-through path without cloning your whole repository.
Mock Data Lab: Realistic Fixtures from Schema or Sample JSON
Seed data for demos, fixtures for Storybook, CSV for spreadsheets, or SQL INSERT statements for local databases—each format shows up in real projects. Mock Data Lab generates data that respects structure: point it at JSON Schema, TypeScript-style interfaces, or representative sample JSON, configure counts and field behavior, and export in the format your pipeline expects.
/developer-labs/mock-data-lab/app/
Produce believable values (not just random strings) with control over field types, volumes, and relationships between entities. Export JSON for apps and tests, CSV for analysis, or SQL inserts when you are bootstrapping a dev database from a schema.
This is especially useful when the UI is ahead of the backend or when you need repeatable datasets for screenshots and pitches. You still own validation rules in your application; the lab helps you manufacture consistent inputs so those rules have something realistic to run against.
Relationship-aware generation matters when entities reference each other: orders pointing at customers, comments at authors, nested collections with plausible cardinality. Configurable counts keep fixtures small enough for unit tests or large enough for performance sketches. CSV export is underrated for cross-team review—product and success teams can sort and filter in a spreadsheet without touching JSON viewers. SQL INSERT output is aimed at local and staging databases where you want a deterministic seed script checked into a /db folder rather than a one-off paste into phpMyAdmin.
How the Labs Connect to Each Other—and to Paid Products
Brand Token Studio, API Contract Lab, and Mock Data Lab are not three unrelated demos. They mirror a common pipeline: define how things look (tokens), define how services talk (contracts), and populate what flows through the system (data). In practice, a team might lock tokens in Brand Token Studio, point API Contract Lab at the service definitions for the same product surface, and use Mock Data Lab to generate payloads that match those shapes for UI review.
The paid products sit at the next layer of ambition. PromptUI turns natural language into UI output at tiered generation limits. The UI Kit Generator is for full kit generation when you want a cohesive component set rather than ad hoc screens. UI Kit Packs are curated, purchasable libraries when you want proven aesthetics out of the box. Brand Token Studio is explicitly designed to feed the UI Kit Generator: tokens you validate in the lab become the handoff input instead of a parallel manual brief.
Pricing context, without turning this post into a catalog: PromptUI spans roughly $19–$79 depending on tier; the UI Kit Generator ranges from one-time starter tiers through subscription and lifetime options up to $999 for lifetime full-kit access; UI Kit Packs run from about $14.99 per pack through $99.99 for the complete bundle. Those numbers matter because they frame what “free labs” are not replacing: they are not a secret upsell inside the token editor. They are the adjacent shelf when your scope grows from exports and fixtures to generated or purchased UI at scale.
One Stack, Two Speeds
Developer Labs run on the Wigley Studios FastAPI server via the developer_labs/ application module: the same service that powers licensing and customer-facing APIs also persists lab state when you save. Saved projects live in developer_lab_projects with version history in developer_lab_project_versions—the same persistence model whether you are iterating tokens or iterating mock payloads. That is ordinary product engineering, not a marketing gimmick: your work has a place to live if you choose to save it.
If you are comparing curated kits, the deep dive on packs—pricing tiers, bundle math, and which visual languages map to which products—is in UI Kit Packs: Eight Curated Design Systems Ready for Production. Read that when you are buying; read this when you are experimenting for free.
A concrete sequence some teams follow: establish palette and type in Brand Token Studio, export Tailwind-oriented config, generate or purchase components that consume those tokens, then use API Contract Lab and Mock Data Lab to keep story data aligned with the OpenAPI file the backend team maintains. The labs do not replace design critique or code review; they remove friction so those conversations happen on stable inputs.
Accounts, Saving, and What You Give Up Without Login
All three labs work without logging in. You can explore, export, and copy outputs in a session. If you close the browser or clear storage before saving to the server, ephemeral work disappears like any unsaved draft. Creating an account unlocks persistence: named projects, history via the versioning tables on the backend, and the ability to return days later without reconstructing token sets or schema wiring.
We are upfront about the tradeoff because it is the same tradeoff every serious online tool faces. Anonymous use keeps the barrier low for evaluation and one-off tasks. Accounts exist so repeat visitors are not punished for trusting the workflow. Nothing about the free tier is a bait-and-switch into a subscription for these three utilities; the paid lines remain PromptUI, UI Kit Generator, UI Kit Packs, and related Bravura offerings with their own pricing pages.
From an implementation standpoint, versioning means you can revisit an earlier token set or mock schema without digging through chat logs or email attachments. That matters when a stakeholder asks to compare “last week’s palette” to this week’s—you have a trail if you saved projects under your account. If you never create an account, treat the labs like a sharp calculator: excellent for the session, nothing persisted on our side.
If you are building a design system, prototyping against OpenAPI, or seeding data for a demo, bookmark the hub at /developer-labs/, open the lab you need, and keep the paid catalog in mind when you are ready to generate or buy full UI at scale. That progression is intentional: free tools for structured work, premium tools when the deliverable is the whole interface layer.