Builderii

View saved version →

---
name: app-screens
description: Design app or website screens in Builderii as a clickable prototype, such as onboarding, a checkout, a dashboard or every screen of an app idea, from a description, this conversation or a screenshot. Use when the user asks for screens, wireframes, a mock-up, a UI, a prototype or an app design in Builderii.
---

# Design app screens in Builderii

1. **Which board.** Use the board the user named (`search` / `list_boards`); otherwise `create_board` with kind `prototype` and a specific name.
2. **From a screenshot or sketch?** Call `generate` with `type: "app_screens"`, the `image_url` and a short prompt. Otherwise plan the screens yourself.
3. **Plan the flow.** 3 to 8 screens for an app (1 to 3 for a website), each with a short id (`home`, `detail`) and a name. Every screen reachable; each has one clear primary action.
4. **Draw them** with `create_app_screens`: `platform` (`mobile` unless it's a website: `web`), and each screen's components top to bottom with real content (names, prices, dates, no lorem ipsum). Mobile screens start with a `topbar` and end with a `tabbar` for the main sections; web pages start with a `navbar`. Put side-by-side components on the same `row`. Set `linkTo` on buttons, list items, cards and tabs so the prototype plays.
5. **Fix the links** with `link_screens` if a tap is missing, and set the `start` screen.
6. **Changes later:** `list_diagrams` → `get_diagram` → `update_app_screens` with only the screens that change (all their components) or are new.
7. **Confirm** in two or three lines: the screens, the main path through them, and the board's link (press Play in Builderii to click through).

View saved version →

---
name: brainstorm
description: Put ideas onto a Builderii board as sticky notes grouped by theme, such as the ideas from this conversation, a list the user gives, research findings, or a fresh brainstorm on a topic. Use when the user says "brainstorm", "put this on a board", "add these to Builderii", "make sticky notes" or similar.
---

# Brainstorm onto a Builderii board

1. **What goes up.** If the user gave ideas or a topic, use those. Otherwise take the ideas, options, risks and questions from the conversation so far, without the back-and-forth.
2. **Which board.** If the user named a board, find it with `search` or `list_boards`. Otherwise make one with `create_board` (kind `whiteboard`) and a specific name, such as "Onboarding ideas, Oct 29", never "Brainstorm".
3. **Group by theme.** Two to six themes, each a short title. Each note is one idea in a few words to one sentence. Aim for 3 to 10 notes a theme, and drop duplicates.
4. **Add** them in one `create_brainstorm` call: `groups`, each with its `title` and `notes` (each group gets its own colour).
5. **More later?** Add to the same brainstorm with `update_brainstorm` (`list_diagrams` gives its ref, `get_diagram` its group ids), or let Builderii's AI sort loose notes into themes with `cluster_stickies`, or grow one idea with `expand_ideas`.
6. **Confirm** in one or two lines: how many notes under which themes, with the board's link.

View saved version →

---
name: builderii
description: Work in the user's Builderii boards (app screens and clickable prototypes, flowcharts, mind maps, sequence diagrams, sitemaps, brainstorms, roadmaps, database diagrams and docs) through the Builderii connector. Use whenever the user mentions Builderii or one of their boards, flows, wireframes, screens or sticky notes, or asks to draw, design, map or change something on a board.
---

# Working in Builderii

Builderii is the user's visual workspace: boards with app screens (wireframes and clickable prototypes), flowcharts, mind maps, sequence diagrams, sitemaps, brainstorms (sticky notes), roadmaps, database diagrams and docs. The Builderii connector acts as the user, with their access: their own boards, boards shared with them and their teams' boards.

## Which tool

| To… | Use |
| --- | --- |
| Find a board | `search` (name and content) or `list_boards` (newest first; filter by `query`, `kind`, `folderId`) |
| See what's on a board | `read_board`: each page's diagrams (with refs) and a text outline; `format: "json"` gives one page's elements with ids |
| Start something new | `create_board` (`name`, `kind`, or a `template` from `list_templates`); `add_page` for another page |
| Draw something you've worked out | `create_app_screens`, `create_flowchart`, `create_mindmap`, `create_sequence_diagram`, `create_sitemap`, `create_brainstorm`, `create_roadmap`, `create_database` (or SQL in `sql`), `import_mermaid` |
| Change a diagram | `list_diagrams` → `get_diagram` (its ids) → the matching `update_*` with the diagram's `ref` |
| Make a prototype clickable | `link_screens` (what's tapped on which screen opens which screen; the start screen) |
| Let Builderii's own AI do it | `generate` (any diagram kind from a prompt, a screenshot via `image_url`, or a change to one with `diagram`), `expand_ideas`, `cluster_stickies`, `summarize_board`, `rewrite_text`, `screen_to_code`, `write_spec`, `apply_brand`; `get_ai_job` when one is still working |
| Give feedback | `add_comment`, pinned beside the element whose text matches `on` |

## Habits

- **Find before you make.** If the user names a board, find it (`search` or `list_boards`) and use it; only `create_board` when they want a new one or none matches.
- **Draw it yourself when you know what to draw.** The `create_*` tools take the structure (steps and arrows, screens and components, a tree of ideas); Builderii lays it out. Use `generate` when the user wants Builderii's AI, when they send a screenshot, or for a quick first draft. Builderii's AI counts against the user's monthly AI requests.
- **Change, don't redraw.** To change a diagram that's on the board, read it with `get_diagram` and send only the changes with its `update_*` tool (sequence diagrams, sitemaps, roadmaps and database diagrams take the whole diagram back, keeping ids). Never draw a second copy.
- **AI jobs finish on their own.** If `generate` (or another AI tool) answers `working`, call `get_ai_job` with its `jobId` after a moment; the result lands on the board either way.
- **Link what you make.** Every result has the board's `url`; give it to the user so they can open the board.
- **Keep the user's words.** Use real names, labels and content; don't invent facts the user didn't give.
- **Respect access.** Boards shared view-only or comment-only can't be changed; if a tool says so, tell the user.
- **Not connected?** If a tool asks to connect Builderii or fails to authorize, ask the user to connect (or reconnect) the Builderii connector and approve it.

View saved version →

---
name: diagram
description: Draw a diagram in Builderii, such as a flowchart of a process, a mind map of a topic, a sequence diagram of a system, a sitemap, a roadmap or a database diagram, from a description, this conversation, code or SQL, or change one already on a board. Use when the user asks to map, chart, diagram, visualise or plan something in Builderii.
---

# Draw a diagram in Builderii

1. **Pick the kind.** A process or decision → flowchart (`create_flowchart`). Ideas around a topic → mind map (`create_mindmap`). Who calls whom, in order → sequence diagram (`create_sequence_diagram`). Pages of a site → sitemap (`create_sitemap`). Work over time → roadmap (`create_roadmap`, real dates). Tables and keys → database diagram (`create_database`, or paste SQL / a Prisma schema in `sql`). Mermaid you already have → `import_mermaid`.
2. **Which board.** Use the board the user named; otherwise `create_board` with a specific name (kind `flowchart` or `mindmap` where it fits).
3. **Write the structure.** Short labels in the user's words. Flowcharts: a start and an end, decisions with labelled arrows (yes / no), 5 to 20 steps. Mind maps: one central idea (parent `""`), 4 to 7 branches, 2 to 4 ideas each. Sequence diagrams: participants in order, then messages (`sync`, `async`, `reply`). Builderii lays everything out, so give no coordinates.
4. **Changing one that's there:** `list_diagrams`, then `get_diagram` for its ids, then the matching `update_*` with its `ref` — only the changes for flowcharts, mind maps and brainstorms; the whole diagram (keeping ids) for sequence diagrams, sitemaps, roadmaps and database diagrams. Don't draw a second copy.
5. **Or let Builderii's AI draw it:** `generate` with the `type` and a prompt (pass `diagram` to change one). If it answers `working`, call `get_ai_job` shortly after.
6. **Confirm** in a line or two what you drew, with the board's link.

View saved version →

---
name: feedback
description: Review a Builderii board (an app flow, wireframes, a prototype, a flowchart or a sitemap) and leave clear, actionable comments on the screens and steps they're about. Use when the user asks for feedback, a design or UX review, a critique, or to check a flow on a Builderii board.
---

# Review a Builderii board

1. **Find and read it.** `search` or `list_boards` to find the board the user means, then `read_board` (and `get_diagram` for the details of a flow or app).
2. **Look for what matters,** most important first:
   - Flows: dead ends (screens or steps nothing leads out of), missing start, unreachable screens, missing error, empty and loading states, steps with no way back.
   - Screens: unclear primary action, buttons that go nowhere, labels that don't say what happens, missing fields the flow needs.
   - Diagrams: unlabelled decisions, branches that never rejoin, steps that say the same thing twice.
   - Open comments already on the board: don't repeat them.
3. **Agree first if it's big.** For more than about eight comments, list them for the user and ask which to post.
4. **Comment** with `add_comment`, one point each, pinned with `on` set to the exact text of the screen, button or step it's about. Say what's wrong and what to do: "No way back from Checkout: add a Back button to Cart".
5. **Sum up** in the chat: the two or three things that matter most, and the board's link.

View saved version →

---
name: summarize
description: Explain what's on a Builderii board, or answer a question about it, such as what a flow does, which screens an app has, what a mind map covers or what's still open in its comments. Use when the user asks what's on a board, to summarize or explain one, or a question that a board answers.
---

# Summarize a Builderii board

1. **Find it.** `search` or `list_boards` with a word from the name the user gave. If several match, ask which one.
2. **Read it** with `read_board` (or `fetch`). To leave the summary on the board as a note, or for a long board, `summarize_board` has Builderii's AI write it.
3. **Answer what was asked.** For a summary: what the board is for, its pages, then per page the flow (start screen or first step, the main path and the branches), the main ideas, and open comments with who wrote them. For a question: answer it from the outline, quoting the screen, step or note names.
4. **Stay with the board.** Say so when the board doesn't answer the question, instead of guessing.
5. **Link it.** End with the board's link.