Share AI Output

Ninety seconds, end to end: ask for a plan, paste it, share the link, hand the raw URL to an agent.

Most assistants can share a conversation, and for showing someone a chat that is the right tool. It is the wrong tool for handing over a plan.

A conversation link shares the whole conversation — the false starts, the correction three messages later, the part you asked it to redo. The reader has to work out which version is current. What you wanted to send was the final artefact.

It is also tied to your account, lives on their servers under their retention rules, and gives an agent nothing to work with. There is no plain-text endpoint behind it.

1. Copy the markdown from the assistant's response — the copy button on the message, not a text selection.
2. Paste it into the editor here. Use Preview to check it renders the way you expect.
3. Share. You get /p/[id] for people and /p/[id]/raw for machines.

This is the part the chat UIs have no answer for. Every paste has a raw endpoint that serves the original markdown as text/plain — no HTML, no wrapper, no scraping:

curl https://mdbin.sivaramp.com/p/abc123/raw

So the same link works for both audiences. A teammate opens it and reads a rendered document. A coding agent fetches the raw URL and gets exactly the bytes the model produced — no markdown mangled by a copy-paste through three applications.

Raw endpoints are served with a noindex header, and paste pages are not indexed either, so a plan you share does not turn up in search results.

This is a typical response — the file table, the state snippet, the two-pass algorithm, the flowchart, the build checklist. Source on the left, what the link shows on the right.

## Wordle clone — implementation plan

Plain HTML, CSS and JavaScript. No build step, no framework.

### Files

| File | Purpose |
| --- | --- |
| `index.html` | Board markup and on-screen keyboard |
| `styles.css` | Grid, tile flip animation, colour states |
| `game.js` | Game state, guess validation, scoring |
| `words.js` | Answer list and the larger allowed-guess list |

### Game state

```js
const state = {
  answer: pickAnswer(),
  guesses: [],        // committed rows
  current: '',        // row being typed
  status: 'playing',  // 'playing' | 'won' | 'lost'
}
```

### Scoring a guess

Two passes, in this order — one pass gets repeated letters wrong.

1. Mark exact matches green and consume those letters from the pool.
2. Mark remaining letters yellow only if the pool still has them.

```mermaid
flowchart LR
  A[Submit guess] --> B{In word list?}
  B -- no --> C[Shake row]
  B -- yes --> D[Pass 1: greens]
  D --> E[Pass 2: yellows]
  E --> F{Correct?}
  F -- yes --> G[Win]
  F -- no --> H{6 guesses?}
  H -- yes --> I[Lose]
  H -- no --> J[Next row]
```

### Build order

- [x] Static board and keyboard markup
- [x] Typing, backspace and submit
- [ ] Two-pass scoring
- [ ] Tile flip animation
- [ ] Persist the daily result to localStorage

### Accessibility

Announce each result with `aria-live="polite"`. Colour alone cannot carry the
result — add a symbol or pattern for colour-blind players.

const state = {  answer: pickAnswer(),  guesses: [],        // committed rows  current: '',        // row being typed  status: 'playing',  // 'playing' | 'won' | 'lost'}

Most assistants put a copy button on each response, and that button gives you markdown. Selecting the text with a cursor usually does not — you get rich text, and the formatting arrives as HTML or as nothing at all.

If a tool insists on giving you rich text, ask for the output inside a fenced block:

Give me the plan inside a single ```markdown code block
so I can copy it verbatim.

That works in ChatGPT, Claude, Gemini, Grok, DeepSeek, Kimi and anything else that speaks markdown, because it sidesteps the interface entirely and asks the model for the raw form.

Whatever comes out renders here: GitHub Flavored Markdown, fenced code in any of 232 languages, tables, task lists, LaTeX maths and Mermaid diagrams. Output in Chinese, Japanese, Korean or Arabic renders correctly too, which is not a given elsewhere.

A plan often describes something that is not public yet — an unreleased feature, an internal system, a migration with dates attached. Switch the form to Encrypted and the content is encrypted in your browser before it is sent. The server stores ciphertext and never receives the password.

One trade-off worth knowing: an encrypted paste cannot be fetched by an agent, because the raw endpoint returns the encrypted blob and the key never leaves the browser. Encrypt when a human is the audience; leave it public when a machine needs to read it.