> ## Documentation Index
> Fetch the complete documentation index at: https://docs.slideless.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Generate, share, update from a terminal

> AI-generated HTML, one command to publish, one more to re-publish. The link never changes.

## The file-versioning trap

Anyone who's shared a deck more than twice knows how it ends:

```
Q4_review.pptx
Q4_review_v2.pptx
Q4_review_FINAL.pptx
Q4_review_FINAL_v2.pptx
Q4_review_FINAL_USE_THIS.pptx
```

Each new version is a fresh file, a fresh email, a fresh attachment, and (probably) a different person opening the wrong one. Tools like Google Slides solve this with a single canonical URL, but only inside their ecosystem, and only if you're willing to log in.

## The Slideless loop

Slideless gives you a single URL per deck and lets you update what's behind it without ever changing the URL:

```
1. AI generates the HTML       (e.g. Claude with `generate-presentation`)
2. You upload it               (`slideless push ./deck.html --title "..."`)
   → returns presentationId, writes slideless.json at the deck root
3. You mint a viewer URL       (`slideless share <presentationId>`)
   → returns shareUrl
4. You share the URL           (Slack, email, anywhere)
5. You iterate on the content  (Claude regenerates, you tweak)
6. You re-publish              (`slideless push` again from the same folder)
   → same shareUrl, version + 1, view count preserved
7. Recipients refresh          (they see the new content, no re-share)
```

That's it. The URL you sent on Tuesday morning still works on Friday afternoon, even though the content has been edited five times in between.

## In a terminal

Generate, push, share, iterate:

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Generate (with the Claude marketplace skill)
$ claude --skill generate-presentation "Q4 results, revenue, churn, headcount" > deck.html

# Push
$ slideless push ./deck.html --title "Q4 review"
✓ Presentation pushed

  Share ID:  abc123
  Version:   1

# Mint a public viewer URL
$ slideless share abc123
✓ Share URL minted

  Share URL: https://app.slideless.ai/share/abc123?token=...

# Iterate, then re-publish (same presentationId, same URL)
$ slideless push ./deck.html
✓ Presentation pushed to v2

  Share URL: https://app.slideless.ai/share/abc123?token=...
```

Hook this into a CI pipeline, a Makefile, a cron job, or a Claude session. The same loop applies. Add `--json` for machine-readable output that's easy to pipe through `jq`.

## What stays stable across updates

When you re-publish:

| Stays the same                                 | Bumps / accumulates         |
| ---------------------------------------------- | --------------------------- |
| `presentationId` (and therefore the share URL) | `version` (auto-increments) |
| `tokens` (every share token still works)       | `updatedAt`                 |
| `totalViews` (no reset)                        | The HTML content itself     |
| `lastViewedAt` history                         |                             |

Recipients reload to see the new content. View counts on the deck and on each individual token continue from where they left off.

## Why this matters

The loop turns a deck from a **document** (a static artifact you send) into a **URL** (a living resource you maintain). That's the same shift the web made for everything else; Slideless brings it to presentations.

A few practical applications:

* **Sales decks** that get personalized per-prospect (different `tokens` per recipient, different content updates).
* **Product changelogs** that always live at the same URL. Every release just re-publishes.
* **Pitch decks** you tweak after each investor meeting, without recirculating.
* **Workshop materials** that update mid-session as questions come up.

## Send it straight to an inbox

When you do need to hand the URL off, Slideless emails it for you. `slideless share-email <presentationId> --to alice@example.com` ships a branded mail via Resend with a **unique tracked link per recipient**, so you can see who actually opened the deck. Perfect for sales outreach where you'd otherwise BCC a list and never know who read it.

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
slideless share-email abc123 \
  --to alice@example.com --to bob@example.com \
  --message "Here's the deck we discussed." \
  --json
```

Same from Claude Code / Cursor via the `share-presentation-email` plugin skill, or from the dashboard's "Share via email" modal.

See [Send a presentation by email](/guides/sharing-via-email).

## Next

* **[Send a presentation by email](/guides/sharing-via-email)** — CLI, plugin, and dashboard recipes.
* **[Collaboration](/concepts/collaboration)** — Cross-device push/pull, dev collaborators, the conflict model.
* **[Use with Claude](/guides/with-claude)** — Generate the HTML with the marketplace skills.
* **[CLI overview](/cli/overview)** — Why the CLI is the way in.