Click through your app once. Get the walkthrough.
1ShowcaseTool records a real session, destroys every credential on screen before it reaches disk, and hands the trace to an AI agent that writes the step-by-step guide. Markdown, a single HTML file, or an MP4 — all of it on your machine.
Free forever tier · $29 one-time to unlock everything · No subscription
Illustration of the app — not a screenshot.
Setup guides are written about software instead of derived from it.
That one root cause produces two different kinds of pain, and both of them land on you.
A 20-step setup across three unfamiliar consoles
Creating an OAuth app, generating an API key, wiring a service account. People abandon somewhere around step 12 and blame the product they were trying to set up.
Docs that quietly stop being true
You screenshotted the flow once. Then the portal was redesigned, a field was renamed, a button moved. Nobody notices until the support ticket arrives.
1ShowcaseTool starts from the recording. The steps are what actually happened, the screenshots are the screens you actually saw, and the marks point at the controls you actually clicked.
Four steps, and only one of them is yours.
You do the clicking and the review. The app does the capture, the writing and the rendering.
Record
Chrome extension · desktop window captureClick through the flow once, in your real browser or against a single desktop window. Every click, keystroke and navigation is captured with a screenshot and an ordered list of selectors — not one brittle CSS path, a ranked set that survives a redesign.
Redact
Blocking gate · no undoPassword fields, key-shaped strings and anything named like a secret are destroyed at capture time, inside the page, before the bytes reach disk. Then you do a review pass: paint over regions, mask a value everywhere it appears, drop whole steps.
Generate
Claude Code CLI · or bring your own keyYou press the button — nothing runs on its own. The redacted trace goes to a local agent CLI if you have one, or to your own API key if you don't, and comes back as a guide with a title, prerequisites, and a body for every step.
Ship
4 formats · offline · yours to hostExport to Markdown for the repo, a single self-contained HTML file for email, an animated walkthrough, or an MP4. Add extra languages and each one becomes its own guide, so a bad translation can be deleted without touching the original.
Not everything worth documenting is a web page.
Two recorders, one guide format. They never run at the same time, and each side refuses to start while the other is going.
The Chrome extension
For anything that lives on the web — a cloud console, a DNS provider, your own admin panel. It captures inside the page, so it knows what element you clicked, what it was called, and where its box sat on screen.
- Ordered selector candidates, plus an accessibility anchor
- Cropped screenshots around the target, full page at boundaries
- Credential destruction runs in the page, before capture
- Talks to the app over a token-authed 127.0.0.1 relay — never the open internet
The machine recorder
For the things that aren't a web page — an installer, a native preferences pane, a terminal. It captures one window you pick, never the whole screen, and the app refuses to hand it a screen source at all.
- Window-scoped capture, enforced in the main process
- A blocklist keeps password managers and keychains out of the picker
- No DOM means no automatic redaction — so the review gate gets stricter, not looser
- Desktop guides are never replayable, and three separate layers enforce it
You are recording a screen with live credentials on it.
That is the whole reason the setup flow was hard to document in the first place. Two layers, and the second one is a gate rather than a setting.
The secret never reaches disk
Runs in the content script before any bytes leave the page. Password, card and one-time-code fields are never stored. Fields named like a secret lose their value. Known key shapes — sk-, ghp_, AIza, xoxb-, a PEM header — are recognised in visible text, and the matching pixels are filled in the bitmap before it is ever encoded.
And a human looks anyway
Recording stops, the review screen opens, and generation, export and publish are all locked until you acknowledge it. Paint over a region. Mask a value and give it a name — every occurrence across every step and screenshot goes with it. Drop steps that should not exist. Save a rule so next time it is caught for you.
Fill, never blur
Blur is a visual effect. Short strings have been recovered from heavy blur before. Redaction here writes solid opaque pixels over the stored image, and there is no unredact.
Only redaction writes to a screenshot
Annotations are coordinates drawn at render time, never baked into the stored file. A mark that could be baked in could be moved onto a secret — and then removed by nobody.
The model never sees it either
Redaction runs before generation, so whatever ran the writing — a local CLI or someone else's API on your key — was handed the redacted trace and nothing else.
Zero warnings is not a green light
On a desktop recording there is no field name to inspect, so the warning count means nothing. The review screen says so in those words, and refuses your acknowledgement until you have viewed every kept step.
One recording, four ways to ship it.
Same guide underneath. The video and the walkthrough can show nothing the Markdown could not — they are renderers, not a second pipeline.
Markdown
Commit it to the repoPlain, reviewable, diffable. Annotated copies of the screenshots are composited beside the file, because Markdown cannot overlay anything and the stored image is never touched.
Self-contained HTML
Email it, or host it yourselfOne file. Every screenshot inlined as a data URI. Works offline, forever, with nothing of ours involved. You can share guides for the rest of time without paying us — that is what makes one-time pricing honest.
Animated walkthrough
Show the flow, no dependenciesAn HTML document with a real animation timeline — push-in on each screenshot, marks appearing on cue, captions. Needs nothing installed and covers the same ground as the video.
MP4
Post it where video wins16:9, square or vertical, 720p or 1080p, 24/30/60fps. Rendered by seeking a paused timeline frame by frame, so the output is identical on any machine. Needs FFmpeg — and when it is missing the app says so instead of failing quietly.
Annotations
Arrows and boxes land on the element's measured box, from the recording. The model never places a mark — a hallucinated arrow points confidently at the wrong control.
Languages
Each extra language is generated as its own complete guide. Selectors, URL patterns and placeholders are never translated.
Customisation
Mark style, video preset, tone and audience are saved per session, so regenerating gives you the same look.
Where this actually differs.
Plenty of tools will record your clicks and write them up. The column that matters is where the recording goes afterwards.
Scroll the table sideways →
| 1ShowcaseTool | Cloud recorders | Writing it by hand | |
|---|---|---|---|
| Records the flow for you | |||
| Runs entirely on your machine | |||
| Recording never uploaded to anyone's server | |||
| Credentials destroyed before capture, not after | Varies | Your problem | |
| A review pass you cannot skip | |||
| Records desktop windows, not just the browser | Some | ||
| Markdown you can commit to the repo | Export add-on | ||
| One HTML file that works offline forever | |||
| Video without a separate editing pipeline | Some | ||
| Uses your own AI account, not a metered credit pool | — | ||
| Pricing | $29 once | Per seat, per month | Your afternoon |
“Cloud recorders” is the category — Scribe, Tango, Guidde and the rest. They are good at what they do; they are also SaaS, per seat, and your recording is on their servers. Behaviour varies by product and by plan.
Not shipped yet. Worth knowing about.
Everything above this section is in the app today. Everything in it is not — listed here because it is where the product is going, and because a roadmap dressed up as a feature list is how landing pages start lying.
Attach a repository
Point the app at the source behind the flow and regenerate — the trace is kept, so nothing needs re-recording. Steps gain the reason they exist and the real config key from the code, rather than whatever the UI label happened to say.
Guides that notice they went stale
With source references on each step, a diff since the recorded commit tells you which steps the change broke — a CLI check and a CI job that comments on the pull request that broke them, rather than a support ticket six weeks later.
Supervised replay
The overlay watches whether the reader actually performs the step, re-anchors the arrow on a wrong click, and offers to send a generated value straight into the field it belongs to — over localhost, on explicit confirmation, every time.
Start free. Pay once when it earns it.
No subscription, no credit card, no trial clock. Redaction is in every tier including the free one — it is a safety feature, and charging for it would be indefensible.
- 3 guides, no time limit
- Both recorders — browser and desktop
- The full redaction suite, gate included
- Markdown and self-contained HTML export
- Unlimited guides
- Every exporter — walkthrough and MP4 included
- Annotation styling, video presets, extra languages
- Attach a repo and drift detection as they land
Bring your own AI account — we never charge for model usage, and we never run generation without you pressing the button.
Frequently asked questions
Does my recording get uploaded anywhere?
No. Sessions, screenshots and guides live in a local SQLite database and on your disk; credentials go to the OS keychain. Nothing leaves the machine unless you explicitly export or publish a guide. The browser extension talks to the app over a token-authed 127.0.0.1 relay that refuses any request whose origin is not the extension itself, and pairing requires you to click Allow in the app window.
What stops a password ending up in a screenshot?
Two layers. The first runs inside the page before any bytes are captured: password, card and one-time-code fields are never stored, fields named like a secret lose their value, and known key shapes are filled with solid pixels in the bitmap before it is encoded. The second is a review pass you cannot skip — generation, export and publish are all blocked until you acknowledge it. Fills are opaque rectangles rather than blur, because blur is a visual effect and short strings have been recovered from it.
Can I get a redaction back if I make a mistake?
No, and that is deliberate. Redaction overwrites the pixels and values in the stored artifact rather than hiding them behind an overlay. There is no unredact. If you paint over the wrong thing, you re-record.
Do I need an API key, or does the app include AI?
You bring your own. If you have the Claude Code CLI installed the app finds it and uses it, so generation runs on the plan you already pay for. If you don't, paste an API key — Anthropic, OpenAI, Gemini, Azure OpenAI, or anything OpenAI-compatible. The app never bills you for model usage and never runs generation on its own; you press the button.
Can it record things that aren't in a browser?
Yes. Alongside the Chrome extension there's a desktop recorder that captures a single window you choose — never the whole screen, and the main process refuses a screen source outright. A blocklist keeps password managers and keychain windows out of the picker. Because there's no DOM, there is no automatic redaction on a desktop recording, so the review gate gets stricter instead: you cannot acknowledge it until you have viewed every step you kept.
What can I export, and does anything need installing?
Markdown for the repo, a self-contained HTML file with every screenshot inlined as a data URI, an animated HTML walkthrough, and MP4. Only the MP4 needs anything extra — FFmpeg, used if your system has it. When it's missing the app tells you rather than failing quietly, and the animated walkthrough covers the same ground with no dependency at all.
Where do the arrows and boxes come from?
From the recording. The element's box inside its own screenshot is measured at capture time, and marks are drawn there. The model is never asked to place one — a hallucinated arrow points confidently at the wrong control, which is worse than no arrow. A step with no measured target, like a plain navigation, gets a corner badge instead.
Can I produce the guide in more than one language?
Yes. Each extra language is generated as its own complete guide rather than a field inside one, so every export, preview and progress record works unchanged, and a translation that comes out wrong can be deleted without touching the original. Selectors, URL patterns and placeholders are never translated.
Which platforms does it run on?
macOS and Windows today. There is no Linux build yet. The desktop recorder on macOS needs the system Screen Recording permission, which macOS ties to the app's code signature.
Is the repo-linked mode available?
Not yet. Attaching a repository — so each step gains the reason it exists, the real config key from the code, and references back to the source that make staleness detectable — is the next milestone, along with the drift check and its CI job. It is on the roadmap section above, not in the app today. When it lands, existing guides upgrade in place: the recorded trace is kept, so you re-generate rather than re-record.
What does the one-time price actually cover?
Unlimited guides, every exporter, and 12 months of updates. After that the app keeps working — you just stop receiving new versions unless you renew. The free tier is not a trial: three guides, both recorders, the complete redaction suite, and Markdown plus HTML export, with no time limit.
How is this different from Scribe or Tango?
Mostly in where the recording goes. Those are cloud SaaS priced per seat per month, and your capture is on their servers. This runs on your machine, stores nothing remotely, destroys credentials before they reach disk, records desktop windows as well as browser tabs, and gives you a Markdown file you can commit and a single HTML file that works offline forever. If you want a hosted team library with view analytics, they are genuinely better at that today.
Click through it once.
The recording becomes the guide. The credentials never reach disk. The whole thing stays on your machine until you decide otherwise.
Free forever tier · $29 one-time to unlock everything · No subscription