# 1DesignTool — full published content > 10 articles. Source: https://1designtool.com --- ## Walk through a real place in 3D, built from your photos Source: https://1designtool.com/blog/walk-through-a-real-place-in-3d Published: 2026-11-16 Tags: 3d world, walkthrough, floor plan, 3d library, character Turn photos, a floor plan or a link into a place you walk through in first person, then step in as your own character that can sit, wave and dance. You want to show someone a place before they get there. A café owner wants regulars to see the new seating before it opens. A gym wants a new member to know where the free weights are. A venue wants a band to see the stage from the back of the room. What you usually have is a handful of photos, a PDF floor plan, and maybe a listing link. Photos show corners, never the whole room, and a floor plan shows the whole room but not what it feels like to stand in it. A real walkthrough has meant a 3D artist, a game engine, or a camera rig and a paid hosting service. And when someone does build one, the first visitor walks into a wall and gets stuck, or falls through the floor by the stairs. ## What changed 1DesignTool 1.20.0 adds **3D World**, a new template on Home. Now you can turn photos, a floor plan or a link into a place you walk through in first person, then step out and walk it as your own character, without opening a game engine. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.20.0/walkable-cafe-world.jpg | A 3D World of a corner café, seen from inside the door, with the Espresso bar and Long table viewpoints below. Every one was built from a written description. ## How it works in practice ### Give it what you have Pick **3D World** on Home, attach what you've got and name the place: a shop, a café, a gym, a street, a venue. The agent works from whatever you give it, and is honest about what that was: - **A floor plan or drawing** sets the layout: positions, sizes, walls, doors and windows. Photos then decide the materials, colours, signs and fixtures. - **Photos only** means the layout is estimated. The agent sets the scale from things of known size, such as a 0.9 m door or 0.6 m floor tiles, and works out what stands where from several views. - **A link or a description** gets the typical layout for that kind of place, with every part marked as inferred. HEIC photos and PDF plans are converted when your machine has a converter, and anything it can't read is listed as a problem rather than dropped. If nothing you sent shows enough of a place to walk, like a logo, a close-up or a dead link, it doesn't invent a building. It tells you what to send instead, such as "two or three wide photos that show the walls". Signs, logos and floor patterns come from your photos. Text on a wall becomes a sign that stays crisp at any distance, and a logo is cut out of the sharpest frontal photo and straightened. ### Click the preview and walk The world fills in while the agent works: first the shell of rooms, walls and stairs, then the big fixtures like counters and racks, then everything else, then signs, lights and named viewpoints. When it's done, click the preview to explore. Move with WASD or the arrow keys, look with the mouse, hold Shift to run and press Space to jump. Viewpoint buttons and a map take you straight to a spot, like "Inside the door" or "Espresso bar". On a phone, the start card says **Tap to explore** and two touch sticks take over: your left thumb moves and your right thumb looks. ### Checks walk it before you do Before a world is called done, its checks play a visitor through the runtime's own physics. They walk to every room and platform from the starting point, run at every wall they can reach to make sure nothing passes through, and make hundreds of runs in every direction to confirm no one can leave the world. Then they render every viewpoint and fail any that comes out blank. They also try the keyboard, the mouse and a phone's touch stick, and check the camera never ends up inside a wall. So the person you send it to doesn't find the gap behind the counter where you fall out of the building. The checks found it first, and the agent fixed it. ### Step out and be in it Press **V** to see yourself in third person, with the camera pulling in when a wall would come between you and your figure. Press **C** to change your character's look: height, build, skin, hair, face, clothes and accessories. Your look is saved in your browser for that world, and **Copy for chat** hands it to the agent if you want it to be the default. Press **Q** for actions such as sit, wave or dance, and **E** to use what's in front of you, like sitting down on the bench you're standing at. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.20.0/third-person-character.jpg | A character sitting at the window bar in third person, with the third-person view at the door and the character customizer below. Then ask the agent for more. "Let me fly over the building" adds flight on F. "A pool on the terrace I can swim in" adds water you walk into and swim through. The world is one file the agent edits, so each request changes the place, not a copy of it. ### Take it with you Export a **PNG screenshot** of the view, or a **Project ZIP** of the whole world. The ZIP holds the page, the world and the 3D library it runs on, and makes no network requests, so it opens offline on any machine with a browser. ### Start from a free 3D library model 1.20 also connects the app to the free 3D library at [1designtool.com/3d](/3d). On a model page, set the options you want, then click **Open in 1DesignTool**. The app asks first, showing the model, how many files it will download and from where, and which of your website settings it keeps. Click **Open as new project** and the model becomes a 3D object project on your computer, ready for you to keep building with your agent. **Cancel** adds nothing. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.20.0/library-model-import.jpg | Open in 1DesignTool on the cargo bike's model page, and the app asking whether to open it as a new project, keeping the box length and frame colour set on the website. ## Before vs after | | Before 1.20 | With 1.20 | |---|---|---| | Showing someone a place | A folder of photos and a PDF plan | A world they walk through in first person | | Getting a walkthrough built | A 3D artist or a game engine | Attach photos, a plan or a link on Home | | Getting stuck in a wall | Found by the first visitor | Found by the checks, which run at every wall | | Seeing it on a phone | A separate viewer, or nothing | Touch sticks in the same world | | Being in the space | A floating camera | Your own character that sits, waves and dances | | Sharing it | Hosting and an account | A ZIP that runs offline | | A model from the 3D library | Download the files, start a project, copy them in | Open in 1DesignTool, then Open as new project | ## Who benefits most **People who run a physical place.** A café, a shop, a gym or a studio can show the space to people who haven't been yet, built from the photos already on the phone. **People planning a space that doesn't exist yet.** Give it the floor plan for a fit-out or a venue layout and walk the result before anything is built. The layout follows the plan, and everything the agent had to guess is marked as inferred. **Designers and makers who use the 3D library.** A model you've configured on the website is one click from a project you can keep changing, instead of a download you have to set up by hand. ## Try it Update to 1DesignTool 1.20.0, pick **3D World** on Home, and attach three photos of a room you know well. When it's done, click the preview, press V, and walk in as yourself. --- ## Design a printable part, then check it before you print Source: https://1designtool.com/blog/design-a-printable-part Published: 2026-10-05 Tags: cad, 3d printing, stl, step, 1videotool You no longer have to relearn a CAD program to make a bracket. Describe a part in millimetres, pull its dimensions around in a live 3D view, and run it through checks that say plainly what they did and did not verify. There is a particular kind of afternoon that anyone who owns a 3D printer knows. You need a bracket. Not an interesting bracket — a flat plate with two holes at a spacing you measured with calipers, and a lip so it does not slide. It should take ten minutes. Instead you open a CAD program you use four times a year, spend the first twenty minutes remembering how sketches and constraints work, and the next forty discovering that the hole you placed is driven by a dimension you set before you knew what it was for. Eventually you export an STL, slice it, print it, and find out the wall is too thin where it matters. The part was never hard. The software was. ## What changed 1DesignTool 1.14.0 adds a **CAD parts** workspace, in preview. Now you can describe a part in millimetres, watch it get modelled parametrically, pull its dimensions around in a live 3D view, and run it through a gate that tells you what it checked and — just as usefully — what it could not. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.14.0/cad-parts-template.jpg | The CAD parts template selected on Home, with a brief describing a 60 x 20 x 4 mm calibration strip and five through-holes from 3.0 to 3.4 mm ## How it works in practice ### Describe the part in millimetres CAD parts sits on Home in the **Games, movies, and other creative** row, next to 3D object, Character Design and Animation. Pick it and write the part the way you would describe it to someone at a workbench: *"Create a 60 × 20 × 4 mm calibration strip with five through-holes measuring 3.0, 3.1, 3.2, 3.3, and 3.4 mm in diameter, evenly spaced along its length."* The template works in millimetres throughout, and the result is parametric — a `model.js` that produces the solids, not a mesh someone sculpted. That is what makes the next step possible. ### Adjust the dimensions, then commit The workspace's side panel is headed **CAD parts** and carries five tabs: **Parameters**, **Parts**, **Printer**, **Examples** and **Code**. **Parameters** is where a part stops being a one-shot generation. Change a dimension and the model rebuilds in the viewer. When it is right, **Commit** saves a history entry you can come back to; **Cancel** restores the saved parameters. Until you commit, the export buttons stay disabled — you cannot accidentally ship an STL of a shape you were still fiddling with. The viewer is built for inspection rather than presentation: fixed **Front**, **Right**, **Top** and **Iso** views, a **Section Z** slider to cut through the solid, an **Explode** slider for assemblies, **Measure two points** for checking a dimension you care about, and **Reset view**. The **Parts** tab lists each named solid with its volume in mm³, and the hardware fits are listed separately so you can ghost one and see where the screw actually goes. ### Run the checks, and read what they did not check This is the part that makes it useful rather than merely quick. The stage carries an honest banner — *Unverified · run checks for this revision* — until you run the gate, and then the panel fills in per-check results. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.14.0/cad-checks.jpg | The CAD gate's per-check results beside the modelled calibration strip, with bed, overhang and range flagged, determinism and exports passing, and the revision held as incomplete The gate runs fifteen rules grouped into technical, requirements and delivery concerns. It checks that the code runs and the parameters resolve, that the result is a closed solid inside its declared bounding box, that sampled wall thickness holds up, that declared clearances and keepouts are respected, that the part fits the printer bed, that overhangs past 45° are flagged for supports, that a fresh independent build produces the same geometry, and that an independent reader agrees with what the exports contain. What matters as much is the vocabulary. A check can come back **not applicable** — `cad.port` and `cad.keepout` say "No required hardware geometry" on a part that declares none, rather than quietly passing. A check can come back **incomplete**: *"Applicable CAD evidence is missing; await measurements or review before completion."* The gate will hold a revision as unfinished rather than bless it, and **Open report** gives you the full evidence. And the hard limit is stated rather than hidden: these are geometry and export checks. **They are not a claim about physical fit or printability.** A part that passes every rule still needs printing and testing against the real hardware. That is the honest position for a tool that has never touched your printer, and the workspace says so instead of implying otherwise. ### Export for manufacturing, and open your slicer Each named part exports as **STL**, **STEP** or **3MF** from the Parts tab, and the whole assembly as **Export assembly STEP** — meshes for printing, STEP when something downstream needs real solid geometry. The **Printer** tab holds a printer profile saved with the project, and asks you to confirm the usable bed before the bed-fit check can pass. Once files are written, each `.stl` or `.3mf` gets **PrusaSlicer** and **OrcaSlicer** buttons, so the path from "the part is right" to "the slicer is open" is one click rather than a trip through Finder. ### Send a finished design to 1VideoTool Separately, a design can now leave for **1VideoTool**. A character still, a 2D puppet, a customized character GLB or a supported 3D scene can be sent as a portable asset. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.14.0/send-to-1videotool.jpg | The Send to 1VideoTool panel confirming an imported asset, with Retry opening and Save .1vasset available beside it On desktop, **Send to 1VideoTool** captures the current design, publishes the bundle, opens 1VideoTool and then *waits* — it reports "Waiting for 1VideoTool to confirm import…" and only says **"Imported into 1VideoTool Assets. Open the asset there to choose how to use it."** once the other app has actually taken it. If it does not, you get **Retry opening** and **Save .1vasset**, and the bundle is remembered per project so a retry later still works. In the browser demo the same bundle downloads for manual import. No silent half-transfers. ### One less trip for a finished design system Smaller, but it removes a detour: the completed-design panel now carries **Add Design System**, which puts the system straight into Systems, and a download action for its tokens and `DESIGN.md` package. Last release put that export in the share menu; now it is also where you land when a design finishes. ## Before vs after | | Before | Now | |---|---|---| | Making a small functional part | Relearn a CAD program for an afternoon | Describe it in millimetres and adjust parameters | | Changing a dimension | Hunt for the constraint that drives it | Edit the parameter, rebuild, commit | | Knowing if it will print | Slice it and find out | Bed, wall, overhang and clearance checks first | | What "passed" means | Whatever you assumed | Named rules, with the not-applicable and incomplete ones shown | | Getting to the slicer | Export, find the file, open the app | PrusaSlicer or OrcaSlicer from the exported file | | Moving a design to video | Export, locate, import by hand | Send, and wait for a confirmed import | ## Who benefits most **People who print functional parts, not models.** Brackets, spacers, mounts and clips are mostly dimensions and tolerances. That is exactly the part of CAD that a parametric description handles well. **Anyone who prints rarely enough to forget the software.** The cost of an occasional part is almost entirely relearning the tool. Describing it removes that cost without removing the control, because the parameters are still yours to pull. **People who already design characters and scenes here.** The 1VideoTool hand-off means a design that is finished in one app arrives in the other as an asset, with a confirmation rather than a hopeful file copy. ## Try it Pick **CAD parts** on Home and describe something you have actually needed — a calibration strip is a good first one, because you can measure the result. Adjust the parameters until the dimensions are right, run the checks, read what the gate says it did *not* verify, and then print it and find out. The tool will get you to a credible part quickly; the hardware still gets the final word, and this release is careful not to pretend otherwise. --- ## Export a design system from a design you already made Source: https://1designtool.com/blog/export-a-design-system Published: 2026-10-04 Tags: design system, design tokens, export, handoff, tokens.css You no longer have to re-describe a look you already landed. Export the palette, type, radii, depth and motion a finished design already is, then import that package and start the next brief inside it. You generate a design, and somewhere in the back-and-forth it stops being a draft. The greens settle. The headings find a size that reads. The cards get a radius and a shadow that look deliberate instead of default. You stop asking for changes because there is nothing left you want changed. Then the next brief starts, and all of that lives in a folder of HTML you are not going to read. So you describe it instead — "same palette as the last one, that muted green, generous spacing, soft shadows" — and you get back something adjacent but not the same. The spacing is tighter. The green moved. By the third project you are maintaining a look in prose, and prose cannot hold a hex value. ## What changed 1DesignTool 1.13.0 can write the design system down for you. Now you can export the system a finished design *already is* — its palette, type scale, radii, depth and motion — as an importable package, and start the next brief from that package instead of from a description of it. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.13.0/design-system-export.jpg | The Export menu, with Design system (tokens + DESIGN.md) sitting alongside the HTML, PNG, PDF, MP4 and Figma handoff exports ## How it works in practice ### Export it from the menu you already use Open the share menu above the preview — the same one that gives you **Self-contained HTML**, **PNG screenshot**, **PDF (print)**, **MP4 video (animation)** and **Project ZIP** — and you will find a new entry at the bottom of the list: **Design system (tokens + DESIGN.md)**. Click it and the activity card says *Extracting the design system from the generated design…*. The app serves your page the way the preview serves it, from the project root rather than as a bare file, so its stylesheets, fonts and images all resolve, and then measures what the browser actually renders. Not what the brief asked for — what came out. When it finishes, the result line names its own numbers: the system's title, how many tokens and colours it found, where the folder landed, and how many colours it had to repair for contrast. Then it opens the folder for you. ### What lands in the folder The package is meant to be read by you and by the next project, so it ships both: - `tokens.css` and `tokens.json` — the design tokens, generated from the measured direction. - `direction.json` — the direction itself. Run `tokens.mjs --direction direction.json` and both token files regenerate from it. - `DESIGN.md` — the written version. Link `tokens.css` first, then use only these variables for colour, type, space, radius and depth. It names the motion tokens (`--dur-fast`, `--dur-slow`, `--ease`) and notes that reduced-motion is already handled. - `components.html` — every token rendered on a page, so you can see the system instead of reading it. - `design-system.json`, a `thumbnail.png` of the page the measurements came from, and a `reports/` folder holding the raw measurement, the capture contract and the structure it observed. Nothing in there is a lossy summary. The reports are the numbers the tokens were built from, and the thumbnail is the exact frame they were read off. ### Import it in Systems and start from it Go to **Systems**, choose to import, and point the picker at the folder. The import reports what it took in — the card count, the token count and the direction it published the package as — and from then on that direction is available to the next brief. So the next project does not begin with you describing a green. It begins already in the system, and whatever you ask for arrives inside it. ### The measurement and the tokens come from one place Underneath, the exporter uses the same measurement and the same token builder that `extract-style.mjs` and `tokens.mjs` already use. That sounds like housekeeping, and it is, but it is the kind that shows: a package you extract and a token run you do by hand can no longer disagree about what the same page is. ### What it will not claim A rendered page shows colour, type, geometry and depth. It shows nothing about why. The package is written to respect that line rather than paper over it. It ships no component inventory, because variants, states and token bindings cannot be recovered from rendered output; `components.html` is explicit that it lists the structure it observed in the source, not a specified component set. The editorial parts of the direction are labelled as descriptions of measurements — the mood is three measured words, the signature is a measured hex and a measured pixel value — and `DESIGN.md`, the manifest notes and `design-system.json` all say so. Where a measured colour fails contrast, `tokens.css` ships the repaired value rather than the page's, and every repair is listed at the end of `DESIGN.md`. You are told what was changed and why, not handed a silently prettier palette. Two limits worth knowing before you reach for it. The export is a metered render, so it draws on the same budget as any other render. And it is refused on codebase projects: there, your design lives behind your own dev server, and Build mode's **Tokens** tab is the equivalent surface. ## Before vs after | | Before | Now | |---|---|---| | Carrying a look forward | Re-describe it in the next brief | Import the package and start inside it | | Where the palette lives | In a prose sentence and your memory | `tokens.css`, `tokens.json`, `direction.json` | | Handing it to a developer | Screenshots plus a conversation | A linkable stylesheet and a `DESIGN.md` | | Checking what the design really is | Read the generated HTML | `components.html` and `reports/dna.json` | | Contrast problems | Found later, by someone else | Repaired in the tokens and listed in the doc | ## Who benefits most **Anyone running a series rather than a one-off.** If project two, three and four should look like project one, this is the difference between a system and a resemblance. **People handing work to developers.** A stylesheet and a document that says "use only these variables" survives the handoff better than a PDF and good intentions. **Anyone who found the look by iterating.** The design you argued your way to is usually the one you cannot reconstruct from a prompt. This writes it down at the moment it is right. ## Also in 1.13.0 A brief dispatched over MCP now renders as markdown in the prompt bubble — headings, lists, fenced code and `#rrggbb` swatches, instead of one unbroken paragraph — and a long prompt clamps behind a *Show full prompt* toggle, with **Copy** still copying the markdown source. On the fixes side, the device stage got a real draggable scrollbar and stopped nesting a second scroller inside itself, and Home's composer footer and Talk cards no longer overflow when a linked repo has a long name. ## Try it Open a design you are happy with, take the share menu, and choose **Design system (tokens + DESIGN.md)**. You will get a folder you can read, a stylesheet you can link, and a direction the next brief can start from — which means the look you just spent an afternoon getting right is now something you own rather than something you have to find again. --- ## Design a Character Once, Then Pose and Animate It Source: https://1designtool.com/blog/design-a-character-then-rig-it Published: 2026-09-30 Tags: character design, 2d puppet, rigging, lip-sync, design agents You no longer have to regenerate a mascot until it looks close enough. Lock its face from one concept, build every sheet from those references, and rig it as a 2D puppet you can pose, lip-sync and export. You have a mascot you like. It came out of one good generation: a round panda with a bamboo stalk, the right eyes, the right blush on the cheeks. Then you ask for the same panda from the side, or laughing, or mid-word, and a different animal comes back. The eyes drift, the ears move, the proportions change. Every new pose is a new roll of the dice, and you spend the afternoon squinting at thumbnails trying to decide which one is "close enough". Getting it to move is worse. A talking mascot for an onboarding screen or a stream overlay usually means exporting layers, opening a separate rigging tool, rebuilding the character by hand, and hoping the file survives the trip back. Most people never get past the still image. ## What changed 1DesignTool 1.11.0 adds a workspace for **Character Design**. Now you can lock a character's identity from one concept image, build every sheet from that locked face, and rig the same character as a 2D puppet, without leaving the project or starting over in another tool. Pick the **Character Design** tile in the Creative group on the home screen and describe who you want. The project opens on a character page instead of a plain preview: the name, the style, whether the face is locked, and four tabs across the top. **Concept**, **Sheets**, **Sheet poster** and **Puppet**. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.11.0/character-workspace.jpg | Bolo the panda with the face locked. The Concept tab shows the approved reference, with Build the sheet below it and Export pack and Open rig editor in the header. ## How it works in practice ### Lock the face before anything else gets drawn The workspace starts from a concept. Once one exists, **Review and lock face** asks you to choose the canonical references: *Choose 1–12 images. After Lock, these refs stay immutable; change the face by forking.* That rule is the whole point. Every sheet the character gets later is generated from those pinned references, so the turnaround and the expression chart are drawn from the same face instead of a fresh guess each time. The page says where you are in plain words. Before the lock it reads *Review this character, then lock the face to generate the sheet.* After, it reads *This is the approved identity. Generate the sheet from these references.* A character that only has a generated reference so far opens on a large Concept view, so you are never staring at an empty grid of pending sheets wondering what went wrong. If you later want a different face, you don't overwrite the locked one. **Fork character** makes a new character that starts from the current state, and the original stays as it was. ### Build the sheets, and approve each batch before it runs **Build the sheet** plans the full set: turnaround, expressions, mouth chart, eye chart, story poses and alternate appearances. The Sheets tab counts them as you go (*Sheets · 0/17* on a fresh character). Nothing expensive runs without you. Each proposed job opens for review first: *Edit the title, output items and 1–3 candidates per item. The cost estimate updates before you start.* You can edit the job, drop it, or start it. When the candidates come back, **Choose candidates** shows them side by side, and **Use this candidate** saves the one you want into the character folder as a real file. **Reject with reason** records why the others missed, and that rejection is saved as a knowledge proposal for the project, so the next batch has a better idea of what you meant. Completed batches get their own consistency review, shown as model opinions with a prompt to confirm the identity yourself. The review is advice; the lock is still your decision. ### The character bible travels with the artwork The page keeps the character bible, style lock, delivery status and rights beside the pictures. Where each image came from is recorded with the asset, and the licence is a file you can read and edit. If you haven't set terms yet, the page says *Licence unknown* instead of assuming you can use the character commercially. Image generation goes through an image connection you choose: either a discovered tool on one of your MCP connections, or the Director runtime's own image tool. If none is connected, the agent says so and doesn't pretend otherwise. ### Rig it as a puppet from the concept you already have This is the part that used to need a second app. Open the **Puppet** tab and press **Open rig editor**. The Character rig editor starts from the character's concept image, so there is no layer export step to get through first. Or you can **Import PNG layers** if you already have named parts. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.11.0/character-rig-editor.jpg | The Character rig editor in Deform mode with a lattice over the panda's face, the part tree with eye and mouth layers, and the Parameters keyform grid below the canvas. The toolbar has two canvas modes. In **Pose**, you drag the character to turn and tilt its head and body. In **Deform**, you move lattice handles to reshape a part. **Split face parts** marks the eye and mouth regions and cuts them into their own layers, which is what gives you blinks and talking shapes. In the shot above that produced `eye-l-closed`, `eye-r-closed` and mouth shapes like `mouth-ah` and `mouth-ee` in the part tree. If a split came out wrong, **Re-split face parts** redoes it. The rest is what you would expect from a rigging tool, in one window: - **Add warp** and **Add pivot** wrap a layer in a deformer; **Move up** and **Move down** change the layer order. - The inspector sets each part's name, opacity, blend mode and clipping mask. - **Add parameter** creates a control, and the Parameters grid stores a keyform at each value so the slider interpolates between shapes you drew. - **Doctor** checks the rig and says *No rig issues found.* when it's clean. Edits support undo and redo, and you can save a rig checkpoint as a version to return to. Puppets built before this release offer an undoable rebuild with the new head and body deformers. ### Test it with your mouse and your voice **Test drive** plays the rig live. **Follow mouse** makes the head track your cursor, and **Mic lip-sync** drives the mouth from your microphone's volume, so you can hear whether the mouth shapes read before you export anything. ### Export something another app can open **Export puppet** writes a portable HTML puppet or runtime JSON, and only after the rig passes validation and the keyforms reload cleanly, so the file you hand off is one that actually loads. With FFmpeg installed locally, you can also record the puppet as a transparent WebM for video editors and overlays. **Export pack** in the character header bundles everything, including the rig and puppet files, into a single `.charpack`. Import it on another machine or into another project and the pinned identity comes with it. Agents you have granted access can read registered characters through read-only MCP tools, so a coding agent building your onboarding flow can reuse Bolo instead of inventing a second panda. This is the first version of the rig editor. PSD and Inochi2D import and export are not in it yet. ## Before vs After | Step | Before | With 1.11.0 | |---|---|---| | Keep the character consistent | Regenerate until one looks close enough | Lock 1–12 references once; every sheet is drawn from them | | Build turnaround and expression sheets | One prompt at a time, compared by eye | One planned job, 1–3 candidates per item, you pick each keeper | | Know if you can use it commercially | Remember where each image came from | Provenance and licence stored with the character | | Make it move | Export layers, rebuild the rig in another tool | Open rig editor from the concept, split face parts, pose | | Check the lip-sync | Export, import, play | Mic lip-sync live in the editor | | Hand it off | A folder of loose PNGs | A validated HTML or JSON puppet, a transparent WebM, or one `.charpack` | ## Who benefits most **Indie developers who need a mascot.** You get the stills for the store page and a puppet for the onboarding screen from the same locked character, and the pack means the next project starts from the same panda. **Streamers and video makers.** A mouse-follow, mic-driven character exported as a transparent WebM drops straight into an overlay or an edit. **Teams using agents to build product UI.** The character becomes something agents can look up and reuse through MCP, instead of a PNG someone has to find in a chat thread. ## Try it Update to 1DesignTool 1.11.0, choose **Character Design** on the home screen, and describe the character you have in mind. Lock the face once, and every sheet and every pose after that starts from the character you already chose, instead of hoping the next generation looks like it. --- ## Change Course Mid-Turn Without Throwing Away the Work Source: https://1designtool.com/blog/steer-a-running-turn Published: 2026-09-27 Tags: steer, composer, follow-ups, design agents, workflow You no longer have to wait out a turn you know is heading the wrong way. Steer checkpoints the running task and resumes it with your instruction, and queued follow-ups can now be edited in place or applied right away. You are forty seconds into a turn and you can already see it going sideways. The agent read the brief, picked a layout, and is now carefully building the hero you are about to ask it to change. You typed the correction the moment you saw it, but a follow-up only sends when the turn ends, so the correction just sits there while the agent keeps polishing the wrong thing. Your options used to be bad in both directions. Wait, and pay for minutes of work you already know you will throw away. Or press Stop, lose whatever the turn had finished, and start again with a longer prompt that re-explains everything plus the one thing you wanted to change. A long 3D scene or an animated explainer can run for several minutes, so "I'll just wait" often meant going to make coffee because of a single sentence. ## What changed Now you can redirect a turn while it is running, without stopping it and without losing what it has already done. While a turn runs, the composer offers two ways to send: **Continue**, which queues your message for when the turn ends, and **Steer**, which checkpoints the running task and resumes it with your instruction. Work the agent already finished is kept, and the new instruction applies to what's left. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.9.0/steer-3d-build.jpg | A 3D build still running: the composer offers Continue and Steer, and the activity card sits as a pill clear of the 3D inspector. ## How it works in practice ### Pick Continue or Steer before you send The two chips appear above the composer only while a turn is running. **Continue** is the default and behaves the way follow-ups always have: the box reads *Queue a follow-up — it sends when this turn ends…* and the send button says **Queue**. Switch to **Steer** and the composer changes to match. The placeholder becomes *Adjust the current task…*, the send button becomes **Steer**, and a line under the chips says what will happen: *Send an instruction to interrupt and resume the current task, or choose "Steer now" on a queued message.* Press Enter and the app pauses the job at a checkpoint, then resumes that same job with your note. The agent doesn't get a blank restart. The resume note gives it the original task and your new instruction together, and tells it to continue from the saved checkpoint, keep completed work, and apply the instruction to the remaining work. For a request like "keep the layout, but make the palette warmer", the files it already wrote stay where they are and only the unfinished work changes direction. Steer needs text. Attachments alone can go into a queued follow-up, but a steer has to say what should change, so the button stays disabled until you type something. Anything you have attached in the composer rides along with the steer. ### Fix a queued message instead of deleting and retyping it Queued follow-ups used to be frozen once you sent them. If you queued "make it relate to AGI?" and then thought of a better wording, the only fix was to remove it and queue a new one at the back of the line. Now you can click a queued message, or press its **Edit** button, to edit it in place. It opens as a text box with **Cancel edit** and **Save**. ⌘⏎ (Ctrl+Enter on Windows) saves and Esc cancels. While you edit, the message keeps its original spot in the queue, so a correction to the second message doesn't move it behind the fourth. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.9.0/edit-queued-message.jpg | A queued follow-up opened for editing mid-turn, with Cancel edit and Save above the Continue and Steer toggle. A message you are still editing can't be applied yet. If the turn ends while it's next in line and its editor is open, the queue waits for you to save or cancel instead of sending a half-finished version. ### Promote a queued message to "now" Sometimes you queue something because it seems like it can wait, and then the turn shows you it can't. Every queued message now has **Steer now** next to **Edit** and the remove button. It interrupts the current run and resumes it with that queued instruction, the same way Steer does from the composer. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.9.0/queued-steer-now.jpg | A queued message with Edit, Steer now and remove while a 3D rooftop scene is still being built. Two details make this safe to use without thinking about it: - **The message keeps its own attachments.** If you queued a message with a reference image and have since attached something else in the composer, **Steer now** sends the queued message's image, not the composer's. - **The rest of the queue stays in order.** Steering one message out of the middle of the queue doesn't reorder or drop the others. They still send, in order, when the turn ends. ### Nothing you type gets lost A steer is two steps, pause and resume, and either one can fail: the agent might not reach a checkpoint cleanly, or the resume might not start. Either way, your instruction stays in the queue instead of disappearing. If the pause never happened, the turn just keeps running and you can try **Steer now** again or let the message send when the turn ends. Only one steer runs per conversation at a time, so a second steer can't race the first while the checkpoint is still being written. ### Steer is not Pause The composer still has **Pause** and **Stop** beside the send button, and each does something different: - **Pause** checkpoints the job and frees its slot. Nothing resumes until you press **Resume**, and anything you type while paused becomes the resume note. - **Stop** cancels the turn. - **Steer** pauses and resumes in one move, with your instruction attached. Use Pause when you want to step away or give another conversation the slot. Use Steer when you already know what to change and want the agent to keep going. ## Before vs After | | Before | After | |---|---|---| | Spot a mistake mid-turn | Wait for the turn to end, or Stop and lose its progress | Switch to **Steer**, type the fix, press Enter | | What the agent keeps | Everything (if you wait) or nothing (if you stop) | Completed work stays, and the instruction applies to what's left | | Reword a queued follow-up | Remove it and queue a new one at the back | Click it, edit in place, ⌘⏎ to save, same spot in the queue | | A queued message becomes urgent | Wait, or Stop and paste it as a new turn | **Steer now** on that message | | A reference image on a queued message | Lost if you re-sent from the composer | Travels with the message, even on **Steer now** | | A steer fails partway | Not applicable | The instruction stays queued and the turn keeps running | ## Who benefits most **Long 3D and animation runs.** A scene build or a one-minute explainer can run for several minutes, and a wrong camera angle or a mistimed beat is usually visible early. Steering at that point saves most of the run. **People who think out loud in the queue.** If you tend to queue three or four follow-ups while watching a turn, you can now tidy them up as the design takes shape, and pull the one that matters to the front. **Anyone paying per token.** Every minute an agent spends on work you've already rejected costs money. Steering early means the turns you pay for end up closer to what you wanted. ## Try it Update to 1DesignTool 1.9.0, start a turn, and switch the composer to **Steer** the first time the preview heads somewhere you didn't mean. The same release also opens sent attachments in place, rebuilds design systems from your screenshots, PDFs, tokens and code, and adds motion presets and product-shot staging to the 3D scene editor. The full list is in the [v1.9.0 changelog](/changelog/v1.9.0). What you get is a turn you can correct while it runs, without starting it over. --- ## Design Inside Your Real Codebase, Without Touching Your Checkout Source: https://1designtool.com/blog/design-inside-your-codebase Published: 2026-09-24 Tags: codebase, build mode, git worktree, design agents, workflow Build and Sketch work on your real app, not a mock of it. Every edit is verified or rolled back, and by default it all lands on an isolated git branch, so your checkout and running dev server are never touched. A design agent is easy to trust with a blank folder. It is much harder to trust with the app you actually ship. You have a checkout with half-finished work in it, a dev server already running on the port your bookmarks point at, and a component tree that took months to get right. Asking an agent to "make the cards breathe a bit more" means handing it all of that and hoping the diff it leaves behind touches only what you asked about. So you don't ask. You find the component yourself, guess which of three padding utilities matters, save, reload, squint, and repeat, while the design tool in another window draws a mock your app will never quite match. ## What changed Codebase projects now have two more modes next to Preview: **Build** and **Sketch**. Now you can edit your real app's rendered UI and have every change checked against your code before it counts, and you can do it on a git branch of its own, so your checkout never sees it. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/build-mode-verified-edit.jpg | Build mode: a Card selected on the rendered page, its source at src/screens/Today.tsx:20, and a padding edit that passed all seven verification steps. Artifact projects keep Preview only. Build and Sketch are for folders that already contain an app. ## How it works in practice ### Click the thing you want to change In Build, the stage is the picture your own renderer drew, not a re-creation of it. Hover outlines elements, click selects one, and the breadcrumb above the stage walks to parents and children. The selection shows its padding and gap guides, and holding Alt while you hover a second element draws redlines between the two. The property panel names the component and the exact `file:line` it comes from. From there you edit the things a designer actually adjusts: padding, gap, direction, alignment, background, radius, opacity, font size and weight, text color and the text itself. ### Every edit is verified or rolled back An edit is not a write to disk and a hope. When you commit a value, it becomes a typed intent and runs through a fixed loop: apply, parse, compile, reload, re-inspect, intent check, blast radius, lint. The Verification card shows each step as it runs, with timings. *Intent check* confirms the element now reports the value you asked for. *Blast radius* confirms nothing outside it moved. A pass joins the undo/redo history, and you can open its diff from the History tab. A failure rolls itself back and shows the reason first, before anything else on the panel, so a gap of 999 that fails its intent check never lingers in your source. The Lint tab groups findings by rule. Clicking a finding selects the element it's about, and *Fix* applies the fix through the same verification loop. ### Always know what you're looking at A badge on the stage says where the pixels came from: *Live* is your project's own dev server, *Snapshot* a toolchain render, *Approximate* no real renderer. It is never hidden, so an approximation never passes for the real app. ### Hand structural changes to the agent The property panel can't wrap two cards in a responsive row or insert a new section. For those, the panel's *Needs native code / LLM* box sends the request to the project's agent as a normal turn. The agent gets only that element's source range and has to answer through `apply_and_verify`, so its change passes the same checks as one you made by hand. ### Sketch a screen, then compile it into your stack Sketch is a canvas for drawing screens in the layout subset: stacks, overlay, scroll, fixed/fill/hug sizing, padding, gap, alignment, token-only visuals and text styles, images, icons and mapped components. Sketches are saved as `design/*.1d` files in your repo, so one gets reviewed in a pull request like any other change. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/sketch-seeded-from-build.jpg | Sketch seeded from the Build screen: the real screen's structure as layers, labelled Approximate, with the Compile to… panel ready to preview code. *Seed from Build* starts a sketch from the current screen's real structure, so you rearrange what exists instead of redrawing it. *Compile to…* previews the generated code for the stack, file and target you pick, and *Apply & verify* sends it through the same loop as a Build edit. The flow runs one way: sketch → intents → code. Nothing converts your code back into a sketch. ### Your stack, including native Build speaks React, Next.js, Vue and Svelte web apps (Tailwind, CSS modules or inline styles), plus React Native, SwiftUI, Flutter and GPUI. A folder with a `Package.swift`, an `.xcodeproj`, a `pubspec.yaml` or a GPUI `Cargo.toml` is offered *Design inside this codebase* just like a JS repo. With no dev server, its result panel opens on Build. A folder that isn't a git repo is asked to `git init` first, because every edit has to be reversible. ## Your checkout stays untouched The second half of this release answers "what if it goes wrong" before you have to ask it. When you adopt a repo, the sheet now offers *Edit on an isolated branch (git worktree)*, checked by default. It creates a `1design/` branch at your checkout's HEAD and does all its work in a worktree the app owns. Your folder, your uncommitted work and your running dev server are never touched. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/adopt-isolated-branch.jpg | The adopt sheet with "Edit on an isolated branch" checked, node_modules and .env ticked to link in, and a warning that the repo already has other worktrees. A fresh worktree has none of your ignored files, so the sheet lists your checkout's ignored and untracked paths with their sizes. `node_modules`, `Pods`, `.env` and similar paths are ticked and symlinked in by default and never committed. Build output is never offered. One thing to know: a linked folder is shared, so a package install inside the worktree writes into the linked folder in your checkout. For JS repos, the preview runs on a dev server started inside the worktree, while yours keeps serving your checkout. ### Every turn is a commit you can read A turn that changed files commits as `1design: `. Each verified Build edit, undo and redo commits as `1design(build): …`. The author is your own git identity, and no commit carries assistant attribution. *Restore this turn* reverts that turn's commit, so the turns after it survive. A branch bar under the result panel tracks all of it: the branch and its base, ahead/behind counts and files changed. It also carries *Review changes*, *Copy merge command* (plus a `gh pr create` line when the repo has a remote), *Open worktree folder*, *Merge into * and *Discard branch*. Merge only runs from a clean checkout on the base and aborts on a conflict. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/branch-review-changes.jpg | Review changes on the isolated branch: one "1design: Make the header sticky" commit, the two files it touched, and the diff against main. The adopt sheet and the branch bar also flag the awkward cases: a repo that already has worktrees, a worktree folder gone missing (Recreate or Prune), a branch checked out elsewhere, a base that moved ahead. If you'd rather edit your checkout directly, that mode is unchanged. The default is a toggle in the Codebase section of Settings, and a direct project's branch bar offers *Move to an isolated branch* whenever you change your mind. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/codebase-worktree-setting.jpg | Settings with the new Codebase section: the "Edit codebases on an isolated branch (git worktree)" default, switched on. ## Before vs after | | Before v1.6.0 | Now | |---|---|---| | Changing a card's padding | Find the file, guess the utility, save, reload | Click the card, type 24, watch it verify | | A change that breaks the build | Discovered on the next reload | Rolled back, with the reason shown first | | Knowing where a component lives | Search the repo | `file:line` in the property panel | | Drafting a new screen | A mock that never matches the code | A sketch that compiles into your stack | | Where the agent's edits land | Your working checkout | A `1design/` branch in its own worktree | | Reviewing what changed | `git diff` across a messy tree | One commit per turn, reviewed in the app | ## Who benefits most **Front-end developers with a running app.** You get design-tool directness on the real component tree, and every change still has to compile, reload and lint clean. **iOS, Flutter and GPUI developers.** Native repos adopt the same way, and Build opens even when there's no dev server to run. **Teams that review everything.** Sketches are files, edits are commits under your own name, and the whole session is one branch you can open as a pull request. ## Also in 1.6.0 The design-system chip now groups by what you're making: None, then starter directions under plain names (SaaS, Landing page, Internal tool, iOS app, Colorful), then your own systems, then the rest of the kit. Hovering a row paints a miniature screen in its palette and heading font, so you can judge it without a build. The default is now None, which lets the agent pick a direction from your brief, and your last pick is remembered. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.6.0/design-system-picker.jpg | The design-system picker grouped by purpose, with a miniature Colorful preview beside the list. Four new kit directions (SaaS, Landing page, Internal tool and Colorful) bring the catalog to 17. External MCP calls can name their agent, either with `runtime` and `model` arguments or inside the brief itself (`@codex/gpt-5`). ## Try it Open a folder that already holds your app, choose *Design inside this codebase*, leave the isolated branch checked, and switch the result panel to Build. Click the first thing that has bothered you for a week and change it. Your checkout won't notice. You'll have a commit on its own branch that you can review, keep or throw away. --- ## 3D without a 3D tool: clay, wireframe, and an export button Source: https://1designtool.com/blog/3d-without-a-3d-tool Published: 2026-09-23 Tags: 3D, three.js, interactive web, showcase The 3D templates do not stop at a render. They stop at a scene with a parts tree, five ways of looking at it, comments you can pin to a mesh, and GLB, OBJ and PNG on the way out. Most "AI 3D" ends at a picture of a 3D thing. You get a render, and if the render is wrong — the hull too shallow, the rim too thick, the camera looking at the back of the object — your only move is to type the prompt again and hope. 1DesignTool's 3D templates end somewhere else: at a scene, in a browser, in a folder, with an inspector attached to it and an export button that produces GLB, OBJ and PNG. :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/3d-website.jpg | A run of the Interactive website template. Editorial layout on the left, a real three.js scene on the right, one signature interaction. ## Two templates, two different jobs **3D object** is for the thing itself: a vase, a watch, a desk robot. Output is a scene plus the meshes, and the checks care about the object — is it in frame, is the silhouette readable, does the camera look at it from somewhere a product photographer would stand. **Interactive website** is for a page that happens to contain a scene. That is a harder brief, because the scene has to survive a headline next to it at desktop width and stacked under it at phone width, and it has to do exactly one interesting thing rather than spin forever. The shot above is the second kind. A two-person kayak workshop, editorial serif, and a clay-material hull on the workshop floor with one signature move: *strip the hull* — peel the layers back to show the cedar-strip construction, with a button, a keyboard shortcut and a close that restores the camera. No orbit controls on a landing page; a visitor who can rotate your hero will leave it upside down. Here it is running. Drag sideways, or press **S**: :::demo kayak-hull ## The inspector is where it stops being a picture Open a 3D result and there is a panel down the right side of the preview. It is not a viewer. It is the difference between looking at the output and being able to say something specific about it. :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/scene-inspector.jpg | The 3D inspector, open on a scene the agent is still building. Views, the parts tree, the selected part, and the export row. - **Views — Beauty · Clay · Silh · Wire · Explode.** Five ways of looking at the same scene. Clay kills the materials so you can judge the form; Silhouette flattens it to a shape, which is the honest test of whether an object reads; Wire shows the mesh; Explode separates the parts. Designers have looked at objects this way for decades. It works on generated geometry for exactly the same reason. - **Camera presets — hero · front · side · top · fit.** The same five angles every time, so two runs can actually be compared. - **Parts.** A real tree, not a blob: `displayrig` with `cube` and `pedestal` under it. Select one and you get its stable ID, its dimensions (`2 × 2 × 2`), a Focus button, and the local coordinates of the point you clicked. - **Pin comment.** Leave a note *on a part* and it goes back to the agent as the next turn's brief. "This bevel is too soft" attached to `displayrig.cube` is a correctable instruction. The same sentence typed into a chat box is a guess. - **Export — GLB · PNG · OBJ.** The scene goes into Blender, into a game engine, into a slide. There is also an honest limit visible in that screenshot, which is the part worth reading twice. The Parameters section says: > No `` document is declared — nothing here can be previewed or committed. Add a `scene.design.json` to make this scene editable. The inspector will open *any* scene — look at it, take it apart, export it. But editing its parameters and committing the change back to the files requires the run to have written a `scene.design.json`: the document that records which dimensions, materials and views are deliberate, and which controls you are allowed to touch. If a scene does not declare one, the panel says so instead of offering you a slider that silently does nothing. ## What the same template does with a quieter brief Not every 3D job is a hero. This one was four sentences — a stoneware vase, roughly 24 cm, narrow neck, visible interior from slightly above, cream glaze, product-shot camera: :::demo lathed-vase And this is the other end of the range: a scene with several hundred moving parts, a text input, and a night sky that has to stay deep blue instead of washing out to grey under bloom. :::demo tet-lantern-night Each of those is a folder on disk with an `index.html` you can open without this app installed, or any app at all. ## Where it still asks something of you Generated geometry is primitives, lathes, extrusions and instancing — built out of shapes, not sculpted. That covers product configurators, diagrams, hero objects and scenes of many small repeated things very well. It does not make you a character model, and a brief that needs one will come back looking like the brief it actually was. Getting a scene you like is still a couple of turns. The difference is what a turn costs: you select the part, you pin the note, you run again with the camera fixed and the rest untouched — because the rest is in files, and the files did not move. --- The rest of the loop — brief, agents, preview, snapshots — is in [Inside a run](/blog/inside-a-run-brief-to-folder), and the checks each of these had to pass are in [the gate](/blog/the-gate-that-can-say-no). --- ## Watch Four Options Build Without Leaving the Design Source: https://1designtool.com/blog/variants-on-the-stage Published: 2026-09-23 Tags: variants, design agents, comparison, token usage, workflow Options no longer live on a screen of their own. A strip under the result panel switches between Main and each option, a building one is watchable live, and every turn now reports the tokens, cost and time it actually spent. Asking for four options used to mean leaving the room. You sent the brief, the app moved you to a Variants screen, and the design you had been staring at — the one you were comparing everything against — was no longer on screen. Four cards sat there instead, filling in at their own pace, and the only way to know what any of them actually looked like was to open one and lose the others. By the time all four finished you had lost the thread. Which one was the risky read? Which builder was still running? You picked from thumbnails, went back to the project, and found out what you had chosen afterwards. ## What changed Options now build on the stage you were already looking at. A strip under the result panel switches between `Main` and each option, and an option that is still building is watchable live — the preview serves its workspace and reloads as the builder writes to it. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.5.0/variant-strip-on-stage.jpg | The variant strip sits under the result panel, next to the per-design usage line. ## How it works in practice ### Watch an option build where the design already is Pick a letter and the stage shows that option. While it is still building, its workspace is served from a `/_lane//` route, so the preview reloads as files land rather than waiting for the run to finish. `Main` is always one key away — `0` for Main, `1`–`4` for the options, `[` and `]` to step along the strip. A lane footer under the strip carries the parts you previously had to guess at: each option's status, its risk read, which builder model is running it, what it has spent and how long it has been going. Every option gets its own *Stop*, *Retry*, *Promote* and *Refine*, and the whole set gets a *Discard*. ### See all four at once, at real size *All options* renders every option simultaneously, scaled down from the real page rather than from a thumbnail, with scroll synced across them. Scrolling one scrolls all of them, which is the only way a four-way comparison of a long page is honest — you are always looking at the same band of the design in each. ### Judge blind, then look openly Compare still opens the blind Left/Right judge, and nothing about that changed: two options, no names, you pick. What is new is what happens *after* the decision. An open side-by-side view lets you put any two options — or an option against Main — next to each other, swap sides, drag a wipe slider between them, and flip to phone width. Nothing in that open view is judged or recorded. It exists so you can go and understand a choice you already made, without the act of looking contaminating the comparison. Options also stay letters everywhere until you decide. No option carries a name that could tilt the pick. ### Decide, and the stage goes back to normal *Promote* makes the option the project. The strip returns to `Main`, the star stays on the letter you picked so the record of the choice survives, and a snapshot keeps the previous state undoable. The Versions drawer lists past decisions as read-only records. The standalone Variants screen and its top-bar button are gone. Old links still work — they open the project with the grid showing. ### Ask for options on any turn, not just the first The project composer's `+` menu now offers 2–4 options for a follow-up. Each option starts from your current design and changes only what its brief names, so a variant on turn six is a variation on what you have, not a fresh start that throws away five turns of work. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.5.0/home-composer-chips.jpg | The composer's chips — runtime, design system, linked code and the variant count — above the template grid. Both the Home chip and the composer state the run count before you commit ("≈ 5–8 runs"), and the Home chip seeds its count from your last pick for that template. Settings gains a Variants section for the default count, how many builders run in parallel, and which model the lanes use — a cheaper builder applies to every lane, and each lane shows which model actually ran it. On the free plan the variant budget is checked before anything starts, so you get the upgrade dialog up front instead of watching lanes fail one at a time. ## Every turn says what it used The other half of this release is that a run stops being opaque about its cost. A per-turn line reads `318k tokens (241k cached) · $0.62 API-eq · 1m 52s`, ticking while the turn runs, and opens into a breakdown by role — builder, plan, lane, critic, repair — and by model. The top bar carries the open design's running total, and each variant lane and each set carries its own. The wording is deliberately careful about where a number came from. `API-eq` is the figure the CLI itself reported; on a subscription that counts against your plan, not your card. `~$0.41 (your rate)` is an estimate from a rate *you* entered in Settings → Usage. No price table ships in the app, so nothing invents a dollar figure on your behalf. Some CLIs report nothing. Amp, Devin, Cline, Hermes and Kiro don't, and the footer says so — "usage: not reported by " — rather than showing a blank and letting you assume it was free. The parsers that do report now read prompt-cache and reasoning tokens across Claude Code, Codex, Cursor, Grok, OpenCode, Qwen, Kimi and Antigravity. Spend lands in a project-local ledger at `.1design/usage.jsonl`, one row per run with its role. It survives app-data resets and travels with the project folder. ## Before vs after | | Before v1.5.0 | Now | |---|---|---| | Where options live | A separate Variants screen | A strip under the result panel | | Watching one build | Wait for the card to finish | Live preview, reloads as files land | | Comparing four | Open one, lose the others | *All options*, real scale, synced scroll | | After the blind judge | The decision was the end of it | Open side-by-side, wipe, phone width | | Knowing what a run cost | Nothing said | Per-turn tokens, cost and time, by role and model | | A CLI that reports nothing | Looked the same as free | Says "usage: not reported" | ## Also in 1.5.0 The design kit picked up an actual imagery pipeline. It now ships the primitives its craft rules always assumed — a ~60-symbol pictogram sprite, a vendored Lucide set that is searched rather than guessed at, and deterministic bar, line, stacked, dot and slope charts as inline SVG with real text and an enforced zero baseline. Generation and fetching are brokered: images come through your own MCP connection, or from exactly three free-licensed sources, and every raster has to answer to the gate for provenance, license and palette distance before it ships. The Systems screen became a real management surface too — a filterable list with palette tiles beside a detail pane showing swatches, fonts, the `DESIGN.md` brief and files, with apply, duplicate and trash. Claude Design exports import straight in as packages. :::shot https://assets.stoicsoft.com/posts/1designtool/v1.5.0/systems-screen-import.jpg | The Systems screen: design systems and directions on the left, the imported package on the right. And two honesty fixes worth naming. An agent claiming "the gate passes" over a gate that failed — or was never called — now gets contradicted in the conversation by the host. And a run dispatched externally no longer wears the wrong agent's name: the resolved runtime and model are stamped on the project before the turn dispatches. ## Try it Open a project, type a brief, and set the composer's `+` menu to three options. Then stay where you are and watch them build. You will know which one you want before any of them finish. --- ## The gate: a design tool that is allowed to tell you no Source: https://1designtool.com/blog/the-gate-that-can-say-no Published: 2026-09-23 Tags: design systems, design kit, quality, accessibility Thirteen visual directions, five checks with numbers in them, and a learning store that changes nothing until a person accepts it. Why the part of 1DesignTool that can fail your run is the part worth paying for. Every tool that puts a model behind a prompt box has the same failure mode. You ask for a settings screen, you get something that looks like a settings screen, and you only find out it is wrong when you try to use it: the secondary text is grey-on-grey, the third card overflows at phone width, the type scale has eleven sizes in it because the model invented one per section. The result *looked* finished. Nothing in the tool had an opinion about whether it was. 1DesignTool has a component whose entire job is to have that opinion, and to be allowed to lose you the run. It is called the design kit, and the part that matters is the gate. :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/ui-mockups.jpg | Three states of one settings screen, produced in a single run. The alignment between them is not luck — it is the same tokens and the same checks applied three times. ## First, a direction — not a guess Before the agent writes anything, a run picks a **visual direction**: thirteen ship with the app, and each one is a small design system rather than a mood. Generated tokens. A signature move the design is built around. Rules with numbers in them — this many type sizes, this spacing scale, this contrast floor. This is the difference between "make it look modern" and a brief an agent can actually satisfy. The agent designs *inside* a system it was handed, instead of improvising one per section and leaving you to notice the seams. ## Then the gate runs, and it can fail When the agent says it is done, the kit checks the claim. Five lines, and they either pass or the run is not finished: ``` $ design-kit gate index.html --type slides plan design-plan.md found · 7 decisions PASS lint 0 hard-coded colors · 0 off-scale sizes PASS audit 1440×900 + 390×844 · no overflow, ≥ 12px PASS contrast 9/9 text pairs ≥ 4.5:1 PASS contact 8 frames · first frame non-blank PASS ``` Read what those actually assert: - **plan** — there is a written design plan with decisions in it, not a pile of markup that happened. - **lint** — no colour was typed in by hand; no size was invented outside the scale. The tokens are the only vocabulary. - **audit** — the thing was screenshotted at a desktop size *and* a phone size, and at neither does content overflow or drop below 12px. - **contrast** — every text-on-background pair was measured. Nine pairs, nine passes, against 4.5:1. - **contact** — a contact sheet of every frame exists and the first one is not blank. The most common way a generated deck is broken is that slide one never rendered. A failure is not a message in a chat. It goes back to the agent as the next turn's work, with the specific frame and the specific number that missed. ## Failures become lessons, and you approve them The Knowledge screen is where the kit's memory lives, and it is deliberately not automatic. It holds proposed cards — lessons distilled from recurring gate failures, house styles extracted from examples you dropped in, patterns picked up from which variant you chose when the app offered four. Every one of them sits in a queue until a person accepts or rejects it. Nothing changes how future runs behave until you say so. A tool that silently learns from you is a tool that eventually surprises you. On larger jobs there is a heavier option: a council. Visual, UX, copy and rights reviewers each pass over the evidence independently, findings merge, repairs run, and the verdict has to be earned again. ## What it looks like when the gate is doing its job Here is a checkout flow — cart, shipping, payment, confirmation — from a one-line brief. Lo-fi on purpose, annotated, every state drawn: :::demo checkout-wireframe :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/wireframe.jpg | The same wireframe run in the result pane. Numbered annotations, a step indicator that is correct on every frame, and a legend along the bottom. The gate is what keeps the third frame as careful as the first. Generated work degrades along a run — the model gets further from its own plan, and the last screen is where that shows. Checks that run over *every* frame are the cheapest way to catch it. And here is a finished-fidelity version of the same idea — a plant-care app in three screens, device frames, real content, one prompt: :::demo frond-app ## The trade you are making A gate that can fail costs you time. Runs take another turn. Sometimes the agent goes around twice on a contrast pair that a human would have shrugged at. What you get back is the ability to *not look*. If the gate passed, the type scale is the type scale, the colours came from the tokens, nothing overflows at 390px, and no frame is blank. That is a boring list, and it is exactly the list you would otherwise be checking by hand, at the end of the day, on work you did not make. The design tool being allowed to say no is the reason you can stop auditing it. --- The run itself — brief, agents, preview, files — is covered in [Inside a run](/blog/inside-a-run-brief-to-folder). All of it happens on your own machine, against the coding agents you already have. --- ## Inside a run: one sentence in, a folder you own out Source: https://1designtool.com/blog/inside-a-run-brief-to-folder Published: 2026-09-23 Tags: design agents, workflow, local-first, templates A walkthrough of a single 1DesignTool run — the four decisions in the prompt box, the two panes you watch it in, and the files it leaves on your disk when it is done. The app opens on a question and a text box. Not a canvas, not a template gallery pretending to be a canvas — a question: **What are we making?** Under it, one line of small print that is really the whole product: *describe it, an agent on this machine designs it, files land in a folder you own.* :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/home.jpg | The home screen. One prompt box, sixteen templates underneath it, and the agents that are ready to work listed in the corner. This post follows a single run from that box to the folder it leaves behind. ## The brief is four small decisions Most of the prompt box is a text field, and most of the time that is all you touch. The row underneath is where a run gets its shape: - **Which agent.** 1DesignTool does not ship a model. It drives the coding CLIs you already have installed and pay for — Claude Code, Codex, Cursor Agent, Grok Build, OpenCode, Antigravity, Qwen Code, Kimi Code, Amp, Devin, Cline, Hermes Agent, Pi, Oh My Pi, Kiro CLI, Aider. The corner of the window keeps a count of how many answered when the app looked: *10 agents ready*. - **Which effort.** A named preset per agent — the run in the screenshot above is set to `night-console`. Cheap and fast for a wireframe, slow and careful for a brand kit. - **How many variants.** One by default. Ask for four and you get four folders to choose between, which is also how the app learns what you like. - **What else it can see.** *Link code* points the agent at a repository so the design matches the thing being built. Files and screenshots can be dropped straight in. Then there is **Start in background**, which is the option that changes how you work. A run is a subprocess with a folder, not a chat you have to sit in front of. Start three, go read something. Below the box sit sixteen templates — Blank, Mobile app, Slides, Document, Wireframe, Animation, UI mockups, Résumé, 3D object, Interactive website, Research, HTML email, Brand, Design system, Infographic, Social media. A template is not a starting file. It is starter files *plus* agent instructions, its own viewer, and the checks that make sense for that format. Picking "Document" and picking "3D object" put the agent in two different jobs, with two different definitions of done. ## You watch it work, because a black box cannot be corrected The run opens into two panes: the conversation on the left, the result on the right. :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/conversation.jpg | A run in progress. The brief starts the first turn on the left; the result stays live on the right, at 100%, in the Result tab. The left pane is not a transcript of the model thinking out loud. Tool calls become readable activity — copying the starter, writing `index.html`, reading a log, taking a screenshot at 1440×900 — and each file the agent writes lands as a card you can open. The right pane is the actual output, reloading as files change. The toolbar above it is the part that earns its place: - **Result · Code · Split** — the rendered thing, the source, or both. - **Full · Tablet · Phone** — the same output at the three widths its checks will be run at. - **50% · 100% · 150%** — zoom, for when the thing is a poster and your screen is not. There is a comment tool up there too. You can point at a part of the result and leave a note on it, and the note goes back to the agent as the next turn's brief. That is the loop this app is actually about: not *prompt, pray, regenerate*, but *look, point, refine*. ## What comes out is files The run in these screenshots was a document — a two-page engineering RFC for adding offline sync to a notes app, produced by Devin from a one-sentence brief. :::shot https://assets.stoicsoft.com/1designtool/blog/2026-09/document.jpg | The finished document at 100%, in the result pane. Status block, numbered sections, goals against non-goals. Here is that exact output, live. It is `index.html` and its stylesheet, nothing else — open the prompt panel under it to see the sentence that produced it: :::demo rfc-offline-sync Note what is *not* in the picture: no export step, no "download your design", no account. The result pane is rendering a file that already exists on your disk, in a folder you chose, in formats other software can open. A document is HTML and prints to PDF. A 3D object is GLB and OBJ. A wireframe is SVG. An HTML email is inlined tables that survive Outlook. When a turn ends, the app snapshots the folder. Take the next turn in a direction you end up disliking and you can roll back to the version you had, because "the version you had" is a real thing on a real filesystem and not a row in someone else's database. ## The part that decides whether it shipped One thing has been left out of this walkthrough, and it is the thing that makes the difference between a design tool and a wrapper: before a result reaches that preview pane, it has to pass the design kit's gate. Screenshots at real sizes, contrast pairs, overflow, off-scale sizes, hard-coded colours. Fail and the run gets the failures back and tries again; the failures also accumulate as lessons. That is its own post — [the gate](/blog/the-gate-that-can-say-no) — because a tool that is allowed to tell you no is a strange thing to sell, and worth explaining properly. ## Try it against something real The free tier is a real tier, not a countdown: 300 prompts, 50 watermarked renders, three live versions per project, four variants, three design systems. Pro is a one-time purchase — $29, $59 or $89 for one, three or five machines, with twelve months of updates — and the files you already made stay yours either way, because they were never anywhere else. The honest test is not "make me a landing page". It is to take the next real piece of work on your list — the RFC nobody wants to format, the settings screen that needs three states drawn, the wireframe for a checkout flow — and give it a folder.