DEV Community: AgentChip

"9am PT = What Time in Beijing?" Is a Question Your Calendar Should Answer

AgentChip — Tue, 15 Sep 2026 00:13:46 +0000

Every remote team has that one spreadsheet: a grid of names, time zones, and working hours, lovingly maintained for about two weeks before it silently rots.

Then the ritual begins. Someone wants to schedule a call. Someone opens three browser tabs — one world clock, one DST checker, one "what is PDT again" article. Someone does the mental math wrong and a teammate in Berlin joins at 6 AM.

Why the mental math keeps failing

Time zone conversion isn't hard because of the arithmetic. It's hard because of the edges:

DST shifts — the offset between two zones changes twice a year, on different dates per country. Your March calculation is wrong in November.
Half-hour zones — India is UTC+5:30. Nepal is +5:45. Your "round to the hour" assumption breaks.
The gap and the overlap — spring-forward has a 2:30 AM that doesn't exist; fall-back has one that happens twice.
"Working hours" are fuzzy — 9-5 in one culture, 10-6 in another, and nobody wants the 11 PM slot even if it technically works.

Online meeting-time finders exist, but they all want you to paste your team's names, roles, and availability into somebody's web form. For a solo freelancer or a small team, that's a lot of trust for a math problem.

What I built: one command, zero uploads

A single-file Python CLI (pure standard library — the only optional extra is tzdata on Windows) that answers the question locally:

# One-shot: what does 9:00 AM in LA mean for everyone?
python timezone_planner.py convert "9:00 AM" America/Los_Angeles Asia/Shanghai Europe/London

# Find shared windows across the whole team, next 7 days
python timezone_planner.py overlap "Alice:America/New_York:09:00-17:00" "Bob:Asia/Tokyo:10:00-18:00" "Carol:Europe/Berlin:09:00-17:00"

What it handles:

DST-aware conversion — uses your system's IANA time zone database, so spring-forward gaps roll to the first valid minute and fall-back repeats take the earlier instant
Overlap finder — scans future days in 15-minute granularity, merges contiguous windows, and skips weekends automatically
Exit code contract — 0 = overlap found, 1 = no overlap (so you can bolt it into cron and get pinged when a scheduling window opens or closes), 2 = bad args
--json output — machine-readable, for piping into your own tooling
100% local — your team's names, zones, and hours never leave the machine

The boring truth

Scheduling across time zones isn't a people problem, it's a lookup problem. The answer already exists in your machines' time zone databases — it just needs a two-command interface in front of it.

If you run a remote team or juggle clients across zones, the full kit (planner + README with cron recipes + DST edge-case notes) is on AgentChip. One-time purchase, no subscription, no account, your data stays on your machine.

Related: if your problem is deadlines in a spreadsheet rather than meetings across zones, that's a different converter — and we cover that too.

Your Bills Live in a Spreadsheet. Your Calendar Has No Idea They Exist.

AgentChip — Mon, 14 Sep 2026 04:10:50 +0000

Every freelancer and small business owner has the same system: a spreadsheet full of due dates. Invoice #204 due the 15th. The software subscription renews on the 28th. Client deliverable due Friday. Content publish dates for the next month.

And then the system fails in the most predictable way possible: the spreadsheet doesn't talk to your calendar. You have to remember to look at the spreadsheet. Which is exactly the kind of task that falls apart the week you're busy.

The manual export ritual (and why it dies)

The common advice is "just put it in Google Calendar." So you spend an afternoon manually creating calendar events from your CSV. It works — until you add row 41 and forget to create the event. Or your teammate adds rows in a different date format. Or you realize you have to redo the whole ritual every time the sheet changes.

What you actually want is a pipeline: CSV in → .ics out → import once → done. And when the sheet updates, run it again.

What I built: one command, spreadsheet to calendar

A single-file Python CLI (pure standard library, zero dependencies — no pip install) that converts any deadline spreadsheet into a calendar file:

Smart header detection — recognizes English (title/date/due/desc/location) and Chinese (标题/日期/截止/描述/地点) headers automatically
Forgiving date parsing — 2026-09-15, 09-15-2026, 20260915, 9/15/26 all work; a flag flips to day-first for non-US sheets
Timed vs. all-day events — rows with a time (9:30 AM) become timed events; rows without become all-day
Automatic reminders — every event gets a 24-hour alarm baked in (configurable per-column or globally)
Bad rows don't kill the run — a row with a broken date gets skipped and reported with its line number and reason, not silently dropped
Encoding & delimiter auto-detection — UTF-8 or GB18030, commas, semicolons, or tabs
Proper ICS escaping — commas, semicolons, backslashes and newlines in descriptions won't corrupt the file
Exit code contract — 0 = events written, 1 = nothing usable (with --strict), 2 = bad arguments. So it bolts straight into cron:

# Rebuild the team calendar from the shared sheet every night
0 22 * * * python csv2cal.py shared_deadlines.csv -o team.ics || echo "csv2cal failed" >&2

Your data stays local — bills, client names, and revenue dates never get uploaded to some free "CSV to calendar" web tool. The conversion happens on your machine, full stop.

The output is a standards-compliant .ics that imports cleanly into Google Calendar, Outlook, Apple Calendar, and Thunderbird.

The real fix is boring

Missing a late fee or a renewal isn't a discipline problem — it's a plumbing problem. Your deadlines already live in a structured file. They just need to be piped into the place you actually look every morning.

If you're a freelancer, founder, or ops person whose deadlines live in a spreadsheet — the full kit (converter + sample CSV + README with cron recipes) is on AgentChip. One-time purchase, no subscription, your data never leaves your machine.

Related: if your problem is meetings across time zones rather than deadlines in a sheet, that's a different converter — and we cover that too.

Customers Email You at 11pm. They Don't Wait Until 9am Anymore.

AgentChip — Sun, 13 Sep 2026 04:12:39 +0000

Here's a pattern every solo founder knows: you finish dinner, open your phone, and there are three customer emails from the last four hours — all sitting unanswered.

Two recent threads on r/smallbusiness described the same trap from opposite sides. One founder put an AI agent on their support inbox and now checks it constantly because "the agent only needs human help for about 90 seconds a day — but I don't know WHICH 90 seconds." Another just wanted customers who write at midnight to get something back before morning, without handing the whole inbox to a bot.

The uncomfortable truth: customers don't wait until business hours anymore. A lead who emails at 11pm and hears nothing until 9am has already visited your competitor's site. But a full 24/7 AI support agent is overkill (and a trust risk) for most small operations.

The middle ground nobody builds anymore

Not a chatbot. Not a human. An auto-responder with judgment:

It knows when you're off the clock (including cross-midnight shifts — 22:00–06:00 counts as "after hours" even though it spans two dates)
It sends a useful reply during those hours: matched from your own FAQ list, in the customer's language (English or Chinese), not a generic "we got your email"
It stays quiet during business hours — you answer those yourself, like an adult
It respects a whitelist (VIPs get flagged for you, not auto-answered) and never answers the same email twice (message-id dedup)
It has a daily send cap, so a mail loop or spam burst can't turn into 500 embarrassing auto-replies

What I built: a cron-sized after-hours responder

A single-file Python CLI (pure standard library — just imaplib and smtplib, zero pip installs) that does exactly the above:

IMAP in, SMTP out — works with any mailbox, including plain Gmail app passwords
Schedule windows — define your off-hours once; cross-midnight windows handled correctly
FAQ matching — keyword-scored against your FAQ file; matched → tailored reply, unmatched → polite "we'll reply first thing" with your response-time promise
--dry-run mode — preview exactly who would get what, before you let it send anything (this is the feature that lets you sleep at night)
Exit code contract — 0 = nothing to do, 1 = replies sent, 2 = error. Bolts straight into cron:

# Every 10 minutes, answer only what arrives after hours
*/10 * * * * python afterhours_responder.py --config faq.yaml --max-daily 40

Your credentials stay local — config lives in ~/.afterhours/, no third-party SaaS reads your inbox

Why this beats "I'll check in the morning"

The 11pm emailer isn't necessarily angry — they just expect acknowledgment. A specific, useful reply at 11:04pm ("yes, we support CSV import, here's the format") converts. Silence until morning doesn't. And unlike a full AI agent, this thing can't go rogue: it answers from your FAQ file, capped, whitelisted, and previewable.

If you run a small business, a side project, or an agency inbox that never sleeps — the full kit (responder + FAQ config + README with cron and Gmail app-password recipes) is on AgentChip. One-time purchase, no subscription, your inbox never leaves your machine.

Related: if your problem isn't after-hours email but knowing when a competitor changes their pricing page, we built a watcher for that too — same philosophy: one file, zero dependencies, cron-friendly.

Your Competitor Changed Their Pricing Page at 2am. You Found Out Next Week.

AgentChip — Wed, 09 Sep 2026 12:12:20 +0000

Ask founders how they track competitors and you'll hear the same answer: a spreadsheet and "I check when I remember."

A 52-post analysis on r/SaaS put it bluntly — competitor monitoring is spreadsheets and manual checks. Meanwhile competitors don't change on schedule. They change prices at 2am, quietly update their policy page on a Friday, and ship a feature on a holiday weekend. If your check-in cadence is "weekly-ish," you're structurally guaranteed to be the last to know.

What actually needs monitoring (and what doesn't)

You don't need an enterprise CI platform. For 90% of indie founders, the answer is a handful of pages:

The pricing page (the single highest-signal page on any competitor's site)
The changelog / blog (launches, pivots, new positioning)
The features page (what they're quietly adding)
Terms/policy pages (fine-print changes that foreshadow strategy shifts)

The problem isn't knowing which pages. It's that checking them by hand doesn't scale past "I remembered today."

What I built: a change watcher that runs itself

A single-file Python CLI (pure standard library, zero dependencies) that watches any list of pages and tells you exactly what changed:

Visible-text extraction — pulls readable content, filters out scripts, styles, nav bars and footer boilerplate so redesigns don't create false alarms
SHA-256 content fingerprints — stable per-page baseline; first run builds it, every run after compares
Line-level diff output — not just "something changed," but which lines were added and removed ("$49/mo" → "$59/mo" jumps out immediately)
Markdown or JSON reports — read it yourself, or pipe it into your dashboard
Exit code contract — 0 = no changes, 1 = changes detected, 2 = error. Which means it bolts straight into cron:

# Every morning at 7am, check all competitor pages
0 7 * * * python competitor_watch.py --config pages.txt --json || curl -s https://your-webhook.example/alert

Your data stays local — page list and baselines live in ~/.competitor_watch/, nothing is uploaded anywhere

Why "check when I remember" loses

Pricing changes are the cheapest competitive intelligence that exists — and the most expensive to miss. A competitor undercutting you by 20% costs you deals for as long as it takes you to notice. The fix isn't discipline, it's automation: a baseline, a fingerprint, and a cron entry.

If you're a founder, indie hacker, or marketer who's ever said "wait, when did they add that?" — the full kit (watcher + config management + README with cron recipes) is on AgentChip. One-time purchase, no subscription, your data never leaves your machine.

Related: if you also need to know when a competitor's site goes *down (vs. changes), that's a different job — uptime monitoring — and we cover that too.*

45 Startup Credits & Discounts in One Command (AWS, Stripe, Vercel, and 42 More)

AgentChip — Sun, 06 Sep 2026 20:42:52 +0000

Every startup program has a discount. Almost no founder claims them all.

AWS Activate gives you $5,000 in credits. HubSpot for Startups takes 90% off. Stripe gives free processing on your first $1M. Google Cloud, Vercel, Supabase, Mercury, Notion — they all have startup programs with real money attached.

The problem isn't that these programs don't exist. The problem is that they're scattered across 40+ websites, each with different eligibility criteria, different application processes, and different credit amounts. When you're shipping product at 2am, "spend half a day hunting startup credits" is never the priority that wins.

So I built a local, zero-dependency tool that puts 45 real startup programs in one command.

What it does:

45 programs, 8 categories — hosting (AWS, Google Cloud, Azure, Vercel, Supabase, DigitalOcean), AI (OpenAI, Anthropic, Cohere), communications (Twilio, SendGrid, Postmark), payments (Stripe, Mercury, Brex), dev tools (GitHub, GitLab, Sentry), analytics (Mixpanel, Amplitude, Segment), support (Intercom, Zendesk, Crisp), design (Figma, Canva, Webflow)
Category filtering — --category payment shows you every payment-related program with credit amounts and eligibility
Keyword search — --keyword stripe finds Stripe's program instantly without scrolling a 45-row table
JSON output — --json gives you machine-readable data for your internal wiki or automation
Export — --export md generates a full Markdown reference doc you can drop into Notion or Confluence
Custom entries — --add lets you append your own discovered programs to a local file without touching the built-in database

The real value isn't the list — it's the structure:

# What credits can I get for payments?
python3 startup_deals.py --category payment

# How much is Stripe giving?
python3 startup_deals.py --keyword stripe

# Full reference for the team wiki
python3 startup_deals.py --export md > startup_credits.md

Every entry includes the company, category, plan name, credit amount, eligibility requirement, and a direct link to the program page. No clicking through marketing pages to find the actual application form.

Built with Python stdlib only — no pip install, no dependencies, Python 3.8+. One-time purchase, free updates, instant download.

If you're a founder, a startup employee, or you help startups get set up (consultant, agency, accelerator), this saves you half a day of research every time someone asks "what credits can we get?" Grab it here: agentechip.com — it's in the store alongside the rest of the startup ops toolkit (LLM spend tracking, agent monitoring, AP duplicate payment detection).

Your runway is measured in months. Every credit you don't claim is a month you're burning for nothing.

4 AI Providers, 4 Dashboards, 1 Silent Budget Leak — Track Them in One Command

AgentChip — Thu, 03 Sep 2026 12:03:45 +0000

Your LLM bill is spread across four dashboards and you have no idea which model is eating the budget.

If you build on AI APIs, you know the drill: OpenAI has a usage page. Anthropic has a usage page. DeepSeek has one. Gemini has one. Your monthly "reconciliation" is you logging into each dashboard, squinting at charts, and trying to remember whether that $80 spike was the client project or the internal agent experiments.

Small teams can't afford a $500/mo FinOps platform. But you also can't keep flying blind — one runaway loop in a background agent can quietly burn a hundred dollars before anyone looks.

So I built a local, zero-dependency tracker that turns four messy CSVs into one answer.

What it does:

Auto column mapping — exports from OpenAI/Anthropic/DeepSeek/Gemini use totally different headers. It recognizes them all (Chinese headers too: 平台/模型/金额/币种/项目 — bilingual books are covered)
Multi-currency, unified — dollar rows, yuan rows, euro rows all converted to USD in one pass (built-in rates, overridable with --rate)
Five-dimension aggregation — by provider, by model, by project, by month, by day. "What did OpenAI cost this month" and "which model burns the most" are both one command
Budget alerts — set --budget 200 and it exits with code 1 the moment you're over. Hook it into cron and you get a daily budget watchdog for free
Filters — slice by provider/model/project/month with simple flags
Markdown + JSON reports, and it's 100% local — your usage data never leaves your machine

The exit-code contract is the real feature:

0 8 * * * python3 llm_spend_tracker.py --csv usage.csv --budget 200

Code 0 = under budget. Code 1 = over budget (cron fires an alert). Code 2 = bad input. That's a daily FinOps check on every AI spend, forever, with no subscription and no upload.

Built with Python stdlib only — no pip install, no dependencies, Python 3.8+. One-time purchase, free updates, instant download.

If you run agents, ship AI features, or just got surprised by a provider bill last month, grab it here: agentechip.com — it's in the store alongside the rest of the ops toolkit (agent process watchdog, backup verifier, uptime monitoring).

Your models are working for you. Make sure their bills are too.

Small Businesses Lose $1.5B/Year to Duplicate Payments. Catch Them in 5 Minutes

AgentChip — Wed, 02 Sep 2026 00:03:04 +0000

Your AP clerk is paying the same invoice twice and nobody knows.

That's not hypothetical. Duplicate payments are one of the quietest cash leaks in small business — the same invoice gets keyed in twice, two departments both pay the vendor, or a recurring charge is never cancelled after the first payment. American businesses lose an estimated $1.5B+ a year to duplicate payments alone. And the other half of the problem is the opposite: invoices that sit overdue for 90+ days because nobody is watching the aging report.

Here's the thing: QuickBooks and NetSuite both have aging reports. But pulling them out, mapping columns, and actually reviewing 200 rows of payables every week? Nobody does that. Excel formulas rot. The "accounting person" is usually the owner wearing a third hat.

So I built a local, zero-dependency tool that turns a boring CSV export into an AP watchdog in one command.

What it does:

Aging analysis — buckets every unpaid invoice into current / 1-30 / 31-60 / 61-90 / 90+ with amounts summed per bucket
Overdue alerts — lists every late invoice sorted by days overdue, and exits with code 1 so you can hook it into cron/CI and get alerted daily
Duplicate detection — flags invoices from the same supplier with the same amount within 14 days as suspicious duplicates, with the risk amount shown
Cash flow view — sums what's due in the next 30 / 60 / 90 days so a payment wall never sneaks up on you
Paid-invoice exclusion — already-paid rows (paid/closed/settled/已付) are automatically skipped
Markdown + JSON reports, filtering by supplier or min amount, and it's 100% local — your data never leaves your machine

It auto-detects Chinese column headers too (供应商/发票号/金额/开票日期), which is a nice surprise if your books are bilingual.

The exit-code contract is the real feature. Run it daily in cron:

0 8 * * * python3 ap_checker.py --csv payables.csv

Code 0 = clean. Code 1 = overdue or duplicate found (your cron fires an alert). Code 2 = bad input. You get a daily AP security guard for free, forever, with no SaaS subscription and no data upload.

Built with Python stdlib only (csv/argparse/json/datetime/collections) — no pip install, no dependencies, Python 3.8+. One-time purchase, free updates, instant download.

If you run a small business, do bookkeeping for clients, or just want to stop paying vendors twice, grab it here: agentechip.com — it's in the store along with the rest of the financial toolkit (invoice cleanup, cash flow forecasting, consignment tracking).

Your AP ledger is bleeding. It takes 5 minutes to find out.

Newsletters Are Still the Best ROI Channel — Here's How to Run One Without a SaaS Bill

AgentChip — Tue, 01 Sep 2026 16:14:53 +0000

You've heard it a hundred times: "start a newsletter, it's the highest-ROI channel." And it's true — an owned email list beats every rented feed. But when you actually try to start, the tooling gets in the way: $30+/mo for a SaaS, a template lock-in you'll outgrow in a month, and a platform that holds your subscribers hostage.

There's a simpler way to run a newsletter that works for small operators, and it costs nothing to keep running.

The boring stack that works

A newsletter really needs four things, and none of them require a subscription:

A subscriber list — a plain CSV or SQLite file you own. No export fees, no "your list is stuck here" surprises.
HTML emails that don't look like 2008 — a branded template you can render locally and preview before sending.
Sending — your own SMTP or a free-tier transactional provider. For a few hundred subscribers, free tiers are plenty.
Unsubscribe that works — a signed link that removes people instantly. Spam complaints kill deliverability fast, so a clean opt-out is non-negotiable.

That's the entire architecture. Everything else — analytics dashboards, A/B testing, fancy automation — is frosting you can add later.

The 1/3/7 rhythm that keeps lists alive

The fastest way to kill a newsletter is to send inconsistently. People forgive a short issue; they unsubscribe from silence. A fixed cadence (weekly is the sweet spot for indie builders) plus a short follow-up window for new signups turns a list into a habit.

Why this matters for indie builders

For a solo operator, a newsletter is the only channel where you own the relationship. SEO takes months, social feeds change algorithms overnight, but email is a direct line that compounds. Every subscriber you earn today is worth more in six months, and the compounding never resets.

I packaged this exact approach into a small, zero-dependency tool — subscriber management, branded HTML templates, dry-run previews, SMTP/Resend sending, and signed unsubscribe links. No SaaS, no lock-in, no data leaving your machine. It's part of the AgentChip product line, where every tool follows the same rule: pure local, standard library only, verified before shipping.

If you've been putting off starting your newsletter because the tooling felt heavy — this is the lightweight path. The hard part was always the writing, not the plumbing.

Originally published on the AgentChip blog.

Your AI Wrote That Code. It's Probably Full of Landmines.

AgentChip — Mon, 31 Aug 2026 20:08:28 +0000

AI-assisted coding is the fastest productivity jump most developers have ever experienced. You describe a feature, the model writes 200 lines, and it mostly works. The problem is the word mostly.

When a human writes code, they leave a trail of intent. When an LLM writes code, it leaves a trail of assumptions — and some of those assumptions explode in production weeks later, at 2 a.m., on a Friday.

Here's what I mean.

The five landmines AI code leaves behind

1. Swallowed exceptions. The model wraps a network call in try/except and prints nothing. The code "works" — until the API goes down and you spend three hours wondering why the job silently did nothing.

try:
    data = api.fetch(account_id)
except Exception:
    pass  # ← the landmine

2. Mutable default arguments. A classic Python trap that LLMs reproduce happily because it looks fine:

def add_tag(tags=[]):   # ← shared mutable state
    tags.append("new")
    return tags

3. eval() and exec() in the hot path. The model "simplified" your config parser by evaluating a string. Congratulations, you now have an injection surface.

4. Debugging leftovers. print(123), # TODO: remove, a hardcoded API key in a test file that ships to production.

5. Unused imports and shadowed names. Harmless-looking, but they rot the codebase and confuse the next human (or the next AI) that touches it.

Why your review process misses them

Two reasons. First, review fatigue — after the 50th AI-generated PR, your eyes glaze over. Second, these bugs are structural, not visual. except Exception: pass looks identical to a well-handled exception when you're skimming.

You need a tool that looks at the AST, not the diff.

The fix: scan your whole project in one command

This is the exact problem I built Bug Buster to solve — a local, zero-dependency static analyzer that walks your project's syntax tree and flags the nine rule classes that matter:

undefined variables
unused imports
mutable default arguments
swallowed exceptions
dangerous calls (eval, exec, shell=True, pickle)
debug leftovers
comparison traps
syntax errors
more

Run it on your repo, get a clean report:

python bug_buster.py src/ --report md

Exit code contract: 0 = clean, 1 = issues found. That means you can drop it into your CI pipeline and it behaves like a lint gate that actually catches the AI-specific bugs:

python bug_buster.py . || echo "Fix the landmines before merging"

Zero dependencies, pure Python stdlib, runs locally — your code never leaves your machine.

A quick reality check

The analyzer isn't magic. It won't understand business logic, and it can't tell you why a design decision is wrong. But that's exactly why it's useful: it handles the boring, mechanical, detectable class of bugs — the ones that survive human review because they're invisible in a diff — so your review energy goes to the parts that need judgment.

A single swallowed exception in a batch job costs more in debugging time than this tool costs in cash. If you're doing any serious amount of AI-assisted coding, add a static pass to your workflow. Your future self (and your on-call rotation) will thank you.

Try Bug Buster free updates and more AI-era dev tools at agentechip.com.

The 40 Seconds That Matter in a 1-Hour Podcast (and How to Find Them)

AgentChip — Mon, 31 Aug 2026 00:22:24 +0000

Every podcaster knows the feeling: the episode is done, the audio is clean — and now you have to find the 40 seconds worth clipping for Shorts, Reels, or TikTok. So you drag the progress bar, listen, drag again, listen again. An hour of audio can eat an afternoon.

The frustrating part isn't the editing. It's the finding. Most tools that promise to fix this either upload your audio to the cloud (privacy + subscription) or lean on AI transcription APIs that bill you per minute of audio. For a hobby podcast or a small creator channel, that's a non-starter.

The simple physics of highlights

Turns out there's a much more boring, much more reliable signal: people get louder when they say something worth clipping. A guest's best story, the host's hot take, the payoff of a long setup — they all register as short bursts of higher RMS energy against the surrounding conversation.

So instead of listening to the whole episode, I wrote a tool that does the listening for you:

Reads a 16-bit PCM WAV file frame by frame (100 ms frames by default)
Smooths the energy curve with a sliding window so coughs and one-off noises don't register
Finds contiguous regions above the threshold and merges adjacent ones
Ranks the candidates by energy strength and outputs the Top N highlights

The whole scan runs in about 30 seconds on a typical episode — and the output is a checklist you can act on immediately.

Output that's actually actionable

Here's what the report looks like:

## 片段 1: 12:34 - 13:05 (时长 31.0s, 强度 2.34x)
ffmpeg -ss 12:34 -to 13:05 -i episode.wav -c copy clip_01.mp3

Copy the ffmpeg command, paste it into a terminal, done. One command per clip. No editing timeline, no export dance, no cloud upload.

A few knobs for different content styles:

--frame-ms — finer frames for fast-paced content, coarser for calm interviews
--window-sec — bigger smoothing window if your speaker ramps up slowly
--min-duration — filter out coughs and one-word interjections
--top N — get more or fewer candidates per episode

Why local matters

Your raw episode is often unreleased or contains client conversations. Sending it to a third-party service to get a clip list back is a real privacy decision. This tool never moves your audio anywhere — the WAV stays on your machine, the energy analysis happens in memory, and the only thing that leaves your terminal is the ffmpeg command you choose to run.

The full kit

The tool is a single-file Python CLI, pure standard library, zero dependencies — it runs anywhere Python 3.8+ runs. It's part of the AgentChip toolkit: a growing library of small, local-first tools for people who build and create. One-time purchase, free updates, instant download.

Your episode has 60 minutes of audio and maybe 2 minutes worth clipping. Now you can find them in half a minute.

Originally published on the AgentChip blog.

Your Drive Is Full of Files You Already Have. Here's a Safe Way to Find Them

AgentChip — Sat, 29 Aug 2026 20:11:48 +0000

Every hard drive has a hoarding problem. Camera bursts save 40 near-identical photos. Backup scripts copy the same folder into three locations. Downloads accumulate the same installer under different names. Before you know it, a 2 TB drive is "full" — and you can't actually point at what's eating the space.

The usual advice is to run a duplicate finder. But here's what nobody tells you: most duplicate finders are dangerous or useless at scale. They either hash every byte of every file (slow on big drives), or they group by size only and delete things that merely look alike.

The two real problems

1. False positives. Two files with the same size are not the same file. A size-only "duplicate" scan will happily flag two different 8 MB PDFs as identical. If you act on that, you delete data.

2. No undo. Many tools delete duplicates on the spot. One misclick and your original is gone — the "duplicate" you kept was actually the one with the newer comments.

What I built: a cautious duplicate finder

A single-file Python CLI (pure standard library, zero dependencies) that treats your files like evidence, not junk:

Two-stage hashing — group candidates by size first, then confirm with SHA-1, and optionally re-verify the survivors with SHA-256 before reporting. No byte-for-byte hash, no false "duplicate" verdict.
Report first, act never — default mode writes a Markdown/JSON report and touches nothing.
A quarantine directory instead of delete — --delete-to moves duplicates to an isolated folder, keeping the first copy in place. You get your space back and a full undo path if you change your mind.
--dry-run before anything destructive, plus --exclude and --min-size filters for the noise (skip system dirs, only scan files above 1 MB, etc.).
Exit code contract — 1 when duplicates are found, so you can hook it into cron or CI and get alerted that your backup dir is breeding copies again.

# Scan and report only (the safe default)
python duplicate_finder.py --dirs ~/Photos ~/Backups

# Move confirmed duplicates to a quarantine dir, keeping one copy of each
python duplicate_finder.py --dirs ~/Photos --delete-to ~/dupes_quarantine --dry-run

# Reclaim the space for real
python duplicate_finder.py --dirs ~/Photos --delete-to ~/dupes_quarantine

Fully local — your file list never leaves your machine, which matters when the drive in question contains client documents or family photos.

Why "cautious" wins

The best dedup tool isn't the one that deletes the most. It's the one you trust enough to run on a drive you actually care about. Size-group + double-hash confirmation + quarantine-with-undo is that trust. The full kit (scanner + quarantine + JSON/Markdown reports + docs) is at AgentChip.

Your storage is finite. Your duplicate copies aren't.

Originally published on the AgentChip blog.

I Run a 26-Product Digital Business With a Self-Healing Pipeline (Almost No Manual Work)

AgentChip — Fri, 28 Aug 2026 12:14:35 +0000

A few months ago I was doing the solo-developer dance: write a tool, zip it, write a sales page, upload it, update the README, check the site, fix the site, repeat. Every product launch was a two-hour manual ritual with a dozen places to drop something.

Today I run a 26-product digital goods store plus a content site with 3,000+ articles, and the only thing I touch manually is the occasional strategy decision. Everything else — generation, packaging, listing, monitoring, recovery — runs itself. Here's the stack that made it possible.

1. One factory script per product family

Every product is generated by a deterministic, re-runnable build script (Python, pure stdlib where possible — zero dependencies means zero pip install breakage in someone else's environment).

# build_my_tool.py — idempotent, re-runnable
# generates the tool, the README, the sample data, the zip, the cover art
# runs a built-in verification suite before emitting anything

Each builder runs its own validation before packaging: py_compile, real executions against sample data, exit-code contracts (0 = ok, 1 = something found, 2 = bad input). If verification fails, nothing gets emitted. The zip that reaches the store is the exact zip that passed the checks.

2. A cron factory does the listing

A nightly cron job takes the next item from a product queue and does the whole listing flow on Gumroad — via a Playwright session on a VPS that reuses a saved login. No API needed, no OAuth dance, no rate-limit anxiety.

The key detail: the listing script is built from a template of the previous successful listing. Every successful launch teaches the template one more edge case (this page has no Publish button, use the share page; wait 5s for the redirect; verify with a buyer-view curl afterward).

3. Verification is part of the pipeline, not an afterthought

After each listing, a buyer-view curl checks: HTTP 200, correct price, is_published=true, and the presence of the key descriptive keywords in the rendered page. If the buyer can't see it, the job is not done.

curl -s https://store.example.com/l/xyz | grep -c 'is_published.*true'

4. Monitoring + self-healing

Watchdog crons check the health of the trading terminal, the VPN tunnel, and the content generator every few minutes. Failed = auto-restart or alert.
The content generator produces ~30-40 articles/day; a periodic check verifies the article count is increasing and the sitemap matches.
The email inbox is checked on a schedule for real orders vs. noise (verification codes, spam).

5. The "no-API desktop software" special case

Some of the most valuable automation targets have no API at all — a Windows-only trading terminal, a desktop chat app. The playbook there: UI automation, state-file parsing, watchdog/self-healing around the process. It's slower to build and it's a moat — most engineers won't touch it, which means the ones who can are in demand.

Why this matters if you hire engineers

The pipeline above isn't about selling tools — it's a proof that I can take a manual process and make it reliable by construction: deterministic builds, verification gates, exit-code contracts, monitoring, self-healing. That exact skill set is what any company building agentic workflows needs, whether it's AI agents for accounting, trading, or support.

If you're building something that needs automation, evaluation, and human-approval loops built in — or you just want the tools and the writeups — everything I've learned is at AgentChip.

The point isn't the products. The point is that a business can be a system — observable, verifiable, recoverable — instead of a pile of manual rituals.

Originally published on the AgentChip blog.