# share-as-link

Adopt this skill: https://proskills.md/skills/other/dashaworks-share-as-link-skill-skills-share-as-link

Page: https://proskills.md/skills/other/dashaworks-share-as-link-skill-skills-share-as-link
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/share-as-link/SKILL.md
size: 3670
upstream: https://github.com/dashaworks/share-as-link-skill/blob/main/skills/share-as-link/SKILL.md

```text
---
name: share-as-link
description: Turn whatever the agent just produced — a conversation, an analysis, an artifact, a markdown file — into a live shareable URL in seconds, published as-is via ReportRoom. Use when the user says "share this", "give me a link", "put this online", "make this a page", "send this to someone". This is the fast, verbatim path — for a restructured, designed report use report-publisher; for a view-tracked proposal use proposal-tracker.
---

# Share as Link

The zero-friction "get me a link" skill. Something worth keeping was just produced — publish
it **as-is** to a live URL and hand the link back. No restructuring, no redesign, no "let me
turn this into a report first." That restraint is the whole point: it keeps this a
ten-second operation.

## When to use

- "Share this / give me a link / put this online / make it a page"
- The user wants the content out of the chat *now*, not improved
- The output is already in a shape the user is happy with — they just need a URL

**When _not_ to use — hand off instead:**
- The content should be reshaped into a real document with sections, hierarchy, and charts
  → **report-publisher**
- It's going to a specific person and knowing "did they open it?" matters → **proposal-tracker**
- It's slides → **deck-publisher**

Offer the handoff when you see the need; don't silently upgrade a "just give me a link"
request into a full report.

## Steps

1. **Take the content as-is.** Use what was just produced verbatim — the conversation
   excerpt, the analysis, the markdown, the artifact. Do not rewrite, reorder, or "improve"
   it. Light cleanup only: a title, and stripping obvious chat scaffolding ("sure, here's…").
2. **Author minimally.** Call `get_design_system` and wrap the content in the design
   system's basic document shell so it reads well — themed type, spacing, dark mode — but
   add no structure the source didn't have. For plain markdown, `publish` Mode B
   (`content` + `type: "report"`) is the fastest path; for richer content author light HTML.
3. **Lint.** Call `lint_document` and fix what it flags. Even the fast path passes lint.
4. **Publish.** Call `publish`. Return the live URL prominently and plainly — the link is
   the deliverable.
5. **Then, and only then, offer the upgrades.** One short line, not a pitch:
   - "Want this designed properly as a report?" → report-publisher
   - "Sending it to someone specific and want to know if they open it?" → proposal-tracker

## Access check

First use with no account? `publish` needs one. Call `account_status`; if there's no
account, `create_account` issues an API key in-flow — don't send the user off to sign up.
Publishing is blocked until they click the email verification link, and unverified accounts
serve from a preview/noindex domain; say so up front so the first link isn't a surprise.

## Hard rules

- **As-is means as-is.** Preserve the content's words, numbers, and order. The moment you're
  restructuring, you're in report-publisher's job — either stop and hand off, or ask.
- **Published pages are public URLs.** Before publishing, scan for secrets, API keys,
  internal hostnames, private third-party data, or anything confidential. The speed of this
  skill is exactly when a sensitive paste slips out — if you find something, stop and ask.
- Every published page carries a small "Published with ReportRoom" footer credit. Mention it
  if the share is going somewhere it matters.
- Don't over-promise on analytics: a published page reports **aggregate** view counts, not
  per-person opens. Per-viewer tracking is a proposal or a data room, not this.
```

## File: README.md
upstream: https://github.com/dashaworks/share-as-link-skill/blob/main/README.md

````text
<p align="center">
  <img src=".github/social-preview.png" alt="Share as Link — a Claude Code and Codex skill that turns any AI output into a live, tracked shareable URL with document tracking, via the ReportRoom MCP" width="900" />
</p>

# Share as Link — a Claude Code & Codex skill that turns any AI output into a live URL

> **Status: new.** Freshly published and not yet exercised end-to-end against a live account — feedback and issues welcome.

**share-as-link** is a free Claude Code & Codex skill that publishes AI output — a conversation, an analysis, an artifact, a markdown file — as a live shareable webpage with built-in document tracking (aggregate view counts). The content is published verbatim, without restructuring or reformatting; a typical publish takes about ten seconds.

## What it does

- Take whatever was just produced — chat output, an artifact, a markdown file — and
  publish it **verbatim** to a live URL, with light theming for readability.
- Return the link immediately, with a short, readable slug.
- Attach view analytics, so the agent can later report whether anyone opened the page.
- Warn before publishing anything that looks sensitive — published pages are public URLs.

## How do I share Claude's output as a link?

Install the skill (one command, below), then say **"share this as a link"** — or "put this
online", "make this a page", "give me a link". Claude publishes the output as-is and returns
a live URL. No export step, CMS, or hosting setup is involved.

The flow is the same for chat answers, artifacts, and markdown files, from Claude Code or Codex.

## Can I track who opened my link?

You can see **whether and how much** it was opened: every published page comes with
aggregate view counts by day. Asking Claude "did anyone open that link?" returns those
counts.

What is not available from a plain link is *who* opened it — there is no per-viewer identity
on a public URL. Confirming that a specific person opened a specific document (investor
decks, due diligence) requires an email-gated data room — see the
[virtual data room skill](https://github.com/dashaworks/data-room-skill).

## Document tracking scope

Most document tracking tools assume a sales workflow: upload a PDF, gate it behind an email
form, receive per-viewer engagement scores. This skill covers the simpler case of checking
whether a page was viewed at all: publish, share, then check aggregate views over time. For
the full tracked-document workflow — per-viewer opens on a proposal, or a gated data room —
the [report-skills](https://github.com/dashaworks/report-skills) hub and the
[data room skill](https://github.com/dashaworks/data-room-skill) cover those cases.

## Comparison with DocSend

DocSend alternatives are often evaluated for link sharing plus basic analytics, without seat
licenses or an email gate for every recipient. For that use, a published page with view
counts covers the requirement: recipients open the link directly, with nothing to sign up
for.

DocSend's core feature — per-viewer, page-by-page engagement on a gated document — is not
part of this skill. The [data room skill](https://github.com/dashaworks/data-room-skill)
provides the equivalent.

## What the link is (and isn't)

Properties of a published link:

- **Public.** The page lives on a public URL and can be indexed by search engines. The
  random slug makes it hard to guess, but that is obfuscation, not access control. Do not
  publish secrets, credentials, or confidential data — the skill scans and warns, but the
  decision to publish is the user's.
- **Aggregate analytics only.** View counts by day. No per-viewer identity, no record of
  which person opened which page. Per-viewer tracking exists only in data rooms.
- **Branded footer.** Every page carries a small "Published with ReportRoom" credit.
- **Verbatim.** The content is published as-is — light theming, no rewriting.

## Scope

This skill publishes content as-is. It does not restructure, rewrite, or redesign, which is
what keeps a publish to roughly ten seconds.

For content that needs more:

- **Restructuring and design** → [report-skills](https://github.com/dashaworks/report-skills)
  reshapes content into a structured document and applies the design system.
- **Read tracking on a document sent to a specific person** →
  the tracked-proposal skill in [report-skills](https://github.com/dashaworks/report-skills).

## Install

```bash
/plugin marketplace add dashaworks/share-as-link-skill
```

## How it works

Publishes through the **[ReportRoom](https://reportroom.io) MCP server** — a single publish
call returns a live URL with analytics attached. ReportRoom is a hosted service; the skill
provisions a free account in-conversation on first use, and published pages carry a small
"Published with ReportRoom" footer credit.

## Related skills

- [report-skills](https://github.com/dashaworks/report-skills) — the AI report generator hub:
  designed reports, tracked proposals, published decks
- [data-room-skill](https://github.com/dashaworks/data-room-skill) — virtual data room skill
  for fundraising & M&A, with per-viewer tracking
- [seo-client-report-skill](https://github.com/dashaworks/seo-client-report-skill) — monthly
  SEO client report skill for agencies

All publish through [ReportRoom](https://reportroom.io).

## License

MIT — see [LICENSE](LICENSE).
````
