---
name: manthan-cards
description: Convert any source material (notes, an article, a book excerpt, documentation) into Manthan concept-card JSON, ready to direct-import at manthan.sirune.tech with no AI-generation quota cost. Use when asked to "make Manthan cards from X", "turn this into a Manthan deck", or similar.
---

# Manthan card creation

Manthan (manthan.sirune.tech) turns source material into a deck of concept cards, then maps them
into a leverage-ranked graph — which few cards unlock the most downstream understanding vs. which
just take time to read. This skill produces the exact JSON shape Manthan already parses, so the
output can be uploaded directly, with no AI-conversion step and no AI-generation quota spent on
Manthan's own end (this "direct import" path exists specifically for cards an AI or human has
already written, as opposed to a raw PDF/doc that still needs converting).

## Output format

A single JSON array of card objects (a top-level `{"cards": [...]}` wrapper is also accepted):

```json
[
  { "title": "Ownership", "content": "Every value has exactly one owner. Only one owner at a time. Value is dropped when its owner leaves scope." },
  { "title": "Borrowing", "content": "References let you access a value without taking ownership of it.",
    "tags": ["rust", "memory"], "prerequisites": ["Ownership"] }
]
```

**Rules for each card:**
- `title` and `content` are required, non-blank strings. `title` is a concept/term, 2-6 words.
  `content` is 1-4 short sentences that actually explain the concept, not just a bare definition.
- One idea per card. Prefer more, smaller cards over fewer, denser ones.
- `tags` (optional): array of 2-4 short topical strings.
- `prerequisites` (optional): array of *titles* of other cards in the same list that should be
  understood first. Each title is matched against the other cards being imported in this same
  batch — a title that doesn't match anything is silently skipped (not an error), so don't worry
  about getting every reference perfect.
- Aim for 10-40 cards for a full document/topic — extract every distinct term, construct, and
  pattern rather than summarizing broad strokes into a handful of generic cards.

### Code in a card's content

`content` can include a fenced code block — ` ```lang\ncode\n``` ` (language tag optional) — and
Manthan renders it with a distinct background instead of folding it into wrapped prose. Cards are
a fixed-width box (36 usable characters, no horizontal scroll), so this only suits a short snippet
(a signature, a one-liner, a handful of lines) — long lines get truncated, not wrapped, so a
snippet that needs more room is better split across a few smaller cards than crammed into one.

## What to do with the output

1. Save the JSON array as a `.json` file (any filename — it becomes the deck's name).
2. On manthan.sirune.tech, open "Create Cards" and either drag the file in, or paste the JSON
   text directly — pasted text that parses as this shape is offered a direct-import prompt
   automatically.
3. Manthan imports every card exactly as written (no rephrasing), resolves `prerequisites` into
   real links, and creates any new `tags` — then the deck is ready to explore in Knowledge mode.

## Full format reference

This skill covers the common case (plain JSON authoring). For the underlying ASCII card-box
format, export/import round-tripping, and more detail on how `prerequisites` resolve against an
existing account, see the full contract at https://manthan.sirune.tech/manthan-claude.md — this
skill's JSON shape is a strict subset of what that spec accepts, so anything valid here is
already valid there.