DEV Community: SHOTA

How to Write a Bug Report That Won't Get Sent Back

SHOTA — Wed, 05 Aug 2026 16:04:51 +0000

Every developer has received the bug report that just says "the save button is broken." No steps, no screenshot, no browser — so the first reply is always the same: "Can you reproduce it? What did you click?" A round-trip later, you finally have enough to start.

A good bug report answers those questions before they're asked. Here's what to include, and a faster way to capture it.

What a reproducible bug report needs

Whoever picks up the bug should be able to trigger it without messaging you. That means:

Steps to reproduce — the exact clicks, in order, from a known starting point
Expected vs. actual — what should happen, what actually happened
Screenshots — the state at each meaningful step, and the failure
Environment — browser, OS, and the URL or build

The steps and screenshots are the part people skip, because capturing them by hand is tedious.

The manual way (and where it breaks down)

The usual flow: reproduce the bug, take a screenshot at each step with your OS shortcut, crop each one, paste them into the issue, and write out the steps from memory. It works, but it's slow, and "from memory" is where steps get dropped — you forget the filter you'd set three clicks ago that actually triggers the bug.

A faster way: Procshot

Procshot is a free Chrome extension that records what you do in the browser and turns it into a step-by-step guide — one screenshot and one written step per action.

For a bug report:

Click record, then reproduce the bug exactly as it happens
Stop recording — you now have every click captured as a numbered step with a screenshot
Annotate the failure screenshot with an arrow or box (and blur anything sensitive)
Export to Markdown and paste straight into a GitHub / GitLab issue, or PDF for a ticket

Because Procshot captures each click as you go, you can't forget a step — the repro is the recording.

Why Markdown export is the useful part

A Markdown export drops into an issue tracker with the steps and images already formatted. The person triaging reads a numbered repro instead of a paragraph, and they can follow it without asking you anything.

One honest note: Procshot makes screenshot-based guides, not video. For a bug report that lives in an issue and needs to be read, numbered screenshots beat a screen recording someone has to scrub through.

Pricing

Free: 5 guides per month, all export formats, all annotation tools
Pro ($4.99/month): unlimited guides, custom branding, PDF templates, priority support

Install

Free, no Procshot account — your guides are built and stored in your browser (IndexedDB).

→ Install free: https://dev-tools-hub.xyz/extensions/procshot/?utm_source=dev.to&utm_medium=referral&utm_campaign=write-a-reproducible-bug-report

Chrome Web Store: https://chromewebstore.google.com/detail/procshot/ieblehdloggcpmkncplccjofeoakhkll

What's the one thing you wish every bug report included? For me it's the exact starting URL — half of "can't reproduce" is starting from the wrong place.

Built by S-Hub — minimal, MV3-native Chrome extensions.

Pocket Shut Down — Here's How to Actually Resume Reading Long Articles

SHOTA — Tue, 04 Aug 2026 16:15:12 +0000

Mozilla shut Pocket down. The apps and the website stopped working on July 8, 2025, the extensions were pulled from stores back in May 2025, and the export window for your saved list closed in October 2025. (Mozilla's own support page has the timeline.)

If you were a Pocket user, you're probably looking for a "Pocket alternative" right now. Before you migrate your whole workflow, it's worth separating what Pocket actually did for you — because most people used it for one job, and that job has a much lighter solution.

What did you really use Pocket for?

Pocket bundled several things:

A save-for-later queue — a place to stash articles you'll read someday
Cross-device sync of that queue
Offline reading and a clean reader view
Not losing your place in a long piece you started

Be honest about which of these you actually used. For a lot of people, the queue filled up with hundreds of links they never returned to, and the real day-to-day value was #4: opening a long article, getting interrupted, and being able to pick up where they left off.

If you need the full archive-and-offline experience, there are heavier read-later apps that replace all of Pocket. But if what you miss is not losing your spot, you don't need to rebuild your whole reading stack — you need a bookmark that remembers your scroll position.

The manual ways (and where they fall short)

Chrome gives you a few half-measures:

Ctrl/Cmd+F the last sentence you remember — if you remember it, and if it's unique on the page.
A normal bookmark saves the page, not your position. You still land at the top and scroll.
Highlighter extensions work, but only if you remember to highlight before you get pulled away. Interruptions don't announce themselves.

They all share the same flaw: they need you to act ahead of the interruption.

The lightweight option: ReadMark

ReadMark is a free Chrome extension that saves your scroll position automatically, so reopening a page drops you back exactly where you stopped.

Automatic saving — it records your reading position as you scroll; there's no button to remember to press
One-click return — jump back to the saved spot, with a visual marker showing where you left off
Per-page tracking — positions are saved per URL, so a dozen half-read tabs each remember their own place
Kept in your browser — your positions live in local browser storage; with Pro they sync across your own devices through Chrome sync, and no ReadMark account is required

Honest scope: ReadMark is not a Pocket clone. It doesn't keep a save-for-later queue, download articles for offline reading, or give you a reader view. It does one thing — pick up long reads where you left off — and stays out of your way. If that was your real Pocket use case, it's a much lighter replacement than a full read-later app.

Free vs Pro

The free plan covers the core loop: save your position on up to 10 pages and jump back with one click.

ReadMark Pro unlocks unlimited saved positions plus folders, full-text search across everything you've marked, and export/import — $4.99/month, with a 7-day free trial if you want to try it first.

Install

Free, no ReadMark account — your reading positions stay in your browser, and Pro syncs them across your devices via Chrome.

→ Install free: https://dev-tools-hub.xyz/extensions/readmark/?utm_source=dev.to&utm_medium=referral&utm_campaign=read-later-after-pocket-resume-reading

Chrome Web Store: https://chromewebstore.google.com/detail/readmark/inejhohffndeacbihghjcobndpoejdfn

Now that Pocket's gone — are you rebuilding a full read-later queue, or did you mostly just want to stop losing your place?

Built by S-Hub — minimal, MV3-native Chrome extensions.

How to Stop Leaking Sensitive Data into ChatGPT

SHOTA — Mon, 03 Aug 2026 16:28:23 +0000

You paste a customer's email into ChatGPT to draft a reply. You drop a real stack trace with an internal hostname into Claude to debug it. You ask Gemini to summarize a document that happens to have someone's name and phone number in it. None of it felt like a leak in the moment — but that data left your machine and went to a third-party model.

For a lot of teams, "don't paste sensitive data into AI tools" is the policy. In practice, people paste anyway because redacting by hand is annoying. Here's how to make redaction automatic.

Why manual redaction fails

The manual approach is: read your prompt, find the names, emails, and IDs, replace them with [NAME] / [EMAIL], then send. It works right up until you're in a hurry — and that's exactly when the customer's real email address slips through. Relying on "remember to redact every time" is relying on the weakest possible control.

Option 1: a redaction checklist (better than nothing)

Keep a checklist of what to strip — names, emails, phone numbers, API keys, internal URLs — and run through it before every prompt. It raises your hit rate, but it's still manual, and it slows you down enough that people quietly stop doing it.

Option 2: PromptStash (PII masking on insert)

PromptStash is a Chrome extension for saving and inserting prompts across ChatGPT, Claude, Gemini, and Perplexity. Its Pro tier includes PII masking: it detects and strips personal data — names, emails, and similar — from your prompt before it goes to the model.

I turned this on after catching myself about to paste a real support email into a chat window to "just draft a quick reply." The masking is the seatbelt for the moment you're moving too fast to think about it.

The workflow stays the same as always — write your prompt, insert it — except the sensitive tokens are masked on the way out, without you having to remember. It removes the "I forgot" failure mode, which is the one that actually bites.

Free vs Pro

Free: up to 10 saved prompts, folders, and variables
Pro ($5.99/mo): unlimited prompts and folders, prompt chaining, a prompt quality score, PII masking, and import/export

PII masking is the reason to go Pro if your prompts ever touch customer or employee data — one masked email that would otherwise have shipped to a third party pays for it.

Install

Free, no PromptStash account, and it works across ChatGPT / Claude / Gemini / Perplexity.

→ Install free: https://dev-tools-hub.xyz/extensions/promptstash/?utm_source=dev.to&utm_medium=referral&utm_campaign=stop-leaking-sensitive-data-into-chatgpt

Chrome Web Store: https://chromewebstore.google.com/detail/promptstash/ocgkponbnolpgobllplcamfobolbjbcj

How does your team handle sensitive data in AI tools right now — a policy, a tool, or mostly trust?

Built by S-Hub — minimal Chrome extensions for productivity.

How to Block YouTube Shorts on Desktop (Feed, Search & Homepage)

SHOTA — Sat, 01 Aug 2026 15:04:05 +0000

You open YouTube to watch one thing, and the Shorts shelf is right there on the homepage, then again in your subscriptions feed, then again when you search. It's engineered to pull you sideways, and "I'll just watch one" turns into fifteen minutes gone.

YouTube doesn't give you a real off switch for this on desktop. Here's what you can do manually, and a cleaner way to just remove them.

What YouTube lets you do (not much)

Your built-in options are weak:

"Not interested" on a Short — it hides that one, and three more take its place.
Watch history off / pausing recommendations — thins things out but doesn't remove the Shorts shelves.
There's no setting that says "hide Shorts on desktop." That's the gap.

So manually, it's whack-a-mole. The shelves keep coming back because removing them isn't in YouTube's interest.

The cleaner way: ShortsKiller

ShortsKiller is a Chrome extension that removes YouTube Shorts from the places they show up on desktop:

Homepage — no Shorts shelf when you open YouTube
Subscriptions / feed — Shorts rows stripped out of your feed
Search results — Shorts filtered out of what you searched for

It also tracks your screen time on YouTube, so you can see the before/after — the point isn't just hiding a UI element, it's getting the minutes back.

I built this because the "just watch one" loop was the exact trap I kept falling into. Removing the shelf entirely worked where "not interested" never did — you can't tap into what isn't on the page.

Install

→ Install free: https://dev-tools-hub.xyz/extensions/shortskiller/?utm_source=dev.to&utm_medium=referral&utm_campaign=block-youtube-shorts-on-desktop

Chrome Web Store: https://chromewebstore.google.com/detail/shortskiller/bajebpkjihldiceceompbcjgepnbhnni

Do Shorts actually pull you off track, or do you scroll past them fine? Curious where people land on this.

Built by S-Hub — minimal, MV3-native Chrome extensions.

How to Create Step-by-Step Guides with Screenshots for Free (Scribe Alternative)

SHOTA — Fri, 31 Jul 2026 16:04:28 +0000

If you've ever written a "how to do X" doc — a bug repro, an onboarding SOP, a code walkthrough — you know the tedious part isn't the words. It's the screenshots. Take a shot, crop it, draw an arrow, paste it, repeat for step 7, realize you missed a click, redo half of it.

Tools like Scribe automate this, but the popular ones send your captures to their servers and gate the basics behind an account. Here's how to make illustrated step-by-step guides that stay in your browser — the manual way, and a faster free option.

The manual way (screenshots + a doc)

You can do this with zero tools:

Press your OS screenshot shortcut on each step
Crop each image
Drop them into a doc, in order
Annotate the important spot (arrow or box) in an image editor
Write the caption for each step

It works for a 3-step guide. Past that it falls apart: renumbering when you insert a step, re-shooting when the UI changes, and keeping 15 loose PNGs in sync with 15 captions. I gave up on this for anything longer than a quick Slack message.

The faster way: Procshot

Procshot is a free Chrome extension that records what you do in the browser and builds the guide for you.

Click the toolbar icon and hit record
Do the task normally — click, type, navigate
Stop recording

Procshot auto-captures each click, form input, and navigation, and turns it into an illustrated step-by-step guide — screenshot plus a written step for every action, no manual capturing.

Then you can:

Annotate screenshots with arrows, boxes, blur (for hiding secrets), and text labels
Export to PDF (4 templates), Markdown (drops straight into Notion / Confluence / GitHub Wiki), or a self-contained HTML file
Keep it local — your guides are stored in your browser (IndexedDB); no Procshot account required

Where it earns its place

Bug reports — record the repro once, export a numbered guide with exact steps
Onboarding SOPs — "how to set up the dev environment" without re-shooting every quarter
Code walkthroughs and handoffs — a Markdown export that lives next to the code
Support docs — a clean PDF you can hand a customer

One honest scope note: Procshot makes screenshot-based guides, not video. If you specifically need a screen recording, it's the wrong tool. For written docs that people actually skim, screenshots-with-steps beat a 4-minute video most of the time — and this is the part I use it for the most.

The blur tool is the underrated one. I annotate a guide with real data on screen, blur the account name, and export — no separate editor.

Pricing

Free: 5 guides per month, all export formats, all annotation tools
Pro ($4.99/month): unlimited guides, custom branding, PDF templates, priority support

Install

Free, no Procshot account — your guides are built and stored in your browser.

→ Install free: https://dev-tools-hub.xyz/extensions/procshot/?utm_source=dev.to&utm_medium=referral&utm_campaign=create-step-by-step-guides-screenshots

Chrome Web Store: https://chromewebstore.google.com/detail/procshot/ieblehdloggcpmkncplccjofeoakhkll

What do you use to document a repro or an SOP today — screenshots by hand, a screen recorder, or something else?

Built by S-Hub — minimal, MV3-native Chrome extensions.

The Best EditThisCookie Replacement in 2026: What to Actually Look For

SHOTA — Thu, 30 Jul 2026 15:52:01 +0000

EditThisCookie was the default cookie editor for a decade. Then Manifest V3 landed, Chrome retired the old Manifest V2 platform, and editors that weren't rebuilt for MV3 quietly stopped working. If you're searching for a replacement in 2026, the field is smaller than it looks — a lot of "cookie editor" results are still MV2 extensions that will break (or already have).

Instead of just handing you a link, here's the checklist I'd use to pick one, and where I landed.

What a 2026 cookie editor actually needs

1. MV3-native. This is non-negotiable. If an extension still relies on persistent background pages, it's living on borrowed time. Check that it's been updated recently and describes itself as Manifest V3.

2. Fast inline editing. The whole point of a dedicated editor over DevTools is speed: see every cookie for the current tab, click one, change the value/expiry/flags, done — no digging through nested panels.

3. Import / export. JSON for tooling, Netscape cookies.txt for curl/yt-dlp and other scripts. If you move sessions between environments, this is the feature you'll use most.

4. Sane defaults, minimal permissions. A cookie editor needs the chrome.cookies API and host access to do its job — but it shouldn't ask for more than that. Fewer permissions, smaller attack surface.

5. Honest about browser limits. No tool can edit HttpOnly cookies — that's a browser security rule, not a feature gap. Be suspicious of anything that claims otherwise.

The baseline: Chrome DevTools (no install)

Before installing anything, know that DevTools has a built-in editor:

Right-click the page → Inspect
Application tab → Storage → Cookies
Select the domain, double-click a row to edit

It's always there and it's trustworthy. But it's slow for repeated use: no quick filtering by cookie type, no one-click export, and every edit is several clicks deep in a small panel. Fine for a one-off; painful for a testing loop.

Where I landed: CookieJar

CookieJar is a free, Manifest V3 cookie editor built as a direct alternative to EditThisCookie. Against the checklist:

Criterion	CookieJar
MV3-native	✅ Built for current Chrome
Inline editing	Click the toolbar icon → click a cookie → edit value/expiry/flags, applies immediately
Auto-labeling	Cookies grouped by domain and tagged (Login / Tracking / Analytics / Functional)
Import / export	JSON and Netscape (`cookies.txt`)
Delete single cookie	One click
`HttpOnly`	Viewable and deletable, not editable — same browser rule as every tool

Everything above is free. CookieJar Pro ($4.99/month, or $29.99 one-time) adds automatic cookie-cleanup rules, saved cookie profiles, and a storage manager — useful if you're constantly resetting state across projects.

Honest scope: CookieJar focuses on editing, organizing, and moving cookies. It's not a network-request tool — if you need to rewrite response headers, that's a different category of extension. For the core "I need EditThisCookie back" job, though, it covers the workflow.

Why the checklist matters for testing

Auth flows — flip session state without creating throwaway accounts
New vs. returning user — clear specific cookies while keeping the rest
Login loops — nuke a stale session cookie in two clicks
Flag verification — confirm Secure / HttpOnly / SameSite at a glance

Install

CookieJar is free and needs no CookieJar account. Your cookies and saved profiles stay in local browser storage — CookieJar never uploads them.

→ Install free: https://dev-tools-hub.xyz/extensions/cookiejar/?utm_source=dev.to&utm_medium=referral&utm_campaign=editthiscookie-replacement-2026

Chrome Web Store: https://chromewebstore.google.com/detail/cookiejar/lhngfkchfepfjjdfhimconagoejemofg

What was the one EditThisCookie feature you can't work without — inline editing, export, or the auto-grouping?

Built by S-Hub — minimal, MV3-native Chrome extensions.

How to Resume Reading a Long Article Where You Left Off

SHOTA — Wed, 29 Jul 2026 15:52:43 +0000

You're halfway through a long article or a docs page, you close the tab (or the browser eats it), and later you're back at the top — scrolling, skimming, hunting for the paragraph you'd reached. For a 4,000-word piece that's a real interruption, and it happens every day across dozens of tabs.

Here's how to pick up exactly where you left off — the manual way, and an automatic one.

The manual ways (and where they fall short)

A few built-in tricks get you partway:

Ctrl/Cmd+F the last sentence you remember — if you remember it, and if it's unique on the page.
Browser bookmark — but a bookmark saves the page, not your position. You still land at the top.
Highlighter extensions — good for marking, but you have to remember to highlight before you leave.

They all share the same flaw: they need you to do something before you get interrupted. Interruptions don't announce themselves.

The automatic way: ReadMark

ReadMark is a free Chrome extension that saves your scroll position automatically, so returning to a page drops you back where you stopped.

Automatic saving — it records your reading position as you go; no button to remember to press
One-click return — jump back to the saved spot instantly, with a visual marker showing where you left off
Per-page tracking — positions are saved per URL, so 12 half-read tabs each remember their own place
Stored in your browser — your reading positions are kept in local browser storage; with Pro, they sync across your own devices through Chrome sync. No ReadMark account required.

The per-URL part is what makes it usable in practice. I keep a pile of long docs open across a week; each one just remembers, independently.

Free vs Pro

The free plan covers the core loop: save your position on up to 10 pages and jump back with one click.

ReadMark Pro unlocks unlimited saved positions plus folders, full-text search across everything you've marked, and export/import — $4.99/month, with a 7-day free trial if you want to try it first.

Install

Free, no ReadMark account — your reading positions are kept in your browser, and Pro syncs them across your devices via Chrome.

→ Install free: https://dev-tools-hub.xyz/extensions/readmark/?utm_source=dev.to&utm_medium=referral&utm_campaign=resume-reading-where-you-left-off

Chrome Web Store: https://chromewebstore.google.com/detail/readmark/inejhohffndeacbihghjcobndpoejdfn

How do you get back to your spot in a long read right now — Ctrl+F, a highlight, or just re-skimming?

Built by S-Hub — minimal, MV3-native Chrome extensions.

Prompt Templates with Variables: Reusable AI Prompts for ChatGPT, Claude & Gemini

SHOTA — Tue, 28 Jul 2026 16:08:16 +0000

Most of the prompts I reuse aren't fixed text — they're almost the same every time, with one or two things swapped. "Rewrite this for a technical audience." "…for a beginner audience." "Summarize in 3 bullets." "…in 5 bullets." Retyping the whole thing to change one word is how good prompts quietly rot in your chat history.

The fix is templates with variables. Here's the idea, and a free Chrome extension that makes it one click.

What a prompt template is

A template is a prompt with placeholders you fill at send time instead of editing the text:

Rewrite the text below in a {{tone}} tone for a {{audience}} audience.
Keep it under {{word_count}} words.

---
{{text}}

Save it once. Each time you use it, you fill in tone, audience, word_count, and paste text — one template, dozens of variations, zero retyping. The wording of the instruction (the part you tuned carefully) never changes, so the quality stays consistent.

The manual version (and why it drags)

You can fake this with a notes doc: keep the template as plain text, copy it into the chat box, then manually find-and-replace {{tone}} before sending. It works, but you're tab-switching and hand-editing placeholders every single time — and it's easy to send a prompt with a {{variable}} you forgot to fill.

PromptStash: variables, one-click insert

PromptStash is a free Chrome extension that stores prompt templates and inserts them straight into the chat box — ChatGPT, Claude, Gemini, Perplexity, and more.

Save a prompt with {{variables}} in it
Organize it into a folder
On insert, PromptStash prompts you to fill each variable
The finished prompt drops directly into the chat box — no tab-switching

Because it fills the variables for you, you can't accidentally send a raw {{placeholder}}.

A few templates worth saving

Code review: Review the {{language}} code below for {{focus}} (bugs / style / performance). Be specific.
Explain an error: Explain this {{language}} error in plain terms and give the most likely fix: {{error}}
Commit message: Write a conventional commit message for this diff. Scope: {{scope}}.

Save each once; fill the blanks per use.

Free vs Pro

Free: up to 10 prompts, folders, and variables — enough to templatize your daily few
Pro ($5.99/mo): unlimited prompts and folders, prompt chaining, a prompt quality score, PII masking (strip names/emails before they hit the model), and import/export

The PII masking is the one I'd point a team at — it catches the "oops, I pasted a customer's email into ChatGPT" problem before it happens.

Install

Free, no PromptStash account, and it works across ChatGPT / Claude / Gemini / Perplexity.

→ Install free: https://dev-tools-hub.xyz/extensions/promptstash/?utm_source=dev.to&utm_medium=referral&utm_campaign=prompt-templates-with-variables

Chrome Web Store: https://chromewebstore.google.com/detail/promptstash/ocgkponbnolpgobllplcamfobolbjbcj

What's the one prompt you retype the most? That's the first one to templatize.

Built by S-Hub — minimal Chrome extensions for productivity.

What are Partitioned cookies (CHIPS), and why can+t your cookie editor see them?

SHOTA — Thu, 23 Jul 2026 15:50:47 +0000

I cleared "all cookies" for a site, reloaded, and a tracking cookie was still there. Not a caching issue — the cookie genuinely came back. That's what sent me down the CHIPS rabbit hole, and it turns out most cookie tools quietly hide a whole class of cookies from you.

Here's the short version of what's happening.

Third-party cookies got partitioned

For years, a cookie set by embed.example.com was one cookie, shared everywhere that embed appeared. That's exactly the cross-site tracking browsers have been clamping down on.

Chrome's answer is CHIPS — Cookies Having Independent Partitioned State — exposed as the Partitioned attribute:

Set-Cookie: session=abc; Secure; SameSite=None; Partitioned

With Partitioned, that cookie is keyed by the top-level site you're visiting. So the cookie embed.example.com sets while you're on site-a.com is a different stored cookie from the one it sets on site-b.com. Same domain, same name, two isolated jars. That isolation is the entire point — an embed can keep state without becoming a cross-site super-cookie.

Why your cookie editor doesn't show them

This is the part that bites developers. In the extension API, chrome.cookies.getAll() treats the partition key as a filter:

// unpartitioned cookies ONLY (what most old tools effectively ask for)
chrome.cookies.getAll({ url });

// a specific partition
chrome.cookies.getAll({ partitionKey: { topLevelSite: 'https://site-a.com' } });

// EVERYTHING — partitioned and unpartitioned
chrome.cookies.getAll({ partitionKey: {} });

If a tool was written before CHIPS, it calls the first form. It isn't lying on purpose — it's asking a question whose answer no longer includes the partitioned cookies. So the UI shows a confident, complete-looking list that's missing rows. You clear "all," the partitioned ones survive because they were never in the list, and you're left debugging against a wrong picture.

The partition key itself has two parts:

partitionKey: {
  topLevelSite: 'https://site-a.com',
  hasCrossSiteAncestor: true   // Chrome 130+
}

hasCrossSiteAncestor (the "Ancestor Chain Bit") is the subtle one: it records whether the cookie's frame sits under a cross-site ancestor. Two cookies can share a topLevelSite and still be different entries because this bit differs. If a tool ignores it — or passes it without topLevelSite, which throws — deletes silently miss.

How to actually see and clean them

Once you know partitioned cookies exist, you want two things: to see them grouped by partition, and to delete the right one (matching its exact partition key).

That's the gap CookieJar fills. It's a free MV3 cookie manager that lists cookies across partitions, groups them by their partition (top-level site), and lets you see and delete partitioned cookies correctly — not just the unpartitioned ones legacy tools show. Editing and dedicated export for partitioned cookies are coming in a later update; the immediate win is finally seeing and clearing the ones that were invisible.

A couple of gotchas worth knowing if you're testing this yourself:

Partitioned cookies require Secure and SameSite=None. You can't create one from a chrome-extension:// page, so to generate test data you need a real HTTPS server setting the header, with a cross-site iframe.
Minimum useful Chrome for the full API is 130 — earlier versions had a getAll regression around partitioned cookies.

Chrome Web Store: https://chromewebstore.google.com/detail/mv3-cookie-editor-manager/lhngfkchfepfjjdfhimconagoejemofg

If you've been fighting a cookie that "won't delete," check whether it's partitioned — I'd bet a good number of those bugs are CHIPS, not caching. Have you hit this one yet?

I built a free, local step-by-step guide maker — the screenshots were the easy part

SHOTA — Thu, 23 Jul 2026 15:48:45 +0000

Writing "how to do X in our app" docs by hand is miserable. You do the steps, screenshot each one, crop them, paste them into a doc, annotate, repeat. Tools like Scribe and Tango solved this years ago — you click through a process and they generate the guide. Tango alone has 400k+ installs, so clearly people want this.

I wanted the same thing but with two constraints those tools don't give me: the guide should be generated locally (screenshots of internal tools shouldn't get uploaded to someone's cloud), and it should export to a plain PDF I own. So I built Procshot.

The screenshot-and-caption part was straightforward. The part that ate a week was keeping a multi-step recording alive.

MV3 service workers die in the middle of your recording

A guide recording is inherently stateful: step 1, step 2, step 3… each click appends to a list you're building over time. My first version kept that list in a variable in the background service worker:

// don't do this
let steps = [];
chrome.action.onClicked.addListener(() => { steps = []; /* start recording */ });

This works right up until the user pauses to actually think about the next step. In Manifest V3 the service worker is terminated after ~30 seconds of inactivity, and when it does, steps is gone. So a 12-step guide would randomly come out as a 4-step guide, and I couldn't reproduce it on demand — it depended on how long the user hovered between clicks.

The fix is the MV3 rule everyone learns the hard way: never hold recording state in memory. Every captured step gets written to chrome.storage.local immediately, and listeners are registered at the top level so a woken-up worker re-attaches them:

chrome.runtime.onMessage.addListener((msg) => {
  if (msg.type !== 'STEP_CAPTURED') return;
  // append synchronously, don't trust the SW to still be alive next click
  chrome.storage.local.get('steps', ({ steps = [] }) => {
    steps.push(msg.step);
    chrome.storage.local.set({ steps });
  });
});

Same idea for the "am I currently recording?" flag — that lives in storage too, not a boolean in the worker. Once state moved out of memory, the dropped-step bug disappeared completely.

The screenshot timing gotcha

The other thing that bit me: capturing the screenshot on click often grabbed the page mid-transition — a half-rendered modal, a spinner. I ended up debouncing capture slightly after the interaction and waiting for the DOM to settle, which made the guides look like a human took them instead of a robot with a fast trigger finger.

Where it landed

Procshot records clicks, auto-captures and captions each step, and exports the whole thing to PDF — locally, no account, nothing uploaded. It's free. It's not trying to be a full video-SOP platform like the bigger tools; it's the "I need a clean numbered guide in two minutes" tool.

If you want to try it: https://chromewebstore.google.com/detail/ieblehdloggcpmkncplccjofeoakhkll

If you've built anything that records a session across multiple steps in MV3 — how did you handle the service worker dying mid-flow? Curious if there's a cleaner pattern than "write everything to storage on every event."

A Chrome extension I never marketed grew 2.7x in two weeks — then I lost half of it

SHOTA — Thu, 23 Jul 2026 15:48:36 +0000

I have a bad habit of judging an extension by how loud its launch was. PageMemo broke that habit. It's a small sticky-notes tool — you drop a note on any web page and it comes back when you return. I never ran ads for it, never posted about it, never did a launch. And over two weeks in April it grew 2.7x on installs anyway.

Then it gave most of that back. That second part turned out to be the more useful lesson, so I'll get to it.

The spike was real, not a bot

First thing I checked, because I'd been burned before: was this a bot wave? On another extension I'd seen installs balloon ~6,000 that were almost entirely fake — they never fired a single usage event.

PageMemo was the opposite. In the same window (April 13–27, peaking April 20–25), monthly active users went up ~4.5x and popup opens ~10x. Installs and actual usage moved together. When people install for real, they open the thing. When a bot "installs," it never does. So this was real demand, not noise.

What actually moved it (the honest version)

Here's where I have to be careful, because it's easy to invent a clean story after the fact.

I don't yet have the Chrome Web Store search-term data that would prove which query drove the installs — that export is still pending. What I do have is the timeline, and it lines up with exactly one thing.

On April 18, right before the spike started, I shipped a boring maintenance batch to PageMemo:

New Chrome Web Store screenshots
An ASO pass on the title and description
Two new locales (Korean and Spanish) added to the listing

No launch. No thread. Just the listing itself getting less bad.

My working hypothesis — and I'm calling it a hypothesis, not a fact — is that the localization did most of the work. When you add locales, the Store re-indexes your listing under those languages, and you become discoverable to people who were never searching in English. That's the kind of growth that shows up as "organic" because there's no campaign attached to it. The screenshots and copy probably helped conversion once people landed, but discovery is what changes install volume, and localization is the lever that touches discovery.

If you take one thing from this: your Store listing is a growth surface, not a formality. An afternoon of screenshots and two locales outperformed every "launch" I've done.

The part nobody frames as a win: I lost them

Now the uncomfortable number. By May, PageMemo's monthly actives fell from 161 back to 62.

I got the traffic and I didn't keep it.

That's a different problem from discovery, and it's the one I'd been ignoring. Sticky notes are a habit product — they only matter if you come back to the page and your note is still there, doing something for you. If the first session doesn't create a reason to return, a great listing just fills the top of a leaky bucket faster.

So the ASO win exposed the real gap. Acquisition was never the bottleneck once the listing was fixed. Retention was. And I'd spent months assuming it was the other way around.

What I'm changing

Treat the listing as a recurring lever, not a one-time setup. Localization especially — it's the cheapest discovery I've found.
Wait for the Store search-term export before I write the "we grew because of keyword X" story. Timeline correlation is a hypothesis; the export is the proof. I'd rather say "I don't know yet" than make it up.
Actually work on the first session. A note that reappears is only valuable if the first note felt worth taking. That's the retention fix, and it's next.

For the record, PageMemo is here if you want to poke at it: https://chromewebstore.google.com/detail/jmpmfbheoclfmceceihjpcjlabakkdde

If you've shipped something that grew from a listing change alone — did the users stick, or did you watch the same decay I did? I'm curious whether this is a sticky-notes problem or a me problem.

How to Save and Reuse Your ChatGPT Prompts (Chrome Extension)

SHOTA — Sat, 11 Jul 2026 14:55:52 +0000

If you use ChatGPT, Claude, or Gemini for real work, you've rewritten the same prompt more times than you'd like to admit — the code-review prompt, the "explain this stack trace" prompt, the commit-message prompt. Retyping them is slow, and the good versions get buried in chat history.

Here's how to stop retyping and start reusing.

Why saved prompts beat chat history

A dialed-in prompt is a reusable asset. Rebuilding it from memory each time risks a worse result. Saving prompts gives you:

Consistency — same prompt, same quality
Speed — no retyping multi-line prompts
Sharing — the team reuses what actually works
Iteration — improve a saved version instead of starting over

Option 1: a notes doc (zero tools)

Keep a "Prompts" doc, paste each keeper with a label, and copy/paste when you need one. It works, but you're tab-switching constantly and there's no way to drop a prompt straight into the chat box. Fine for a few prompts; tedious past that.

Option 2: PromptStash (one-click insert)

PromptStash is a free Chrome extension that saves prompts and inserts them directly into ChatGPT, Claude, Gemini, Perplexity, and more — no tab-switching.

Install it (free, no PromptStash account)
Save any prompt and drop it in a folder
Insert it straight into the chat box in one click
Reuse as-is or tweak before sending

Free: up to 10 prompts, folders, and variables.
Pro ($5.99/mo): unlimited prompts and folders, prompt chaining, a prompt quality score, PII masking, and import/export.

Templates with variables

If you send the same prompt with one thing changed, use a variable instead of editing text every time:

Rewrite the text below in a {{tone}} tone for a {{audience}} audience.

Save once, fill in tone and audience on insert. One template, dozens of variations.

Where it pays off for devs

Code-review and refactor prompts, reused across every PR
"Explain this stack trace" with a consistent format
Commit-message and changelog prompts as one-click templates

Install

Free, no PromptStash account, and it works across ChatGPT / Claude / Gemini / Perplexity.

→ Install free: https://dev-tools-hub.xyz/extensions/promptstash/?utm_source=devto&utm_campaign=save-reuse-chatgpt-prompts

Chrome Web Store: https://chromewebstore.google.com/detail/promptstash/ocgkponbnolpgobllplcamfobolbjbcj

Built by S-Hub — minimal Chrome extensions for productivity.