Kai Product Maker logo

Kai Product Maker

Community
cgallic
kai-product-maker

Build a Gumroad-ready digital product from scratch — ebook, card deck, playbook, Notion template, or flipbook. Walks from concept → content outline → design brief → per-item markdown → images → multi-format build (PDF, HTML flipbook, Notion, card deck) → Gumroad sales page + email blast + launch assets. Use when "make a digital product", "build an ebook", "create a playbook", "card deck", "notion template product", "gumroad product", "make a pdf to sell", or any request to ship a sellable information product.

Overview

Publishercgallic
Repositorykai-cmo-harness
Skill namekai-product-maker
Stars
61
Forks
8
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by cgallic on GitHub. Read the source before you install it.

Installation

Install the Kai Product Maker AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/cgallic/kai-cmo-harness/tree/main/harness/skills-v2/kai-product-maker
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/cgallic/kai-cmo-harness.git /tmp/kai-cmo-harness
mkdir -p .claude/skills
cp -r /tmp/kai-cmo-harness/harness/skills-v2/kai-product-maker .claude/skills/kai-product-maker
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Kai Product Maker in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Kai Product Maker on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Kai Product Maker is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Objective

A Gumroad-ready digital product a buyer would pay $7–$97 for, plus the assets that sell it: the finished deliverable (PDF, HTML flipbook, Notion deck, or card set), a sales page, a three-email launch sequence, launch video scripts, and a customer-facing package containing only what the buyer should receive.

The product is built from content/*.md and images/, assembled by a build script, and governed by a design brief locked before any content is written. Design inconsistency is the single largest reason an information product reads as cheap.

Use this when the user has a topic and an audience and wants a sellable artifact, or has drafts but no structure, images, or sales page. Do not use it for a free lead magnet (/kai-write, /kai-landing-page), for a sales page on a finished PDF (/kai-write), or for anything that is software rather than a static digital good.

Done when

Work type campaign — floor E5/C3/O4 (harness/eco-floors.yaml), composite. A product launch is a multi-asset work item: the deliverable, the sales page, the email sequence, and the launch video each carry their own child floor, and the campaign is CLOSED only when every child is CLOSED and the campaign threshold is met. One unshipped asset keeps it open.

  • E5 — the Gumroad listing exists with thumbnail, sales copy, and uploaded files; the live listing reads back matching the approved bundle; the downloaded package opens and the PDF or flipbook renders end to end with working navigation.
  • C3 — sales copy scores 12+/16 on Four U's with zero banned words and a clear CTA; content passes a Four U's check at 12+/16; a non-producer read the finished deliverable end to end. The brief matches the shipped product with no design drift, and images hold to the character reference.
  • O4 — units sold, revenue, and conversion rate against a threshold declared before launch, read from Gumroad at the declared window. Baseline and threshold are set before the listing goes live.

Launch evidence checklist: every content file referenced by the build lives in content/; the zip contains only customer-facing files (no research, no old drafts); three launch emails queued; one launch video scripted.

Constraints

  • Approval gates twice before production. The one-paragraph concept is approved before the brief; PRODUCT_BRIEF.md is approved before any content is written. Skipping either produces a product that gets rebuilt.
  • Content lives only in content/*.md. The build is downstream. Never edit assembled HTML or PDF directly — the next build overwrites it.
  • Every unit is structured identically. Chapters share a shape, cards share a shape. Structural drift across items is what makes a product read as amateur.
  • Images come last among production assets, after content and brief are locked, because iteration on them is the most expensive step. Pin the character reference in every image prompt; kill style drift before generating more.
  • Sales copy comes after the product is finished. Writing it earlier means writing about a product that does not exist yet.
  • Facts carry sources. Statistics, patent numbers, and quotes go in a Research/ folder beside content/ with the source cited. An unsourceable number does not ship in a paid product.
  • Quality gate every five units. Run /kai-gate for a Four U's score and fix before producing more; a batch of twenty bad units costs twenty rewrites.
  • Ship examples, not theory — real screenshots, real numbers, real scripts.
  • Scope is locked at the unit count set in the concept. A tenth chapter when nine was the plan is a 1.1 release, not this release.
  • No launch video means no traffic. A Gumroad listing without launch content is a dead listing.

Context

NeedLoad
Product, ICP, voice, positioningMARKETING.md (project root); run /kai-start if absent
Ground truth for a finished 9-chapter PDF ebook ($47–67)E:\Dev2\DigitalProduct\AlgoProduct\
Ground truth for a 30-card mobile-first Notion deck ($37)E:\Dev2\DigitalProduct\ApprovalEngine\
Ground truth for an HTML flipbook + PDF, 20 workflows ($37)E:\Dev2\DigitalProduct\CommentConnorPlaybook\
Design brief structure to copyCommentConnorPlaybook/PRODUCT_BRIEF.md
Build prompt structure to copyCommentConnorPlaybook/BUILD_PROMPT.md
Sales page structure to copyAlgoProduct/GUMROAD_SALES_COPY.md
Customer package structureAlgoProduct/CUSTOMER_PACKAGE_STRUCTURE.md
Production checklist structure (priority, time estimates, why-it-matters)AlgoProduct/PRODUCTION_CHECKLIST.md
Batch image generation patternCommentConnorPlaybook/generate_images.py

All three examples share the same scaffolding — numbered content/*.md, images/, PRODUCT_BRIEF.md, BUILD_PROMPT.md, a build script, sales copy, and a production checklist.

Six concept decisions, made before the scaffold exists: working title and subtitle; the one-sentence promise (what changes for the reader); format; price point ($7 / $17 / $27 / $37 / $47 / $67 / $97 — a higher price buys more production polish, not more pages); unit count (chapters, workflows, cards, templates — this sizes everything downstream); and source material.

Format choice drives everything downstream:

FormatShapeBuild tool
PDF ebookLinear read, 30–80 pagespandoc + xelatex, or AlgoProduct/merge_pdfs.py + AlgoProduct/HOW_TO_COMBINE_PDFS.md
HTML flipbook + PDFIllustrated, page-by-page, designedCommentConnorPlaybook/build_html.py (self-contained HTML, base64 images, keyboard + touch nav)
HTML print versionSame content, @page + print CSS, browser-to-PDFCommentConnorPlaybook/build.py
Notion card deckMobile-first, scannable, 20–50 cardsApprovalEngine/setup_notion.py + NOTION_IMPORT.csv
Template packFill-in worksheets and promptsUsually a bolt-on, not standalone

Folder scaffold at E:\Dev2\DigitalProduct\<ProductName>\:

<ProductName>/
├── PRODUCT_BRIEF.md              # design + spec, locked before content
├── BUILD_PROMPT.md               # how a fresh session assembles deliverables
├── content/                      # 00_ front matter, 01_-NN_ in reading order, zero-padded
├── images/                       # character_reference.png, cover.png, dividers, per-item art
├── Research/                     # source notes (optional)
├── GUMROAD_SALES_COPY.md
├── EMAIL_BLAST.md
├── COVER_IMAGE_PROMPT.md
├── PRODUCTION_CHECKLIST.md
├── VIDEO_SCRIPTS.md
└── <ProductName>_Package/        # customer zip: START_HERE.txt, MAIN.pdf, bonuses, README.md

PRODUCT_BRIEF.md minimum sections: what you are building (one paragraph, tone matched to the product); aesthetic direction (one named mood plus 3–5 references); color palette (bg / surface / border / primary text / dim text / accent / danger / success, 6–8 hex codes); typography (headline, body, code — Google Fonts for HTML with system fallbacks, plus italics, stamps, letter-spacing rules); page or card layout with a per-page element list; full page sequence front to back; image specs (character reference, cover dimensions, per-item style, consistency rules); distribution formats.

Unit structure. An ebook chapter: H2 title, one-paragraph setup, numbered or bulleted body, a "watch out for" callout, a "why this works" callout, a forward link. A card or workflow: ## Situation, ## Goal, ## What NOT to say, ## Use this instead (script or prompt in a code block), ## Why this works, then tags.

Image set: character_reference.png (consistency sheet, not shipped), cover.png (1600×900 Gumroad, 2:3 portrait for PDF), cat_<name>.png per section cluster, 01_<slug>.png per item, Product_Thumbnail.png (400×400).

BUILD_PROMPT.md is self-contained for a fresh session: what exists (content, images, brief files to read), what to build (one section per deliverable), and what not to regenerate.

Sales assets, in order: GUMROAD_SALES_COPY.md (headline and subheadline; hook framing the problem painfully; the reveal; proof with screenshots, numbers, case study; what's inside; who it is and is not for; price anchor and CTA; guarantee and PS), EMAIL_BLAST.md (tease → launch → last-call, mirroring the sales page hook), COVER_IMAGE_PROMPT.md (the exact prompt used), VIDEO_SCRIPTS.md (1–2 hook-first 30–60s scripts, composed with /kai-video).

Composes with: /kai-brand (voice), /kai-write (any single file), /kai-gate (scoring), /kai-video and /kai-video-production (launch video), /kai-email-system (sequence), /kai-repurpose (product → 15+ social assets), /kai-competitors (who else sells this).

Escalate when

  • The source material does not contain enough substance for the declared unit count — a padded product refunds.
  • A statistic, quote, or screenshot central to the pitch cannot be sourced.
  • The price point and the production polish disagree and the user wants the higher price anyway.
  • Images drift from the character reference and re-generation would exceed the agreed budget.
  • The build produces a deliverable that does not render cleanly and the fix requires changing the locked brief.
  • A testimonial or customer result would appear in the sales copy without written permission — route to /kai-proof-builder first.

Frequently asked questions

What does the Kai Product Maker AI skill do?

Build a Gumroad-ready digital product from scratch — ebook, card deck, playbook, Notion template, or flipbook. Walks from concept → content outline → design brief → per-item markdown → images → multi-format build (PDF, HTML flipbook, Notion, card deck) → Gumroad sales page + email blast + launch assets. Use when "make a digital product", "build an ebook", "create a playbook", "card deck", "notion template product", "gumroad product", "make a pdf to sell", or any request to ship a sellable information product.

Why use Kai Product Maker on TypingMind?

Because you install it once and use it with any model. Kai Product Maker is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Kai Product Maker in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/cgallic/kai-cmo-harness/tree/main/harness/skills-v2/kai-product-maker. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Kai Product Maker?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Kai Product Maker?

As many as you like. As long as a model supports skills, you can use Kai Product Maker with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Kai Product Maker AI skill free?

It is published on GitHub by cgallic. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇