AI Skill Report Card
Repurposing Archives into Digital Assets
Quick Start13 / 15
Given any content source (URL, archive, metadata dump, historical text), run it through the four-stage pipeline:
- Source scan: identify the repository, license status (public domain / CC0 confirmed), and the raw unit of value (a color plate, a pattern diagram, a paragraph of instructions).
- Fragment extraction: break the raw unit into its smallest reusable components (individual colors, stitch nodes, coordinate pairs, sentence-level logic).
- Remap to target format: choose the output state machine (design tokens, crochet chart, Notion schema, vector sheet) and write the fragment→output transformation rule.
- Package + ship: bundle outputs into a single sellable pack with one free sample, one paid tier, and a written "recipe" so the next pack is cheaper to produce.
Output of every pass: a recipe document (source → extraction rule → validation step → output files) that gets reused, not just the asset itself.
Recommendation▾
Show a concrete input/output pair with actual sample data (e.g., real hex codes, an actual stitch grid snippet) rather than describing the transformation abstractly.
Workflow13 / 15
Progress:
- Step 1: Pick one source repository and one output format (don't parallelize on v1)
- Step 2: Extract 10-20 raw units manually to find the fragment pattern before automating
- Step 3: Define the granular fragment schema (what's the atomic unit — a hex code? a node coordinate? a stitch instruction?)
- Step 4: Write the remapping rule from fragment → target output structure
- Step 5: Run one validation pass specific to the output (accessibility check, physical buildability check, schema check)
- Step 6: Package as: 1 free sample + 1 paid pack + 1 product page
- Step 7: Write the recipe doc so pack #2 skips steps 2-3
Sequencing rule: never build the multi-step agent canvas before the manual recipe is proven on one pack. The canvas comes after the recipe is stable, not instead of it.
Recommendation▾
Add a 'bad outcome' example — e.g., a pack that failed validation or shipped without license-checking — to contrast with the successful examples.
Examples16 / 20
Example 1: Colour plate → design tokens Input: Public-domain historical color plate archive (HathiTrust) Output:
- Fragment unit: individual color swatch (hex value + plate position)
- Remap rule: cluster swatches into palettes of 5, run color-blind simulation (deuteranopia/protanopia/tritanopia), discard failing palettes
- Output files: Figma Tokens Studio JSON, CSS custom properties, print-ready PDF swatch sheet
- Package: 12 validated palettes, 5-swatch free sample, email-gated download
Example 2: Historical pattern book → crochet chart Input: Public-domain lace/needlework pattern catalog Output:
- Fragment unit: single stitch node with row/column position
- Remap rule: convert stitch symbols to a grid state machine (each cell = stitch type + position), validate that the graph is physically closeable (no orphan stitches, row counts match)
- Output files: printable chart PDF, symbol-key legend, optional digital stitch-by-stitch JSON for app import
- Package: one chart pack, one free single-motif sample
Example 3: Web metadata → Notion template Input: Bundle of URLs plus scraped metadata (titles, tags, dates) Output:
- Fragment unit: single metadata record (title/tag/date/source)
- Remap rule: map fields to Notion database properties, generate relation/rollup structure
- Output files: Notion template JSON/export, CSV seed data
- Package: CRM template + starter dataset
Recommendation▾
Clarify licensing edge cases (e.g., what counts as public domain vs. CC0 vs. 'freely available but restricted') since license-checking is called critical but given minimal detail.
Best Practices
- One source, one output, one pack for any new repository — prove the recipe before scaling.
- Validation is format-specific and non-negotiable: color-blind simulation for palettes, physical closeability for craft charts, schema integrity for templates. Ship nothing unvalidated.
- Always produce a free fragment (5 swatches, 1 motif, 1 template section) before the paid pack — it's the email-capture wedge, not an afterthought.
- Write the recipe as you go, not after — the recipe document is the actual scalable asset, the pack is just its first output.
- License-check first, extract second — confirm public domain / usage rights before any fragment work begins.
- Keep the granularity as small as the target format allows — smaller fragments (single color, single stitch, single field) give more remapping flexibility than pre-clustered chunks.
Common Pitfalls
- Building the multi-step agent/AI canvas before manually validating one pack end-to-end — automate the proven recipe, not the guess.
- Skipping format-specific validation (e.g., shipping a crochet chart that isn't physically buildable, or a palette that fails accessibility checks).
- Treating the source material as finished content to "edit" rather than raw material to decompose into fragments — remixing isn't the same as remapping.
- Launching multiple packs/sources simultaneously in v1 — this fragments effort before any single recipe is proven.
- Forgetting the free-sample email capture — it's the mechanism that turns a static asset into a growing buyer list.
- Confusing "waitlist/interest" mode with "live sales" — don't imply real checkout exists until payment infrastructure is actually connected.