DEV Community: WgeorgeAssistantIA

I Built an AI Tool That Extracts Tech Stacks from YouTube Videos

WgeorgeAssistantIA — Sat, 12 Sep 2026 18:57:29 +0000

Every developer has done this: you open a 45-minute "Build a SaaS in a weekend" video, and by minute 12 you're already pausing every 30 seconds to screenshot a terminal command or squint at a VS Code sidebar to figure out which ORM the creator just installed. You rewind three times because you missed the name of the vector database. By the time the video ends, you've spent an hour to extract maybe eight lines of useful information: a framework name, two library names, one hosting provider. I built VidScope because I got tired of doing this manually, and I wanted to share how the extraction pipeline actually works under the hood — and why "AI video summarizer" was the wrong way to think about the problem from the start.

The first mistake I made was treating this as a summarization problem. Early prototypes fed the full YouTube transcript into an LLM and asked for "a summary of the tools used." The results looked plausible and were frequently wrong — the model would infer a database was PostgreSQL because the creator said "SQL," or assume a deployment target was Vercel because the video mentioned Next.js, even when the actual clip named Railway. Summarization models are optimized to sound coherent, not to be strictly grounded in the source. For a tool whose entire value proposition is "tell me exactly what was mentioned," a confidently wrong answer is worse than no answer. That's the core design constraint that shaped everything else: extraction, not interpretation.

The pipeline itself is simpler than people expect. VidScope pulls the video's transcript (falling back to audio transcription when no captions exist), chunks it to stay inside context limits for long-form content — some tutorials and conference talks run past two hours — and runs extraction passes that are explicitly instructed to only output tool, framework, or library names that appear verbatim or near-verbatim in the transcript text. No inference from context, no "this is probably React because they mentioned JSX." If a name isn't in the transcript, it doesn't make it into the report. This is the "0% hallucination" constraint, and it's enforced at the prompt level with strict extraction rules, not just requested politely.

The part that took the most iteration wasn't the extraction — it was verification. A raw list of tool names is only marginally more useful than pausing the video yourself. What makes the report actually save time is that every extracted name gets resolved to its official documentation or homepage link automatically, so a developer can go from "watched half a tutorial" to "have the actual docs open in five tabs" in under 30 seconds. Getting this resolution step accurate meant handling ambiguous names (there are at least four different open-source projects called "Flow"), filtering out generic terms that get mentioned but aren't tools (the model initially flagged "the cloud" and "database" as extracted entities before I tightened the extraction schema), and deduplicating variants of the same tool referenced multiple times under slightly different names across a single video.

Long videos exposed a separate scaling problem: a two-hour conference talk produces a transcript that's tens of thousands of tokens, and naively extracting per-chunk without merging state across chunks produces duplicate or fragmented tool lists — the same framework mentioned in minute 5 and minute 90 shows up twice with slightly different context. The fix was maintaining an extraction state across chunks rather than treating each chunk independently, which also meant the final report generation step needed to be idempotent regardless of how many chunks a video's transcript happened to split into. This is the unglamorous part of building an "AI feature" that nobody talks about: the actual model call is a small fraction of the engineering effort compared to chunking, state management, and making outputs consistent at different video lengths.

None of this matters if the tool doesn't fit into how developers actually work. The workflow I optimized for is: paste a YouTube link, wait 30 seconds, get a clean list of every tool and framework mentioned with verified links, export to Markdown or PDF, move on. No account required to try it, no video re-upload, no watching required at all. It's built for the moment when you find a promising tutorial at 11pm and want to know in thirty seconds whether it's using a stack you actually want to learn, before committing 45 minutes to watching it.

If you've ever kept a messy notes file of "tools mentioned in videos I watched," or rewound a stream three times to catch a package name, that's exactly the problem VidScope solves. You can try it free on two videos, no credit card required, at vidscope.fr.

How I Built a Local Silence Remover That Processes a 5GB Audio File in Under 6 Minutes

WgeorgeAssistantIA — Thu, 10 Sep 2026 09:44:45 +0000

VoxCut is a dedicated silence remover for audio and video: it automatically detects and cuts silent pauses — dead air, long breaths, gaps between takes — from podcasts, interviews and recordings. Unlike full editors that bundle silence removal as one feature among many, it does this one job, entirely on your device.

I want to walk through the actual engineering problem behind it, because "remove silence from audio" sounds trivial until someone hands you a 72-hour, 5GB recording and expects it back in a few minutes.

The naive approach falls over first

The obvious way to build this: load the whole file into memory, scan the waveform, cut the quiet parts, re-encode. That's roughly what most desktop audio editors do — and it's exactly why they choke on anything past a couple of GB. Once you're loading multi-hour recordings, you hit a RAM ceiling that has nothing to do with your CPU.

VoxCut instead runs a local, FFmpeg-based streaming pass over the file rather than materializing the whole thing in memory. That single architectural choice is what lets it handle files "beyond 5GB" without a hard ceiling — the real limit becomes your disk space, not your RAM.

Detection: comparing amplitude against a threshold

The detection logic itself is simple in concept and easy to get wrong in practice: compare each segment's amplitude against a decibel threshold and a minimum pause duration. Too aggressive, and you cut a natural breath mid-sentence. Too conservative, and you leave dead air in.

VoxCut previews exactly what will be cut before anything is removed, so the sensitivity setting is something you tune by ear rather than trust blindly — nothing is deleted until you confirm.

The Turbo Mode trade-off (V2)

The 2.0 release added a Pro-only Turbo Mode that's a good example of an honest trade-off rather than a free performance win. The standard export stitches kept segments together with crossfades, which sounds smoother but costs time on files with hundreds of detected cuts. Turbo mode removes silence in a single pass instead — no crossfades — which is roughly 2x faster on realistic content (podcasts, interviews, meetings).

The cost: sharper cuts instead of smooth transitions. For most spoken-word content that's barely audible; for content that leans on the crossfades to hide the cut points, standard mode is still the default.

On realistic content (not the "silence-only" edge case that inflates marketing numbers), expect roughly 35-50x real-time in standard mode and 70-100x in Turbo, depending on the machine. A 72-hour, 5GB file was processed in under 6 minutes on ordinary consumer hardware.

Going cross-platform: Windows/Linux desktop, then Android

VoxCut started as a Windows/Linux desktop app. Porting the same core logic to Android (shipped as v2.0.2, same week as the 2.0 desktop release) meant a separate app with its own constraints: mobile storage, a different free-tier limit (5 minutes per file vs. 10 minutes on desktop), and Pro features gated differently — AI noise reduction and loudness normalization are Android-Pro-only, priced independently (€14.99 lifetime) from the desktop license.

Keeping "100% local, no upload" true on both platforms was the one non-negotiable constraint across the port — it's the core promise, not a checkbox feature.

What I'd do differently

If I started over, I'd build the streaming-pass architecture from day one instead of retrofitting it — the in-memory prototype worked fine on my own test files and only broke once real users started throwing multi-hour recordings at it. Test with files bigger than you think anyone will use.

VoxCut is free to try (Windows, Linux, Android) — voxcutpro.com. Feedback and questions welcome in the comments, this is my first shipped piece of software and I'm still learning in public.

About VoxCut

VoxCut is a dedicated silence remover for audio and video. It automatically removes silence, pauses and dead air while processing your files locally — with no upload and no subscription.

VoxCut — Silence Remover for Audio & Video · https://voxcutpro.com

Why I built a local-first PNG-to-SVG converter instead of using an online tool

WgeorgeAssistantIA — Fri, 04 Sep 2026 12:58:26 +0000

Most "convert your image to SVG" tools online are the same story: upload your file to a server you don't control, wait, download a result that's either bloated with thousands of tiny paths or stripped of the details that made the image worth vectorizing in the first place. I hit this wall enough times doing client logo work that I built my own converter — VectorPop — and kept it entirely local, no upload, no subscription.

The problem nobody talks about

Vectorizing a raster image well isn't really about tracing pixels — any tool can call a tracing library and spit out an SVG. The actual work is everything that happens before tracing: merging near-identical colors so you don't get 40 shades of "almost the same blue," rebuilding gradients as real <linearGradient> elements instead of dozens of flat color bands, and cleanly separating a subject from its background. Skip that preprocessing and you get technically-valid SVGs that are unusable in a real design workflow — too many paths, wrong colors, gradients turned into stripes.

The technical approach

VectorPop wraps vtracer (the Rust tracing engine) with a Pillow-based preprocessing layer I built specifically to solve those problems: color quantization and merging before tracing, gradient reconstruction that samples the original pixels to estimate a real gradient rather than approximating it geometrically, and an "Optimize" button that tries ~12 setting combinations and keeps whichever one is closest to the source image — no deep learning, just systematic comparison. Background removal works two ways: flat-color removal with a tolerance slider for logos on solid backgrounds, and optional AI segmentation (rembg) for photos — the AI path is opt-in and the app degrades gracefully if the dependency isn't present.

Why local, and why this pricing model

Everything runs on-device: no image ever leaves your machine, which matters if you're vectorizing client logos or anything under NDA, and it also means no per-conversion cost to pass on to the user. That's why VectorPop is free for unlimited vectorization with 3 SVG exports/day, and a one-time €39 for the Pro tier (unlimited exports, PDF/high-res PNG, AI cutout, batch processing) — no subscription, because a desktop tool that runs locally shouldn't need one.

Wrap-up

VectorPop is a Windows app, live on the Microsoft Store, built by a solo dev after getting tired of redoing SVGs by hand in Illustrator for logo and print work. If you've fought with online converters that either paywall basic exports or upload your files to a server, it's worth a look: vectorpop.fr.

Curious what this community thinks of the gradient-reconstruction approach vs. just tracing flat color bands — happy to go into more technical detail in the comments.

Stop Copy-Pasting Your Invoices: The Complete Guide to Local PDF Mail Merge

WgeorgeAssistantIA — Thu, 27 Aug 2026 19:01:59 +0000

If you run a small business, a freelance practice, or a local club, you probably spend more time than you'd like doing administrative chores. One of the worst offenders? Copying and pasting data from a spreadsheet to create individual documents.

Whether it's monthly invoices, employee training certificates, or personalized event badges, doing this manually is a guaranteed way to waste hours and introduce typos.

Enter the PDF Mail Merge.

Mail merge isn't just for sending letters anymore. By using your spreadsheet as a simple database and connecting it to a PDF template, you can automate this entire workflow. But there is a catch.

Many people default to online web tools. While convenient, this means uploading sensitive financial data, client names, and addresses to a third-party server. If you care about data privacy (or GDPR compliance), this is a red flag.

The Local-First Solution

The safest and most efficient way to handle this is locally on your own computer. We developed InOneShot exactly for this purpose.

Here is how a local PDF mail merge works in 3 steps:

Prepare your Data: Keep a clean Excel or CSV file. One row per invoice or person.
Design your Template: Create a beautiful PDF design once. Leave blank spaces for the variable data.
Merge and Generate: Use InOneShot to map your spreadsheet columns to your PDF. As an offline bulk PDF generator, the app runs locally on your machine, generating hundreds of unique, named PDFs in seconds. You get a clean ZIP file of documents. No monthly subscriptions, no data privacy concerns, just hours of your life back.

Automating your admin work doesn't require complex coding or expensive cloud tools. Sometimes, a smart local app is all you need.

👉 Ready to get your time back? Download InOneShot, the ultimate local PDF creator, and start automating your paperwork today!

An Auto-Editor Alternative With No Command Line (for People Who Don't Code)

WgeorgeAssistantIA — Sat, 04 Jul 2026 14:02:32 +0000

Long interviews, webinars and full sessions crash browser tools and choke on upload. Here's how to trim silence from large, multi-hour audio files without hitting size limits.

Trimming silence from a three-minute clip is easy — almost any tool handles it. The pain starts when the file is big: a two-hour interview, a full-day workshop recording, a webinar, a long-form podcast in lossless WAV. That's where most silence removers fall apart, and where the choice of tool actually matters.

Why large files break most silence removers

The majority of popular silence-removal tools are browser-based or cloud-based. That's fine for short clips, but with large files it creates real friction:

Upload limits — many web tools cap uploads at 100–500 MB, well under a multi-hour lossless recording.
Slow, fragile uploads — sending a 2–4 GB file over your connection can take ages, and a dropped connection means starting over.
Browser memory limits — loading a huge waveform into a browser tab can freeze or crash it.
Privacy exposure — a confidential interview or client recording leaves your machine and sits on someone else's server.

The fix: process large files locally

A desktop app that runs on your own machine sidesteps every one of those problems. There's no upload — the file never leaves your computer — so file size is limited by your disk and RAM, not by someone's server quota. Processing reads the file directly, which is far faster than streaming gigabytes to the cloud and back, and your audio stays completely private.

What to look for when files are big

Runs locally / offline — no upload step, no size cap tied to a server.
Handles multi-gigabyte files without choking — headroom for multi-hour lossless recordings.
Batch processing — so you can queue a whole folder of long recordings and walk away.
A preview before you commit — you don't want to reprocess a 3 GB file because the threshold was off.
Lossless format support (WAV, FLAC) — long recordings are often captured uncompressed.

Doing it with VoxCut

VoxCut is a desktop app for Windows and Linux built for exactly this. It runs 100% locally — your audio never leaves your computer — and handles files up to 5 GB, which comfortably covers multi-hour interviews, webinars and full-length episodes in WAV or FLAC. You set a sensitivity threshold, see a before/after waveform (blue for voice, grey for silence) so you know what will be cut before you export, and batch-process a whole folder of long recordings in one go. It's a one-time purchase, no subscription.

Tips for long recordings

Preview first on the waveform — a small threshold error is annoying on a 3-minute clip and expensive on a 2-hour one.
Keep a 400–600 ms minimum silence so natural pauses survive across a long conversation.
Batch overnight — queue the whole folder and let it run while you do something else.
Always keep the original — trimming is destructive to timing, so archive the source file.

Big files shouldn't mean big headaches. Once you stop fighting upload limits and process long recordings locally, trimming silence from a multi-hour session becomes just as quick as a short clip — and your recordings stay private the whole time.

How to Automatically Remove Silences From a Podcast (Without Manual Editing)

WgeorgeAssistantIA — Wed, 17 Jun 2026 11:02:48 +0000

If you record podcasts, interviews, or voiceovers, you already know the truth: the recording is the easy part — the editing is where the hours disappear. And a huge chunk of that editing time goes into one tedious, repetitive task: cutting out silences, pauses, and dead air.

The good news? You don't have to do it by hand anymore. Here's how to remove silences from your audio automatically, and why it makes such a difference.

Why silences matter more than you think

A few seconds of dead air feels harmless while you're recording. But across a 45-minute episode, those pauses add up — often to 10–20% of the total runtime. That's:

Longer episodes that feel slower and lose listeners
More file size to host and deliver
A less professional, less "tight" listening experience

Removing silences makes your content punchier, shorter, and noticeably more polished — without changing a single word you said.

The slow way: cutting silences manually

The traditional approach is to open your recording in an editor (Audacity, Audition, Premiere…), scrub through the waveform, find each gap, select it, and delete it. Repeat a few hundred times per episode.

It works, but it's mind-numbing — and it's the single biggest reason editing a podcast can take 2–3× longer than the recording itself.

The fast way: automatic silence detection

Modern tools can analyze your audio, detect every silent passage based on a volume threshold, and trim them in one pass. Instead of hunting for gaps manually, you:

Load your audio file (MP3, WAV, etc.)
Set the sensitivity — how quiet and how long a passage must be before it counts as "silence"
Let the tool detect and trim every silent section automatically
Export your cleaned-up file

What used to take an hour now takes a couple of minutes.

A simple tool for this: VoxCut

I build a small Windows app called VoxCut that does exactly this. You drop in a recording, and it shows you a before/after waveform — blue for voice, grey for silence — so you can see precisely what's being removed before you commit. One click, and the dead air is gone.

It's designed to do one job well rather than be a full DAW: adjustable sensitivity, fast processing, and a clean interface with no learning curve. There's a free version to try it, and a one-time Pro upgrade (no subscription).

(Full disclosure: I'm the developer of VoxCut, so I'm obviously biased. But the workflow above works with any silence-detection tool — the point is to stop doing this by hand.)

Tips for the best results

Don't over-trim. Leaving a small natural pause (150–300 ms) between sentences keeps speech sounding human. Cutting every millisecond makes it feel rushed and robotic.
Tune the threshold to your recording. A noisy room needs a higher silence threshold than a treated studio, or background hiss gets mistaken for speech.
Always keep your original file. Trim a copy, so you can re-do it if you cut too aggressively.
Do silence removal first, then your other edits (EQ, leveling, music) on the tightened file.

The bottom line

Manually cutting silences is one of those tasks that adds zero creativity and eats enormous amounts of time. Automating it is one of the highest-leverage changes you can make to your editing workflow — you get shorter, tighter, more professional episodes, and you get your evenings back.

If you want to try it on Windows, you can grab VoxCut at voxcutpro.com.