Claude is building at home. You're at lunch. Peekable turns what it made — a page, a deck, a video ad — into a private link: open it on any device, tap the exact spot that looks off, and leave a note. Your agent picks the note up, with context, and ships the revision.
2 items · ships in 3–5 days
↑ click any element to annotate · widget stays in the corner
Three steps, and two of them aren't yours. Installing the CLI teaches your agent the whole loop — you just type /peekable. Reviewers need no account and install nothing.
Type /peekable in Claude Code or Codex. Installing the CLI installs the skill, so your agent already knows what it's showing and how to share it — a mockup, slides, a report, or the app running on your machine. You get a private link.
Whoever opens the link sees the real page — phone, tablet, laptop. They tap the actual button, heading, or section they mean and leave a note pinned right there. No account, nothing to install, nothing to learn.
Notes flow back to Claude or Codex with the exact element and page attached — so "this button" means this button, not a guess from a screenshot. It revises, pushes the next version, and reviewers always see the latest.
When someone taps and writes a note, Peekable remembers exactly what they tapped — the element, the page, the version. Your agent doesn't decode a screenshot. It knows.
The whole point: you don't have to sit in front of the machine that's building. Be on the train, at lunch, on someone else's couch — the link opens anywhere, and your notes land back in the loop while you're still out.
Every note arrives as structured data, not a screenshot to squint at: the exact element, its selector and text, the page, the version, and who said it. That's why the revision lands on the first try.
Share the link with a teammate and you're both on the same live session. When one of you drops a pin, it lands on the other screen in the same breath — no reload, no "did you see my comment yet?"
◉ Both viewers see every pin as it lands · powered by a live websocket, not polling
Run peekable watch <session-id> in your terminal. When a reviewer submits their annotations, you get a single, clean notification — not a stream of noise for every pin.
◉ watch fires once per submit batch — your agent isn't woken for every pin
Your agent renders an ad, a demo, a motion cut — and pushes it to the same private link. You scrub to the moment, tap the layer that's off, and the note lands with the layer and timestamp attached. It re-renders; the conversation follows that layer into the next cut.
Video feedback used to be "around 7 seconds, the logo thing." Peekable knows the composition — every layer, every scene — so a tap means that layer at that moment, and your agent reads it exactly like page feedback.
Anything your agent can render, you can share — app screens, HTML pitch decks, slides, reports, video ads. And whoever you send it to just taps and types.
Claude is building locally on your desktop. You're at lunch. Peekable lets you peek at the result on your phone, drop a few notes, and walk back into your office to a queued patch.
Send the live thing instead. They click the actual button that's wrong, leave a note, and your agent gets a selector — not a "make this more punchy" Slack DM.
Clients click around, leave sticky notes on the actual thing. No Loom recordings, no "can you make the logo bigger" Slack threads from screenshots — just structured feedback that you (or your agent) can triage in minutes.
QA finds a broken element on Safari iOS. They click it. Peekable captures the element, the browser, the route, the version. Your agent pulls the report and reproduces it on the first try.
Your agent renders the ad and pushes it to the link. You scrub on your phone, tap the logo at 0:07, say "hold this beat longer." It re-renders, pushes v2 to the same link — and the note threads into the next cut.
Installing the CLI installs the skill for Claude Code and Codex. Type /peekable and your agent knows what it's showing, how to share it, and how to pull the feedback into its next loop. No orchestration code, no prompt engineering.
Run peekable proxy <port> and your local dev server gets a public URL routed through Peekable. No deploy, no SSH gymnastics — just send the link.
Reviewers click any element on the page and leave a note. Comments stick to selectors, not pixels.
Every peekable push bumps a version. Reviewers always see the latest, and feedback is pinned to the version it was left on.
Mark comments resolved from the CLI, then push the next version. The loop closes where you live — the terminal — not in another tab.
Each comment carries selector, DOM path, element text, computed styles, bounding box, route, push version, and reviewer name.
Tail new comments as they come in, while your agent is still working. Pipe them straight into the next prompt.
Predictable flags, stable JSON output, no interactive prompts unless you ask. Works with Claude Code, Cursor, Codex, and anything that can shell out.
Set a view secret on any session and reviewers unlock once. Rotate the secret and every existing viewer is kicked out instantly. No restart, no revoke queue.
Point push-url at anything. It won't touch localhost, RFC1918 addresses, or cloud metadata endpoints unless you explicitly opt in. Redirects re-validate. Bodies get size-capped.
Two reviewers open the same share and see each other's pins land in real time over a websocket. No refresh. No "did you see my comment yet?"
Push a rendered video with its manifest. Notes pin to a layer at a moment — and thread across re-renders, because layer IDs stay stable from cut to cut.
The hosted beta runs on Peekable's managed service. We're focusing the first batch on the CLI and support loop, so hosted peekable.fyi is the fastest way in.
Review is half the loop. Studio is where you direct the cut — timeline, layers, re-render from a note. Coming soon.
Full access to the hosted beta. Share live links, get element-pinned feedback, and keep your agent in the loop. No credit card required.
Enter your email and we'll send your access code and a short setup guide. It takes about two minutes, with no credit card and no invite queue.
We sent your access code and setup steps. Create your first share when you're ready.
No inbox required — paste this to Claude Code, Codex, or Cursor and it sets everything up: