Skip to content
Back to search

linkedin-document-carousel

Create high-converting LinkedIn PDF document carousels (1080x1350 portrait 4:5 or 1080x1080 square 1:1) plus companion post copy. Use when the user asks for a LinkedIn document, LinkedIn carousel, swipeable PDF post, slide deck for LinkedIn, or wants to repurpose an article, workflow, thread, or concept into LinkedIn slides with slide-by-slide copy and layout specs. Not for plain text-only feed posts (use linkedin-post-writer) or for auditing an existing draft (use linkedin-humanizer).

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/blankarrayy--linkedin-document-carousel/badge.svg)](/listings/blankarrayy--linkedin-document-carousel)

HTML

<a href="/listings/blankarrayy--linkedin-document-carousel"><img src="/api/listings/blankarrayy--linkedin-document-carousel/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1 — Clone into your personal skills directory (recommended)

git clone http://github.com/blankarrayy/linkedin-document-carousel.git \
  ~/.claude/skills/linkedin-document-carousel

Restart Claude Code (or start a new session). The skill appears as `linkedin-document-carousel` and triggers automatically when you ask for a LinkedIn document, carousel, or swipeable PDF post.

Option 2 — Project-level install (team-shared)

From your project root:

git clone http://github.com/blankarrayy/linkedin-document-carousel.git \
  .claude/skills/linkedin-document-carousel

Commit `.claude/skills/` so everyone on the team gets the skill.

Option 3 — Manual copy

Download or copy this folder to either:

- `~/.claude/skills/linkedin-document-carousel/` (all projects), or - `<your-project>/.claude/skills/linkedin-document-carousel/` (one project)

Either way, the folder must contain `SKILL.md` at its root.

Verify

ls ~/.claude/skills/linkedin-document-carousel/SKILL.md
python3 -c "import fitz, playwright; print('deps ok')"

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 272 lines
  1. ---
  2. name: linkedin-document-carousel
  3. description: Create high-converting LinkedIn PDF document carousels (1080x1350 portrait 4:5 or 1080x1080 square 1:1) plus companion post copy. Use when the user asks for a LinkedIn document, LinkedIn carousel, swipeable PDF post, slide deck for LinkedIn, or wants to repurpose an article, workflow, thread, or concept into LinkedIn slides with slide-by-slide copy and layout specs. Not for plain text-only feed posts (use linkedin-post-writer) or for auditing an existing draft (use linkedin-humanizer).
  4. ---
  5. # LinkedIn Document Carousel Creator
  6. Create swipeable LinkedIn PDF document carousels in one of two formats — **1080×1350 (4:5 portrait, default)** or **1080×1080 (1:1 square)** — plus high-engagement companion post copy. LinkedIn renders uploaded PDFs as native swipeable carousels, which boosts dwell time and saves.
  7. ## Format (user picks one)
  8. | Format | Value | Page size in pt | When to use |
  9. |---|---|---|---|
  10. | **Portrait (default)** | 1080×1350, 4:5 | `1080pt × 1350pt` | Maximum vertical real estate on the LinkedIn mobile feed — default unless the user says otherwise |
  11. | **Square** | 1080×1080, 1:1 | `1080pt × 1080pt` | Even grid presence, simpler layouts, quotes/stat slides, when the user asks for square |
  12. The px figures are how LinkedIn users talk about the sizes; author and assert in **pt** (1:1 px↔pt mapping at these dimensions) so the PDF pages come out exact. Record the choice as `data-format="portrait"` or `data-format="square"` on `<body>` alongside `data-design`. All pipeline geometry below is parameterized by this choice — never hardcode 1350 when the format is square.
  13. **Pipeline:** author slides as **HTML/CSS** → render to PDF with **Playwright (headless Chromium)** → parse, QA, and verify the PDF with **PyMuPDF**. Do not generate the PDF with reportlab, weasyprint, fpdf, or direct PyMuPDF text-drawing — layout lives in HTML; PyMuPDF only audits the output.
  14. ## Mandatory libraries (exact install)
  15. Two packages, no substitutes:
  16. | Step | Library | Role |
  17. |---|---|---|
  18. | Render HTML → PDF | `playwright` (Python) + Chromium | The only renderer — pixel-faithful CSS, real browser engine |
  19. | Parse / QA / verify PDF | `pymupdf` (imports as `fitz`) | Re-open the PDF, bbox checks, page-geometry asserts, PNG renders for visual QA |
  20. ```bash
  21. python3 -m pip install --quiet pymupdf playwright
  22. python3 -m playwright install chromium # add --with-deps on Linux if system libs are missing
  23. ```
  24. Verify both before any work:
  25. ```bash
  26. python3 -c "import fitz, playwright; print(fitz.__doc__); print('ok')"
  27. ```
  28. If `import fitz` fails: `python3 -m pip install --user pymupdf`, then `python3 -m pip install --force-reinstall pymupdf`. If Chromium is missing: re-run `python3 -m playwright install chromium`. Never swap in another PDF library — fix the install.
  29. ## Canonical pipeline
  30. ### 1. Author `carousel.html`
  31. One self-contained HTML file, all slides in document order. **First pick the format** (portrait 1080×1350 or square 1080×1080) **and the design direction** (minimal-professional / experimental / editorial), and set both on `<body data-format="…" data-design="…">`; the `<style>` block below is the shared skeleton — override its tokens (page size, palette, fonts, heading sizes, footer style) to match the chosen format and direction. Starting point (portrait shown; for square change `--page-h` to `1080pt` in both `@page` and `.slide`):
  32. ```html
  33. <!doctype html>
  34. <html><head><meta charset="utf-8">
  35. <style>
  36. /* Tokens — set these from the chosen format + design direction */
  37. :root {
  38. --page-w: 1080pt;
  39. --page-h: 1350pt; /* square format: 1080pt */
  40. --bg: #FAFAF8; --ink: #111111; --accent: #1F4FD8; --muted: #6B6B6B;
  41. --font-display: Helvetica, Arial, sans-serif;
  42. --font-body: Helvetica, Arial, sans-serif;
  43. }
  44. @page { size: 1080pt 1350pt; margin: 0; } /* square: size: 1080pt 1080pt — keep literal, match --page-h */
  45. * { margin: 0; padding: 0; box-sizing: border-box; }
  46. body { font-family: var(--font-body); background: var(--bg); color: var(--ink); }
  47. .slide {
  48. width: var(--page-w); height: var(--page-h);
  49. page-break-after: always; break-after: page;
  50. overflow: hidden; position: relative;
  51. padding: 72pt 72pt 96pt;
  52. display: flex; flex-direction: column; justify-content: center;
  53. }
  54. .slide:last-child { page-break-after: auto; }
  55. h1 { font-size: 72pt; font-weight: 700; line-height: 1.1; }
  56. h2 { font-size: 44pt; font-weight: 700; line-height: 1.2; }
  57. p, li { font-size: 24pt; line-height: 1.4; } /* body floor: 24pt */
  58. .footer { position: absolute; left: 72pt; right: 72pt; bottom: 40pt;
  59. display: flex; justify-content: space-between; font-size: 18pt; }
  60. </style></head>
  61. <body data-format="portrait" data-design="minimal-professional">
  62. <section class="slide" data-slide="1"> … cover … </section>
  63. <section class="slide" data-slide="2"> … insight … </section>
  64. <!-- one <section class="slide"> per slide; N−1 middle slides, CTA last -->
  65. </body></html>
  66. ```
  67. Rules:
  68. - **Units are pt, not px.** `@page size: 1080pt 1350pt` (or `1080pt 1080pt` square) + `.slide` at the same dimensions makes Chromium emit PDF pages of exactly 1080×1350pt or 1080×1080pt. A px-based layout converts at 96dpi and lands at 810×1012.5pt / 810×810pt — right ratio, wrong assert target. Author in pt so geometry asserts pass. Note `@page { size }` cannot reliably read `var()` in Chromium — keep it a literal matching `--page-w`/`--page-h`.
  69. - **Format drives geometry; direction drives skin.** Change `--page-h`, `@page size`, and the `page.pdf()` / PyMuPDF assert dimensions together when switching formats. Swap `--bg`, `--ink`, `--accent`, fonts, heading sizes, and footer treatment per the direction's spec — but keep the pt geometry, the 24pt body floor, and the `.slide` structure unchanged. Experimental may push cover titles to 80–96pt; editorial uses serifs; minimal stays restrained.
  70. - **Square format is tighter:** 270pt shorter — trim cover titles toward the lower end of each direction's range (e.g. 64pt minimal, 80pt experimental), and keep middle-slide body even leaner (target ≤32 words) so centered layouts don't crowd the footer.
  71. - Body ≥ 24pt, headings ≥ 44pt (cover title per direction: 64–72pt minimal, 80–96pt experimental, 64–80pt editorial). High-contrast backgrounds via the direction's palette.
  72. - Footer: consistent handle left, `01/08`-style slide number right — inside `.footer`, never floating free.
  73. - Keep copy inside the slide: 35–40 words max per body slide (≤32 in square). `overflow: hidden` on `.slide` is a backstop, not a license to overfill.
  74. ### 2. Pre-render DOM QA (Playwright, before PDF)
  75. Open the file and check overflow in the real layout engine — catch problems before the PDF exists:
  76. ```python
  77. from playwright.sync_api import sync_playwright
  78. with sync_playwright() as p:
  79. browser = p.chromium.launch()
  80. page = browser.new_page()
  81. page.goto("file:///abs/path/carousel.html", wait_until="networkidle")
  82. over = page.evaluate("""() => [...document.querySelectorAll('.slide')].map((el, i) => ({
  83. slide: i + 1,
  84. overflowY: el.scrollHeight - el.clientHeight,
  85. words: (el.innerText.trim().split(/\\s+/).length)
  86. })).filter(s => s.overflowY > 1 || s.words > 40)""")
  87. assert not over, f"DOM QA failed: {over}"
  88. # then render (step 3) in the same session
  89. browser.close()
  90. ```
  91. Fix the HTML and re-run until this returns `[]`.
  92. ### 3. Render HTML → PDF (Playwright, still in the same session)
  93. ```python
  94. # portrait: 1080×1350pt | square: 1080×1080pt — match the chosen format
  95. page.pdf(
  96. path="carousel.pdf",
  97. width="1080pt", height="1350pt", # square: height="1080pt"
  98. print_background=True, # required — solid slide backgrounds
  99. prefer_css_page_size=True, # honor @page size above
  100. margin={"top": "0", "bottom": "0", "left": "0", "right": "0"},
  101. )
  102. ```
  103. Keep steps 2–3 in one script (e.g. `build_carousel.py`) so a copy edit → re-QA → re-render is one command.
  104. ### 4. Parse back + programmatic QA (PyMuPDF — mandatory)
  105. Reopen the rendered file; never trust the renderer blindly:
  106. ```python
  107. import fitz
  108. FORMATS = {"portrait": (1080, 1350), "square": (1080, 1080)}
  109. W, H = FORMATS[fmt] # fmt = "portrait" or "square"
  110. doc = fitz.open("carousel.pdf")
  111. assert len(doc) == slide_count
  112. MARGIN = 36 # pt
  113. for i, page in enumerate(doc, 1):
  114. assert page.rect == fitz.Rect(0, 0, W, H), f"slide {i}: wrong page size {page.rect} (expected {W}×{H} for {fmt})"
  115. for block in page.get_text("dict")["blocks"]:
  116. for line in block.get("lines", []):
  117. for span in line["spans"]:
  118. x0, y0, x1, y1 = span["bbox"]
  119. assert x0 >= MARGIN and x1 <= W - MARGIN, f"slide {i}: x overflow {span['text']!r}"
  120. assert y0 >= MARGIN and y1 <= H - MARGIN, f"slide {i}: y overflow {span['text']!r}"
  121. assert span["size"] >= 17, f"slide {i}: font too small ({span['size']}pt): {span['text']!r}"
  122. ```
  123. (Header/heading spans should be checked at ≥44pt where the design says so; 17pt is the absolute floor for the footer. The HTML spec keeps body at 24pt.)
  124. Any assert failure → edit `carousel.html`, re-run steps 2–4. No skipping.
  125. ### 5. Visual QA (PyMuPDF render → Read the PNGs)
  126. ```python
  127. for i, page in enumerate(doc, 1):
  128. pix = page.get_pixmap(matrix=fitz.Matrix(1, 1), alpha=False) # 1080×1350 px, or 1080×1080 square
  129. pix.save(f"slide-{i:02d}.png")
  130. ```
  131. Read every `slide-*.png` and visually confirm: no clipping, no overlap, no wall-of-text, footer and slide numbers present, contrast holds. Fix and re-loop until clean.
  132. ### 6. Finalize
  133. Save a compressed copy if you mutated the doc (`doc.save("carousel.final.pdf", garbage=4, deflate=True)`). Deliver `carousel.pdf` (7–10 slides typical, hard cap 30, well under LinkedIn's 100MB limit) plus the companion post copy below. State the delivered format in your summary (e.g. "1080×1350 portrait" / "1080×1080 square"). Ship `carousel.html` and `build_carousel.py` alongside so the user can re-run after edits.
  134. ## Design directions (user picks one)
  135. The pipeline is identical for every direction — only the `<style>` block inside `carousel.html` and the copy tone change. Pick **one** mode per carousel; never blend two modes in one document. Record the choice as a `data-design="…"` attribute on `<body>` so re-runs stay consistent.
  136. ### A. `minimal-professional` — Minimal Professional (default)
  137. Corporate-safe, high whitespace, zero decoration. Reads like a well-made consulting deck.
  138. - **Palette:** near-white background `#FAFAF8` (or pure `#FFFFFF`), ink `#111111`, single restrained accent (e.g. `#1F4FD8` or brand color) used only for rules, numbers, and the CTA. One alternate slide may invert (ink background, white text) for the cover or CTA only.
  139. - **Type:** one sans family (Helvetica/Inter). Cover title 64–72pt regular or medium — **not** ultra-black. Body 24pt, generous line-height 1.45. Sentence case headings; no ALL-CAPS except tiny eyebrow labels (16–18pt, letter-spaced).
  140. - **Layout:** single column, strong left alignment, 72pt+ margins. Thin 1–2pt horizontal rules to separate eyebrow from headline. Numbers set large (48pt+) in the accent color. Lots of empty space — if a slide feels full, cut words, don't shrink type.
  141. - **Footer:** hairline rule above; handle left, `01/08` right, 16–18pt, muted gray.
  142. - **Avoid:** gradients, shadows, rounded cards, emoji, dark backgrounds on more than one slide.
  143. ### B. `experimental` — Cool / Experimental
  144. Dark-first, loud type, asymmetric. For builders, dev-tools, design-engineering personal brands.
  145. - **Palette:** deep background `#0B0B0F` / `#0E1116`, off-white text `#F5F5F7`, one electric accent (`#7C3AED`, `#22D3EE`, `#C6FF00` — pick one). Optional subtle gradient wash or a single large geometric shape (`border-radius`, rotated rect) per slide.
  146. - **Type:** one sans, extreme contrast — cover title 80–96pt heavy (800/900), body 22–24pt regular. Oversized slide index (`03` at 120pt+, accent color, low opacity, bleeding off an edge). Short punchy lines; mono font (`ui-monospace`, `JetBrains Mono`) for labels, code-ish eyebrows, and the footer.
  147. - **Layout:** break the grid on purpose — title pushed to one edge, a stat occupying the opposite corner, intentional asymmetry. One hero element per slide (a number, a one-word title, a diagram). Stagger reveals of information across middle slides.
  148. - **Footer:** mono, accent slash — `handle / 03—08`.
  149. - **Avoid:** more than one accent color per slide, soft corporate blues, dense paragraphs.
  150. ### C. `editorial` — Editorial / Magazine
  151. Print-magazine energy for thought leadership, essays, contrarian takes.
  152. - **Palette:** warm paper `#F6F1E7` or crisp `#FFFFFF`, near-black ink `#1A1A1A`, one ink-wash accent (`#8B1E1E`, `#1A5E3A`, or deep navy). Serif-dominant.
  153. - **Type:** serif for display and body (Georgia / `Source Serif` / `Libre Baskerville`; embed a TTF via `@font-face` if provided). Cover title 64–80pt, with a serif italic subtitle. Body 22–24pt, line-height 1.5. Sans only for eyebrows and footers (small, tracked-out caps). Drop-cap or oversized initial on narrative slides if it fits cleanly.
  154. - **Layout:** magazine moves — eyebrow (category label) → serif headline → rule → deck/subhead → body. Two-column body only when text is short enough to stay ≥24pt. Pull-quote slides: one sentence at 40–48pt italic, centered, with quotation marks. Page furniture like print: running eyebrow top, folio bottom.
  155. - **Footer:** folio style — `handle` left, `· 03 ·` centered or right, small caps.
  156. - **Avoid:** neon accents, heavy geometric shapes, ultra-black weights, tech-startup gradients.
  157. ### Choosing well
  158. - User's audience is recruiters/clients/execs → `minimal-professional`.
  159. - User is a builder/designer/creator showing taste → `experimental`.
  160. - User is making an argument, essay, or POV post → `editorial`.
  161. - Brand palette or font file provided → keep the chosen direction's *layout and type character*, but swap in the brand colors/font so the deck stays on-brand (the direction still governs structure and tone).
  162. - User asks for something "like the design of X" → map X onto the closest direction above and say which one you picked.
  163. ## When to use
  164. - User asks to create a LinkedIn document, carousel, or swipeable PDF post (portrait or square).
  165. - User wants to turn a blog post, technical architecture, workflow, or thread into LinkedIn slides.
  166. - User asks for slide-by-slide LinkedIn copy and visual layout specifications.
  167. ## Steps
  168. ### 1. Clarify inputs (if missing)
  169. Confirm the core topic or source material, target audience, slide count (default: 7–10), brand palette/handle, accent color, and brand font file (optional TTF → `@font-face` in `carousel.html`) if not already known.
  170. Also confirm the **format** (see the Format section above). If unspecified, default to **portrait 1080×1350 (4:5)**; ask when in doubt:
  171. - **Portrait (1080×1350, 4:5)** — default; tallest presence in the mobile feed
  172. - **Square (1080×1080, 1:1)** — even grid presence; simpler, punchier layouts
  173. And confirm the **design direction** (see the section above). If the user doesn't specify one, ask with these labels — or default to `minimal-professional` if they say "just make it":
  174. - **Minimal Professional** — safe for any industry, recruiter- and exec-readable
  175. - **Experimental** — for builders, designers, dev-tools, personal brands that want to stand out
  176. - **Editorial** — thought-leadership and long-form essay energy
  177. ### 2. Structure the slide arc
  178. - **Slide 1 (Cover Hook):** Bold, high-contrast title (under 10 words) + short subtitle + swipe cue. No dense paragraphs.
  179. - **Slides 2 to N−1 (Core Insights):** One idea per slide. Body under 35–40 words. Numbered steps, short bullets, or clear visual comparisons.
  180. - **Final Slide (Closing CTA):** One-line takeaway + a specific action (comment, save, visit link).
  181. ### 3. Build via the canonical pipeline
  182. Write `carousel.html` (chosen format + design direction, pt units, `.slide` sections) and `build_carousel.py` (DOM QA → `page.pdf` → PyMuPDF parse/QA → PNG render). Run them. Only hand over a PDF that passed bbox asserts **and** your visual read of every rendered slide — and confirm every slide reads as *one* consistent direction, not a mix.
  183. If Python/Pip/Playwright cannot run in the active environment, output the slide-by-slide blueprint plus the complete `carousel.html` and `build_carousel.py`, and the exact install lines (`python3 -m pip install pymupdf playwright && python3 -m playwright install chromium`).
  184. ### 4. Write companion LinkedIn post copy
  185. - **Hook (lines 1–2):** Under 12 words, stops the scroll, no "I" opener or corporate fluff.
  186. - **Body:** 3–5 short lines on why the document matters, with concrete numbers or outcomes.
  187. - **CTA question:** One specific, easy-to-answer question to drive comments.
  188. ## Gotchas
  189. - **Wrong unit → wrong page size:** px-authored slides render at 810×1012.5pt (portrait) or 810×810pt (square). Author everything in pt; assert `page.rect` against `FORMATS[fmt]` in step 4 — a failed assert means the file is wrong, not the assert.
  190. - **Format mismatch mid-pipeline:** Changing the format means updating *all four* together: `@page size`, `.slide` height, `page.pdf(height=…)`, and the PyMuPDF `W, H` assert. Updating only the CSS leaves the render and QA disagreeing.
  191. - **`print_background=True` omitted:** Chromium drops solid backgrounds; slides ship white-on-white. Always pass it.
  192. - **Wall-of-text slides:** Never exceed 40 words per slide. Split across two slides instead of shrinking fonts — the DOM word-count check and bbox QA both enforce this.
  193. - **Skipping parse-back QA:** Rendering without re-opening the PDF in PyMuPDF is how clipped text ships. Steps 4–5 are mandatory, not optional.
  194. - **Image-only workarounds:** Do not screenshot slides and paste images into a PDF to dodge layout issues — fix the HTML. (Text-based PDFs stay selectable and were audited for overflow.)
  195. - **Blending directions:** One mode per carousel. A minimal deck with one neon experimental slide looks broken — if a slide needs emphasis, use the direction's own tools (accent rule, inverted panel, pull quote).
  196. - **Decorating past the copy:** The direction changes look, not length. 35–40 words/slide and the 24pt floor hold in all three modes; experimental's oversized type means *fewer* words, not smaller ones.
  197. - **AI buzzwords:** No "delve", "harness", "unlock", "tapestry", or "game-changer" in slides or post copy. Direct, concrete language only.
  198. ## Related skills
  199. - Drafting a text-only feed post from scratch → `linkedin-post-writer`
  200. - Stripping AI tells from carousel captions or the companion post → `linkedin-humanizer`
  201. - Turning an existing article or thread into source material first → `linkedin-repurposer`
README.md · README · 108 lines
  1. # linkedin-document-carousel
  2. A Claude Code skill that creates high-converting **LinkedIn PDF document carousels** (1080×1350pt portrait, 4:5) plus companion post copy — and actually ships a QA'd PDF, not just a slide outline.
  3. **Author:** [blankarrayy](http://github.com/blankarrayy/) · **Repo:** [blankarrayy/linkedin-document-carousel](http://github.com/blankarrayy/linkedin-document-carousel)
  4. ## What it does
  5. - Turns an article, workflow, thread, or concept into a 7–10 slide swipeable carousel
  6. - Two **formats**: **1080×1350 portrait (4:5, default)** or **1080×1080 square (1:1)**
  7. - Offers **three design directions** the user picks from:
  8. - **Minimal Professional** (default) — clean consulting-deck look, safe for any industry
  9. - **Experimental** — dark, loud type, asymmetric; for builders and personal brands
  10. - **Editorial** — magazine/serif thought-leadership energy
  11. - Writes the companion LinkedIn post (hook, body, CTA question)
  12. - Builds the PDF through a fixed pipeline and QA's it before handing it over:
  13. ```
  14. carousel.html (HTML/CSS layout)
  15. → Playwright headless Chromium (DOM overflow QA → page.pdf render)
  16. → PyMuPDF (parse back: page geometry, text bbox, font-size asserts)
  17. → slide-NN.png (visual QA — every slide inspected)
  18. → carousel.pdf
  19. ```
  20. No reportlab, weasyprint, or hand-drawn PDF text — layout lives in HTML; PyMuPDF only audits the output.
  21. ## Requirements
  22. - Python 3.9+
  23. - Two packages (installed by the skill on first use, or pre-install yourself):
  24. ```bash
  25. python3 -m pip install pymupdf playwright
  26. python3 -m playwright install chromium # add --with-deps on Linux
  27. ```
  28. ## Install
  29. ### Option 1 — Clone into your personal skills directory (recommended)
  30. ```bash
  31. git clone http://github.com/blankarrayy/linkedin-document-carousel.git \
  32. ~/.claude/skills/linkedin-document-carousel
  33. ```
  34. Restart Claude Code (or start a new session). The skill appears as `linkedin-document-carousel` and triggers automatically when you ask for a LinkedIn document, carousel, or swipeable PDF post.
  35. ### Option 2 — Project-level install (team-shared)
  36. From your project root:
  37. ```bash
  38. git clone http://github.com/blankarrayy/linkedin-document-carousel.git \
  39. .claude/skills/linkedin-document-carousel
  40. ```
  41. Commit `.claude/skills/` so everyone on the team gets the skill.
  42. ### Option 3 — Manual copy
  43. Download or copy this folder to either:
  44. - `~/.claude/skills/linkedin-document-carousel/` (all projects), or
  45. - `<your-project>/.claude/skills/linkedin-document-carousel/` (one project)
  46. Either way, the folder must contain `SKILL.md` at its root.
  47. ### Verify
  48. ```bash
  49. ls ~/.claude/skills/linkedin-document-carousel/SKILL.md
  50. python3 -c "import fitz, playwright; print('deps ok')"
  51. ```
  52. ## Usage
  53. Just ask in Claude Code:
  54. > "Make a LinkedIn carousel from this blog post: \<paste or link\>"
  55. > "Turn this thread into a 9-slide LinkedIn document, experimental design"
  56. > "Make a square 1:1 LinkedIn carousel from these release notes, editorial style"
  57. The skill will:
  58. 1. Clarify topic, audience, slide count, **format** (portrait 4:5 or square 1:1), and **design direction** (if not specified)
  59. 2. Structure the slide arc (cover hook → insights → CTA)
  60. 3. Write `carousel.html` + `build_carousel.py`, run the render → parse → QA loop
  61. 4. Deliver `carousel.pdf` (in the chosen format), `slide-NN.png` previews, the source files, and the companion post copy
  62. ## Files
  63. | File | Purpose |
  64. |---|---|
  65. | `SKILL.md` | The skill definition Claude Code loads |
  66. | `README.md` | This file |
  67. ## Related skills
  68. - Text-only feed post → [`linkedin-post-writer`](http://github.com/blankarrayy/linkedin-post-writer)
  69. - De-AI an existing draft → `linkedin-humanizer`
  70. - Repurpose an article/thread into source material first → `linkedin-repurposer`
  71. ## License
  72. See the repository for license details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.