Readiness Check

Confirm which path fits and what you need in place before you start.

I'm starting the Build Your Asset Production System workshop.

My starting point: [a fresh mock-up / concept]  OR  [an existing repo / app]
What I want to walk away with: [keep building / docs & SOPs / launch-ready outputs]

Ask me up to 5 questions that expose anything missing — unclear scope, missing
access, no clear output target. Then tell me which path fits (Mock-up or Repo)
and the first three things I should do.

Mock-up Teardown

Break a mock-up, screenshot, or screenshot-to-code output into named assets.

Here is a mock-up / screenshot / concept of what I'm building:
[paste an image description, link, or screenshot-to-code output]

Break it into a structured asset set. List every screen or surface, the
reusable components, the content types, and the data each one needs. Name each
item and note its purpose. Flag anything ambiguous as a question — don't guess.
Output a clean list I can turn into a build plan.

Asset & Token Extraction

Pull design tokens and reusable assets into one source of truth.

From this mock-up: [paste or describe it]

Extract the reusable design and structural assets: colour and type tokens,
spacing, components, and layout patterns. Produce a single source-of-truth
list — token name, value, and where it's used — that I can hand to a build step
so the implementation stays consistent.

Build Plan from a Mock-up

Turn a defined asset set into an ordered, prompt-driven build plan.

Here is my structured asset set: [paste the teardown / extraction output]

Turn it into an ordered build plan. For each step, give: what gets built, which
assets it uses, and the prompt I'd run to execute it. Sequence it so nothing is
built before its dependencies. Keep it to one screen of output.

Repo Audit

Map what an existing repo actually contains before you document it.

Audit this repository so I can document and operationalize it.
[paste the file tree or key files]

Identify the real assets: modules, services, data models, user-facing flows.
For each, note what it does, how stable it looks, and whether it's documented.
List the gaps between what the code does and what's written down — that gap
list is my documentation backlog.

Flow Capture Plan

Identify the key user flows worth capturing as documentation.

Here's my app: [describe the product and its main users]

List the user flows worth capturing as documentation — onboarding, the core
task, key edge cases, admin. For each flow give the entry point, the steps, and
what a screenshot or recording should show. Order them by how often they're
used. I'll capture these with a browser tool.

SOP Generator

Generate a grounded standard operating procedure from a real artifact.

Using this artifact: [paste a file, captured flow, or process]

Write a standard operating procedure that reflects how it actually works — not
the ideal. Include when to run it, prerequisites, numbered steps, and the
failure modes to watch for. Keep it to one page, written so a new team member
could follow it.

Onboarding Doc Generator

Turn an existing product into skimmable onboarding documentation.

Here's my product: [describe it, and paste the Repo Audit output]

Write the onboarding documentation a new user or teammate needs: what the
product does, the core concepts, the first task to try, and where things live.
Keep it concrete and skimmable — headings, short paragraphs, no marketing
language.

Notion Ops Export

Reformat workshop outputs into a Notion-ready operations structure.

Here are my workshop outputs: [paste assets, SOPs, docs, or plans]

Reformat them into a Notion-ready operations structure: a short, flat page
hierarchy with clear titles, each page's content as simple headings and
bullet-friendly blocks. Avoid tables and deep nesting. Output it so I can paste
each page straight into Notion with minimal cleanup.