DEV Community: Remove AI Meta

A Directory of Browser Tools Grouped by the Job, Not the Hype

Remove AI Meta — Tue, 22 Sep 2026 08:37:33 +0000

Most tool lists are SEO piles. I needed a directory grouped by job: converters, generators, editors, calculators. That is Web Tools List.

Search the job, not the brand. A useful tool works in the browser and explains the output.

Browse webtoolslist.com by category. The useful web is still small pages that do one thing.

Play a Browser Mech Game, Then Browse More Robot Wars

Remove AI Meta — Tue, 22 Sep 2026 08:37:28 +0000

I wanted a mech fight that loads in a tab: no launcher, no account wall before the first match. Mechangelion is that page, plus a directory of robot, tank, and stickman war games nearby.

A 2-minute session should not require a 4 GB install. Readable hit feedback and a round that ends matter more than a long HP sponge.

Start at mechangelion.com. Play, then browse.

Find the Song Used in an Instagram Reel Without Guessing

Remove AI Meta — Tue, 22 Sep 2026 08:32:07 +0000

Reels hide the track behind a sticker and a truncated title. If you are clearing music or matching a reference, guessing from a 3-second hook wastes an afternoon.

Reel Song Finder is the page I open when I need the track name from a Reel.

Read the sound label, search with the share URL, confirm with a 10-second listen. Editors get a title and artist.

The tool is at reelsongfinder.com.

Export a ChatGPT Thread to Word Without Losing the Structure

Remove AI Meta — Tue, 22 Sep 2026 08:32:03 +0000

ChatGPT is fine for drafting and painful for filing. Copy-paste into Word drops code fences, turns lists into a wall, and loses who said what.

I use ChatGPT to Word when a thread has to become a note, a brief, or an appendix.

Headings, lists, code blocks, and user vs assistant turns should survive. Export once, then edit in Word.

The exporter is chatgpt2word.com. Treat the chat as a whiteboard. Treat Word as the artifact.

Turn SRT Subtitles Into an Editable Word Document

Remove AI Meta — Tue, 22 Sep 2026 08:26:42 +0000

SRT files are great for players and terrible for editors who live in Word. Timecodes, blank lines, and cue numbers get in the way of a script pass.

I convert them with SRT to Word when I need comments, highlights, or a bilingual table.

A producer needs readable paragraphs, not cue indexes. Translators get a .docx. I keep the SRT as the source of truth for timing.

The converter is at srt2word.com. Upload, download Word, send to review.

Strip C2PA and IPTC Metadata From AI Images Before You Publish

Remove AI Meta — Tue, 22 Sep 2026 08:26:37 +0000

AI image tools now stamp Content Credentials and older IPTC fields into files. That can be useful for provenance. It is a problem when you need a clean asset for a client who does not want model traces in the bytes.

I keep a dedicated inspector for this: Remove AI Meta.

What is actually in the file

Typical extras include C2PA manifests, IPTC software fields, and EXIF that still names the generator. Viewing the image is not the same as reading those chunks.

A publish checklist

Inspect the download
Strip credentials if the brief requires a clean file
Re-inspect so you did not leave a second packet
Keep the original if you still need provenance later

The before-and-after flow is on removeaimeta.com. Metadata is not the image. Treat it as a separate document attached to the pixels.

Generate Minecraft Schematics in the Browser Before You Build

Remove AI Meta — Tue, 22 Sep 2026 08:20:00 +0000

Building in Minecraft is faster when you can test a layout as a schematic instead of placing every block by hand. I wanted a generator that runs in the browser, exports a schematic, and does not require a local modpack just to try an idea.

That is what I use Minecraft Schematic Generator for.

Why a schematic first

A schematic lets you:

iterate on size and symmetry
share a build without a world save
paste into a test world with a known tool

Sketching in creative mode is fun. Rebuilding the same wall ten times is not.

A workflow that stays small

Describe or draw the structure you want
Generate the schematic
Inspect the footprint
Export and paste in a creative world

If the export is wrong, fix it in the generator. Do not debug with a stack of cobblestone.

What I check before pasting

dimensions vs the plot
block palette (no surprise netherite walls)
orientation so doors face the street

The generator lives at minecraftschematicgenerator.com. It is a browser tool, so I can try a layout on a laptop and only then open the game.

If you build a lot of houses or farms, keep schematics next to your world backups. The game is the renderer; the schematic is the source.

How to Download Snapchat Memories Without Losing Photo Quality

Remove AI Meta — Tue, 22 Sep 2026 08:19:55 +0000

Snapchat Memories are easy to browse in the app and surprisingly hard to keep as real files. If you ever switch phones, lose access, or just want a backup you control, you need an export that produces photos and videos you can open later.

I wrote a short walkthrough of the practical path: collect Memories, export a ZIP, and check that the files are actually there. The tool I use for this is Snapchat Memories Download.

Why the in-app gallery is not a backup

Memories live in Snapchat's account. That is convenient until:

the app refuses to load older days
you need originals for a project
you want files on disk, not a feed

A backup is a folder of files with dates you can sort. Anything that only plays inside Snapchat is still a lock-in.

What a usable export looks like

A good export should:

List Memories you selected
Pack them into a ZIP
Keep images and videos playable outside the app

If the ZIP opens and the media plays in a normal player, the job is done.

A simple checklist

Export on a desktop browser if the phone is slow
Keep the ZIP until you have copied files to two places
Do not post private Memories to a public drive

I keep the steps on snapchatmemoriesdownload.com so I do not have to re-learn the flow every time I help someone offload an archive.

If you only needed one takeaway: treat Memories like email attachments. Download them, then decide what to keep.

Generate a Minecraft Java Edition .litematic from a text prompt

Remove AI Meta — Mon, 21 Sep 2026 14:52:27 +0000

If you use Litematica on Minecraft Java Edition, you usually copy a build in-world or download someone else's schematic.

A shorter path when you want a new house, castle, tower, or nether portal:

Describe the build in English.
Download a .litematic.
Drop it in .minecraft/schematics and load the hologram.

I use Minecraft Schematic Generator for that. It is Java Edition only — not Bedrock.

After download, this import guide covers Fabric, CurseForge, and Modrinth.

Also useful:

Not affiliated with Mojang Studios, Microsoft, or Litematica.

Cleaning AI Metadata from Images and Files: A Practical Guide for Developers

Remove AI Meta — Mon, 21 Sep 2026 03:03:55 +0000

If you have ever

Why Subtitle Files Break Your Docs Pipeline (and How I Handle It)

Remove AI Meta — Mon, 21 Sep 2026 03:03:52 +0000

If you've ever tried to hand a .srt file to someone who doesn't work with video, you know the look. It's the same look you get when you send a .parquet file to a product manager. The content is in there — dialogue, timestamps, speaker cues — but the container is wrong for the audience.

I've been building tooling around media workflows for a few years now, and subtitle conversion keeps coming back as a small, annoying, recurring problem. Not because it's hard, but because most people solve it badly the first time and then copy that solution forever.

Here's what I've learned about doing it properly.

What's actually inside an SRT file

An SRT is deceptively simple. Each block looks like this:

1
00:00:04,120 --> 00:00:07,880
So the first thing we need to check
is whether the token is still valid.

2
00:00:08,010 --> 00:00:10,440
If it isn't, we bail out early.

Three parts: an index, a timing line, and one or more lines of text. That's it. No styling, no positioning, no speaker metadata unless someone smuggled it into the text itself.

The simplicity is why it's everywhere. YouTube exports it. OBS writes it. Whisper generates it. Every transcription service on the planet will hand you an SRT before they hand you anything else.

The simplicity is also why it's a bad format for anything that isn't a video player.

Where the pipeline breaks

The failure mode I see most often is a naive conversion: strip the timestamps, concatenate the text, paste into Word. It works for a five-minute clip. It falls apart the moment you have real content.

Three specific problems show up:

Line breaks become meaningless. In an SRT, a line break is a display constraint — it exists because the subtitle box is narrow. In a document, a line break is a paragraph. If you keep them, you get a document where every sentence is its own paragraph. If you drop them all, you lose real paragraph boundaries that the transcriber may have encoded with blank lines or double breaks.

Timestamps carry information you might want. For a transcript you're editing for publication, you probably don't want 00:00:04,120 --> 00:00:07,880 in the body. But for a review copy, a legal record, or an accessibility audit, you absolutely do. The right answer depends on the destination, not the source.

Encoding is a minefield. SRT files in the wild are a mix of UTF-8, UTF-8 with BOM, Windows-1252, and occasionally something stranger. If you're reading them in Python with the default open(), you'll get a UnicodeDecodeError on the first curly apostrophe. Always specify the encoding, and be ready to fall back.

A conversion approach that holds up

If you're writing this yourself — and for a one-off, you should — the shape of the solution is:

Read the file with an explicit encoding, falling back to latin-1 if you have to.
Split on blank lines to get blocks.
For each block, drop the index line, parse the timing line with a regex, and join the remaining lines.
Decide what to do with the text: keep it as a single paragraph, or merge consecutive blocks that belong to the same speaker.
Write out to a .docx using python-docx, or to Markdown if the destination is a docs site.

The interesting decision is step 4. Merging is where quality lives. A good merge heuristic: if the gap between block N's end and block N+1's start is under ~500ms and the previous block doesn't end with sentence-terminating punctuation, join them with a space. That single rule cleans up 90% of the choppiness in auto-generated transcripts.

Here's a minimal version:

import re
from docx import Document

TIMING = re.compile(
    r"(\d{2}):(\d{2}):(\d{2}),(\d{3}) --> "
    r"(\d{2}):(\d{2}):(\d{2}),(\d{3})"
)

def parse_srt(text):
    blocks = re.split(r"\n\s*\n", text.strip())
    cues = []
    for block in blocks:
        lines = block.splitlines()
        if len(lines) < 2:
            continue
        match = TIMING.match(lines[1])
        if not match:
            continue
        body = " ".join(lines[2:]).strip()
        cues.append((match.groups(), body))
    return cues

From there, merging and writing to docx is a dozen more lines. The whole thing fits in a single file and takes an afternoon.

When not to write it yourself

There's a category of task where rolling your own is the right call: you do it often, you have specific requirements, and you want it in your build. There's another category where it isn't: you need one file converted, right now, and you don't want to install Python and python-docx on a machine you don't control.

For that second case, I keep a browser-based converter bookmarked. I've been using SRT to Word for the quick jobs — it takes an SRT, produces an editable .docx, and doesn't require an account or an upload to a service I don't know. It's the kind of tool that exists because the manual version is tedious and the scripted version is overkill for a single file.

The tradeoff is real: you're handing a file to someone else's server. For a public YouTube transcript, that's fine. For an internal meeting recording, run the script locally. Know which one you're doing.

The general lesson

Subtitle conversion is a small instance of a pattern that shows up everywhere in developer tooling: the format that's convenient for machines is rarely the format that's convenient for people. SRT is optimized for a player that needs to know when to draw text on a screen. Word is optimized for a human who needs to read, edit, and comment.

The conversion between them isn't a format change. It's a change in what the structure means. Line breaks stop being display hints and start being paragraphs. Timestamps stop being playback instructions and start being either noise or evidence, depending on who's reading.

Get that mapping right, and the code is trivial. Get it wrong, and you get a document that technically contains the words but is miserable to actually use.

The Subtitle Problem Nobody Talks About: Editors Are Still Working in the Wrong Format

Remove AI Meta — Mon, 21 Sep 2026 02:54:36 +0000

Every production I have worked on hits the same wall. The video is locked. The audio is mixed. And somewhere in the chain, a subtitle file is sitting in a format that no one on the editorial team can actually open.

SRT files are brilliant at what they are designed to do. They tell a player when to show a line of text and when to hide it. Timestamps, sequence numbers, dialogue. That is the whole job. For a video player, that is enough. For a human being trying to review, edit, or approve that dialogue, it is close to useless.

I have watched experienced editors open an SRT in a text editor and squint at timecodes. I have watched producers copy lines out of a subtitle file one at a time and paste them into a document, then lose track of which line came from which timestamp. I have watched a two-hour documentary's captions get proofread in a spreadsheet, which is a sentence I never want to type again.

The formatting problem is not glamorous, but it costs real time. A subtitle file does not respect paragraphs. It breaks sentences wherever the character limit demands. It strips out punctuation conventions that editors rely on. Speaker labels, italics for emphasis, line breaks that carry meaning — all of that either disappears or turns into noise.

The fix is not complicated. It is just a conversion. Subtitles belong in a player. Dialogue belongs in a document. When you move an SRT into Word, the timestamps become reference points rather than obstacles, and the text becomes something a person can actually read from top to bottom. Editors get track changes. Producers get comments. Legal gets a file they can mark up without learning a new tool.

That is the reasoning behind what I built. I run a small tool that takes a subtitle file and turns it into an editable Word document, so the review process happens in the format editors already use every day. You can see how it works at https://srt2word.com/ — it is deliberately narrow in scope, because the problem it solves is narrow too.

What surprises people is how often this comes up. It is not just film and television. Corporate training teams need to review captions before publishing. Podcast producers want a transcript they can edit by hand. Researchers working with interview footage need the spoken content in a document they can quote from. In every one of those cases, the subtitle file is the source of truth and Word is the working surface.

There is a broader point here about tooling. The industry has spent years optimising capture, encoding, and delivery. The last mile — the part where a human being has to read the words and decide whether they are right — is still often handled with copy and paste. That is not a technology gap. It is a format gap, and format gaps are usually the easiest ones to close.

If your workflow involves captions, subtitles, or transcripts of any kind, it is worth asking where the bottleneck actually is. More often than not, it is not the editing. It is the file format standing between the editor and the text.