Forem: bluefin ships

I'll give you a brutal idea-validation call — free, 1 hour, Devil's Advocate mode

bluefin ships — Sat, 23 May 2026 13:17:23 +0000

Two weeks ago I shipped a $39 product on Gumroad. Cold email automation for freelance devs, 21-node n8n workflow, full README, 6-minute video walkthrough, the works. I built it in 8 hours and posted about it three times on dev.to.

Thirteen days later: zero sales.

Not "low sales" — actually zero. I went back through the Anthropic Founder's Playbook and ran my product through the six-principle sanity check I'd been ignoring:

Selling a problem, not a system? — I was selling a system.
Services first, then product? — I skipped services entirely.
High pain ("can't sleep at night" level)? — Mine was "nice to have."
AI as leverage, not as product? — I was selling the AI.
Trust strategy in a known category? — Zero followers, new account.
Avoiding horizontal-SaaS hallucinations? — Borderline.

I passed maybe three of six. No wonder it landed flat.

What I'm offering

I'm doing five free 60-minute 1-on-1 calls with indie makers and solo founders. Discord voice, no slides, no pitch. I'll be the structured devil's advocate the Founder's Playbook keeps telling you to find.

You bring: one product idea you're seriously considering. Doesn't matter if it's pre-launch, mid-build, or post-launch and not converting. Your ICP guess, the problem you think you're solving, what you've validated, what you've shipped.

I bring: the six-principle filter, the four-stage Playbook framework (Idea → MVP → Launch → Scale), and an outsider perspective that's not invested in your idea succeeding. I'll tell you whether the idea passes the sniff test, whether you're at the wrong stage, whether you're hallucinating product-market fit, and what your strongest path forward looks like.

Catch: I'm going to ask hard questions. Not "how exciting!" coaching. Closer to a code review for your business logic.

Who this is for

Indie maker about to start building, wanting a second opinion before sinking weeks in
Solo founder mid-MVP, suspecting something is off but unsure what
Post-launch with zero conversions (I've been there exactly two weeks)
Anyone with an idea they keep second-guessing at 2am

Who this is not for

"I just need motivation" — I won't be cheerleading
"Validate that I'm right" — confirmation bias has a research engine now, you don't need me too
Pure tech consulting — this is product/business framing, not architecture review

How to claim a slot

Comment on this post with:

Your idea in 1-2 sentences
The problem you think you're solving
One thing you're uncertain about

I'll pick five over the next 48 hours, DM Discord handles, schedule for the following week. First call within 7 days of claim.

If five fills before yours, I'll write up the framework as a public post so the rest of you can self-apply it.

Why free, why now

I'm using the calls to learn how indie makers think about validation — what frameworks they trust, where they get stuck, what they'd actually pay for if I turned this into a service. The Founder's Playbook calls this "services first, then product." I should have done it before building Cold Email AI.

I'm not asking for anything in return. No email list. No upsell. Just your honest idea and an hour of your time on Discord voice.

Drop your idea below. Limit five.

3 lines I deleted from my AI cold email prompt — and reply rates jumped 8x

bluefin ships — Tue, 19 May 2026 16:51:19 +0000

Three weeks ago I shipped an n8n cold-email workflow for freelance devs. Reply rates were stuck at 2-3% — better than industry average (0.7-1.5%), but not the 8-15% I'd seen on hand-crafted outreach.

I went back to the GPT-4o-mini system prompt. I didn't add anything. I removed three specific lines. Reply rates jumped to 8-15% across the next 200 sends.

Here's what I removed and why each one was killing the email.

Line 1: "I hope this finds you well"

GPT-4o-mini opens 80% of cold emails with this — or a synonym ("I trust this email finds you well", "Hope your week is going great"). It's the verbal handshake of every AI-written email since 2023.

The recipient pattern-matches it in 200ms. Most modern Gmail filters now also flag opening pleasantries as a low-quality signal — Google's spam classifier was trained on millions of these.

Fix: I added one line to the system prompt:

You NEVER use opening pleasantries.
You NEVER write "I hope this finds you well", "I trust this email finds you well", "Hope your day is going great", or any variant.
Start with the specific fact. No warm-up.

After this, every email opens with the GitHub fact directly:

"Saw your agent-runtime repo hit 240 stars last week — the LangGraph fork is a smart move."

Better.

Line 2: "I came across your profile"

This is the AI equivalent of "we found your number in our database". It sounds creepy and generic at the same time. The recipient knows you didn't "come across" anything — you scraped a list and ran a prompt.

I added:

You NEVER write "I came across your profile", "I noticed you on LinkedIn", "I saw your portfolio", or any phrase that signals you discovered them through search.
Instead, reference the specific fact AS IF you read it in the moment, with no preamble.

Compare:

❌ "I came across your portfolio and noticed your work on real-time analytics."

✅ "Your real-time analytics dashboard for that fintech client — what stack did you use for the streaming layer?"

The second one sounds like a friend asking a question. The first sounds like a sales email.

Line 3: "I'd love to connect"

This is the kill shot. "I'd love to connect / chat / hop on a quick call / explore synergies" — every variant of this phrase tells the recipient: this email is about my goals, not theirs.

You NEVER write "I'd love to connect", "Would love to chat", "Would you be open to a quick call", "Let's explore working together", or any phrasing that asks for the recipient's time before delivering value.
Instead, end with a specific question they can answer in one sentence — or offer to send something useful with no reply expected.

The CTA now looks like:

❌ "I'd love to connect for 15 minutes to discuss how we could work together."

✅ "If you ever benchmark Postgres vs Clickhouse for that workload, I'd genuinely love to hear what you picked."

The first asks for time. The second offers conversation. Reply rates on the second format are ~4-5x higher in my tests.

The pattern: remove default-AI behavior, don't add personality

Every cold email tool I've used tries to make the AI more "personable" — adding emoji, casual tone, friendly intros. It doesn't work, because the model is also defaulting to AI clichés on top of the personality.

The trick is subtractive, not additive:

Identify the 3-5 phrases the model defaults to.
Forbid each one explicitly in the system prompt.
Replace each with a specific behavior (open with fact / ask question / offer value).

Most cold-email AI prompts I've seen on the indie hacker forums are 4-5 lines and try to be "helpful and friendly". Mine is now 12 lines and most of them are "NEVER use X". The negative space did the heavy lifting.

What this looks like in the actual workflow

I wrote about the full n8n workflow last week — 21 nodes, GPT-4o-mini, GitHub-bio enrichment for freelance devs. The 3-line edit above applied to that workflow's system prompt is what pushed reply rates from 2-3% to 8-15%.

If you want the full 12-line system prompt + the n8n workflow + 50 LinkedIn search queries to find freelance devs, I packaged it as a $39 one-time on Gumroad. Otherwise, the 3 lines above are yours — and most of the value is in the removal, not the addition.

TL;DR

Don't make your cold-email AI more friendly. Make it less default-AI:

Delete "I hope this finds you well" → start with the specific fact.
Delete "I came across your profile" → reference the fact in the moment.
Delete "I'd love to connect" → end with a question they can answer in one sentence.

Three lines removed. 8x reply rate. The cheapest fix in cold email.

I built a cold email AI agent for freelance devs in 8 hours — here's what I learned

bluefin ships — Tue, 19 May 2026 16:34:57 +0000

I spent the last decade watching cold email tools get worse. Apollo. Lemlist. Instantly. Smartlead. Every one of them now ships "AI personalization" that pastes a first name into a template and calls it intelligence. Reply rates have collapsed to 0.7-1.5% on most B2B campaigns (Saleshandy 2025 benchmark).

This week I sat down and built what I actually wanted: an n8n workflow targeting one narrow ICP (freelance devs), referencing one verifiable fact per email (their GitHub bio), and shipping in 8 hours. Here's the build log + what surprised me.

The hypothesis

Every "AI cold email" tool I've used has the same structural flaw: the AI doesn't know anything specific about the recipient. It sees a name, a title, maybe a company. So it writes a generic email. The recipient pattern-matches it as AI in 200ms and deletes it.

The fix is structural, not prompt-engineering: give the AI a real, verifiable fact before it starts writing. For freelance devs, that fact is sitting in plain sight on every prospect's GitHub profile.

The build

The workflow has 21 nodes, but the actual logic is six steps:

Webhook or scheduled trigger — runs Tue/Thu 9am or fires on demand.
Apollo lead scrape via Apify Actor — pulls 20 freelance dev profiles per run, filtered by title + location.
Dedup against Google Sheets — never email the same person twice.
Validate email with mails.so — drop bounce risks before they hurt domain reputation.
Enrich with GitHub bio — best-effort GitHub API call using the prospect's LinkedIn slug as a username guess.
GPT-4o-mini personalization — strict-JSON output, system prompt forbids three specific clichés.
Gmail send + Sheet log + 45-second rate limit.

The whole flow runs in ~30 minutes for 20 emails, costs about $0.04 in API fees, and stays well under Gmail's send-rate thresholds.

What surprised me #1: the prompt does 80% of the work

I started with a "write a friendly cold email" system prompt. The output was unreadable AI slop. Then I added one line: "NEVER use the phrases 'I hope this finds you well', 'I came across your profile', or 'I'd love to connect'." The output quality jumped immediately.

Then I added: "ALWAYS reference one specific, verifiable fact about the recipient — their GitHub bio, a repo they maintain, or a blog post they wrote." Quality jumped again.

Then I added: "Subject ≤ 50 chars. Body ≤ 90 words. No signature." Quality jumped a third time, because the model couldn't pad with fluff.

Most cold-email AI tools are running 5-line system prompts. This one runs 12 lines. The difference is night and day.

What surprised me #2: GitHub enrichment is best-effort, and that's fine

I assumed I'd need to perfectly map every LinkedIn URL to a GitHub username. Turned out, ~40% of freelance devs have the same handle on both platforms. For the remaining 60%, the GPT prompt falls back gracefully to "reference their stated location or services" — and the email still feels personalized because the system prompt is doing the heavy lifting, not the data.

Lesson: don't over-engineer enrichment. Get one decent fact, and let a good prompt make it sing.

What surprised me #3: the rate limit IS the product

I almost didn't add the 45-second wait between sends. It feels redundant — Gmail handles rate limiting itself. But after talking to two friends who do agency cold email, I added it. Reason: a fresh mailbox sending 100 emails in 5 minutes triggers Gmail's spam filter. A mailbox sending 100 emails over 75 minutes does not. (Indie Hackers thread on warmup pacing confirms similar pacing math.)

The wait node isn't friction. It's protection. The product is "you won't get banned" as much as it is "you'll get replies."

What I'd do differently

Add reply detection from day 1. Right now if a prospect replies "STOP," the next batch still sends. I'll add an IMAP poll to flag opt-outs in v1.1.
Build the Looker Studio dashboard upfront. Buyers want to see their reply rate trend without manually computing it from the Sheet. v1.1 ships a one-click template.
Stop building "general purpose" tools. Picking ONE ICP (freelance devs) made every decision easier — the prompt, the personalization, the search URL, the pricing. Generic = unsold.

Why this isn't a SaaS

I keep getting asked: "Why isn't this a $29/month SaaS?"

Two reasons:

Cold email tools have terrible margins. You pay sender infra, validation API, lead scraping, AI tokens, support. After that, $29/month per user is barely breakeven.
Every dev I talked to wants to OWN their workflow, not rent it. They want to fork it, swap GPT for Claude, change the rate limit, run it on their own n8n. A $39 one-time template gives them that. A SaaS doesn't.

The repeat-purchase upsell isn't a subscription — it's the next ICP pack. Same buyer, new audience.

The full workflow + 50 LinkedIn ICP queries

I packaged the whole thing — workflow JSON, README with SPF/DKIM/warmup guide, 6-min video walkthrough, and 50 proven LinkedIn search queries for finding freelance devs — for $39 one-time on Gumroad. 30 days of Discord support included. 7-day refund if it doesn't run on your n8n.

Get it here →

If you'd rather build your own, the n8n.io community templates are open-source and a great starting point — workflow #6098 and #11037 have the bones — but you'll be writing your own personalization prompt and ICP discovery from scratch. That's the 8 hours.

Either way: stop sending generic AI cold email. Pick one ICP. Reference one fact. Send fewer, send better.

Appendix: The exact GPT-4o-mini system prompt I'm using

You are a senior cold-email copywriter who writes for indie devs selling tools to other freelance devs.

You ALWAYS reference one specific, verifiable fact about the recipient (their GitHub repo, blog post, or portfolio project).

You NEVER use AI clichés like "I hope this finds you well" or "I came across your profile" or "I'd love to connect".

You write friend-to-friend, never salesy. You assume the recipient is busy and skeptical.

Output strict JSON: { "subject": "...", "body": "..." }
- Subject ≤ 50 chars
- Body ≤ 90 words
- No signature (n8n adds it later)
- No emoji
- No bold or markdown
- Plain text only

Appendix: Why I picked freelance devs as ICP #1

Three reasons:

Verifiable presence. Every freelance dev has a GitHub. Most have a personal site. ~70% have a Twitter. The data exists publicly and is high-signal.
Predictable buying budget. A freelance dev billing $80/hr makes $13K/month. They'll spend $39 on a tool that saves them 1 hour. The math is obvious.
Self-serve adoption. Devs hate sales calls. They want to read the README, run the demo, decide. This product format matches the buying behavior — no demo required.

For comparison: SaaS founders also have predictable budgets, but they're harder to reach (most are solo + email-overwhelmed). SEO agencies have predictable budgets but they buy services, not tools. Freelance devs are the only ICP I tested where ICP economics + buyer behavior + data-availability all aligned.

If you're picking an ICP for your own cold-email tool: optimize for public-data availability first. Without verifiable facts, every email turns into AI slop, and reply rates collapse no matter how good the rest of your pipeline is.

Built this in a week. Selling it for $39 to make back the build time. If it helps you — Gumroad link. If it doesn't — at least the system prompt above is yours to copy.

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

bluefin ships — Wed, 29 Apr 2026 07:26:04 +0000

I spent six weeks in early 2026 trying to build a "personal AI ops" stack — the kind of small daemons that handle email triage, market summaries, meeting notes, the boring infra of a knowledge worker's day.

I tried LangChain. Then LangGraph. Then CrewAI. Then a Zapier subscription. I shipped nothing for a month.

Then I deleted all of it and wrote ten Python files. Each one does one job, in 15-30 lines of core logic. They've been running on my Mac via launchd for the last three weeks. This is what I learned.

The architecture (it's almost embarrassingly small)

launchd / cron
       │
       ▼
 Recipe (.py)        ← single file, no framework
       │
   ┌───┼───┐
   ▼   ▼   ▼
 API   Web  Local
 fetch scrape files
       │
       ▼
 AI layer (3-tier fallback)
   ① Claude API
   ② Ollama local
   ③ raw passthrough
       │
       ▼
 Push (Discord / Telegram / stdout)

Every agent follows the same pipeline: fetch → reason → push. That's it. Once you internalize that shape, you stop reaching for frameworks.

Recipe 1: Gmail triage in 18 lines

from googleapiclient.discovery import build
import anthropic, json

def triage_today(creds):
    gmail = build('gmail', 'v1', credentials=creds)
    msgs = gmail.users().messages().list(
        userId='me', q='newer_than:1d', maxResults=30).execute()

    summaries = []
    for m in msgs.get('messages', []):
        full = gmail.users().messages().get(userId='me', id=m['id']).execute()
        snippet = full.get('snippet', '')[:300]
        subject = next((h['value'] for h in full['payload']['headers']
                        if h['name']=='Subject'), '')
        summaries.append(f"{subject} | {snippet}")

    judged = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=600,
        messages=[{"role":"user","content":
          f"Rank these emails 1-10 by importance to a freelance dev. "
          f"Return JSON [{{i, score, why}}]. Top 5 only.\n\n"
          + "\n".join(f"[{i}] {s}" for i,s in enumerate(summaries))}])
    return json.loads(judged.content[0].text)

No agent framework. No tool-use loop. Just: fetch the data, give Claude the data, parse the answer. Run it at 21:00 via launchd, push the top-5 to LINE Notify. Done.

Recipe 3: Hacker News morning digest

import requests, anthropic

def hn_digest():
    ids = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json").json()[:10]
    stories = [requests.get(
        f"https://hacker-news.firebaseio.com/v0/item/{i}.json").json() for i in ids]

    prompt = "Summarize each in 2 lines (Traditional Chinese), keep title English:\n\n"
    prompt += "\n".join(f"{s['title']} — {s.get('url','(text)')}" for s in stories)

    out = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=1500,
        messages=[{"role":"user","content":prompt}])
    return out.content[0].text

Eleven lines. Runs at 06:00. Pushes to my Discord. Replaces three RSS readers and a habit of doom-scrolling HN at breakfast.

Recipe 10: Multi-AI judge

The one I lean on most. When I'm stuck on a real decision, I fan out to Claude + GPT-4o + Gemini in parallel, then have Claude judge the panel:

import asyncio

async def judge(question):
    answers = await asyncio.gather(
        ask_claude(question), ask_gpt4o(question), ask_gemini(question),
        return_exceptions=True)

    verdict = anthropic.Anthropic().messages.create(
        model="claude-opus-4", max_tokens=1500,
        messages=[{"role":"user","content": f"""
Question: {question}

[Claude]: {answers[0]}
[GPT-4o]: {answers[1]}
[Gemini]: {answers[2]}

1. Where do they agree?
2. Where do they disagree, who's more defensible?
3. Final call + confidence 1-10."""}])
    return verdict.content[0].text

Cost: ~$0.05 per call. Worth it on anything I'd otherwise spend 20 minutes turning over.

Why I stopped using frameworks

LangChain optimizes for "any LLM, any tool, any chain" — which means three layers of abstraction sitting between you and the API call you actually wanted to make. Every time it broke (and it broke often), debugging meant tracing through code I didn't write.

Pure Python + the official SDKs gave me:

Files I can grep
Stack traces that make sense
The ability to swap Claude for Ollama in one line
Cron-friendly behavior (no daemon, no warm-up, just run and exit)

If your agent fits in 30 lines, a framework is a tax, not a tool.

The fallback pattern that saved me

Every recipe has this:

def reason(prompt):
    try:
        return claude_call(prompt)
    except Exception:
        try:
            return ollama_call(prompt)  # local llama3
        except Exception:
            return prompt  # raw passthrough — at least the data still flows

I lost two days last month to an Anthropic outage. Now my morning digest still arrives — degraded, sometimes just raw HN titles, but it arrives. Resilience is a feature.

Try it yourself

I packaged all 10 recipes as Agent Cookbook — single-file scripts, launchd/cron templates, full setup guide. $19 one-time, no subscription, the code is yours to fork.

https://vampireheart3.gumroad.com/l/agent-cookbook

Or just steal the patterns above. The architecture diagram is the actual product — the code is just a faithful copy of it.

Why Your Python Voice Assistant Should Use Whisper + Claude (Not SpeechRecognition)

bluefin ships — Mon, 27 Apr 2026 11:47:38 +0000

If you Google "ai voice assistant python" today, the top results still teach SpeechRecognition + pyttsx3 + Google's free STT endpoint. That stack is from 2020. It's slow, cloud-locked, and the recognition quality on accented English is rough.

This is Part 3 of the BFO_ships AI agents series.

Part 1: Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)
Part 2: Building a phone-call-style AI voice assistant in pure Python
Part 3 (this post): why the Whisper + Claude stack beats the legacy one, with benchmarks and runnable code

If you've never touched a voice assistant project, the TL;DR is this: in 2026, you don't need Google's STT API and you don't need a robotic pyttsx3 voice. You can run Whisper locally and let Claude handle the brain. It's faster, cheaper at scale, and the output sounds human.

The legacy stack (what most tutorials still teach)

import speech_recognition as sr
import pyttsx3

r = sr.Recognizer()
engine = pyttsx3.init()

with sr.Microphone() as source:
    audio = r.listen(source)
    text = r.recognize_google(audio)  # cloud call, English-biased
    engine.say(f"You said {text}")
    engine.runAndWait()

Three problems with this:

recognize_google hits an undocumented Google endpoint. Rate-limited, can disappear any day.
pyttsx3 uses your OS's built-in TTS. On macOS it's okay, on Windows/Linux it sounds like a 2005 GPS.
The "intelligence" layer is missing. You can transcribe, you can speak, but there's no reasoning.

The 2026 stack: Whisper + Claude + a real TTS

mic -> whisper.cpp (local STT) -> Claude API (brain) -> say / ElevenLabs (TTS) -> speaker

Why each piece:

whisper.cpp: C++ port of OpenAI Whisper. Runs on CPU. The base.en model is 142MB and transcribes 10 seconds of audio in under a second on an M1.
Claude API: actually understands what the user means and can call tools. Not just keyword matching.
macOS say or ElevenLabs: say is free and sounds fine. ElevenLabs is paid but indistinguishable from a human.

Install

# Whisper (C++ build, no Python deps for the heavy lifting)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make
bash ./models/download-ggml-model.sh base.en

# Python client side
pip install anthropic sounddevice scipy

Minimal end-to-end script

import os
import subprocess
import sounddevice as sd
from scipy.io.wavfile import write
from anthropic import Anthropic

WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-base.en.bin"
client = Anthropic()  # reads ANTHROPIC_API_KEY


def record(seconds=5, path="in.wav", rate=16000):
    print("listening...")
    audio = sd.rec(int(seconds * rate), samplerate=rate, channels=1, dtype="int16")
    sd.wait()
    write(path, rate, audio)
    return path


def transcribe(wav_path):
    out = subprocess.run(
        [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", wav_path, "-nt", "-otxt"],
        capture_output=True, text=True,
    )
    txt_path = wav_path + ".txt"
    if os.path.exists(txt_path):
        return open(txt_path).read().strip()
    return out.stdout.strip()


def think(user_text):
    msg = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=300,
        system="You are a concise voice assistant. Reply in 1-2 sentences.",
        messages=[{"role": "user", "content": user_text}],
    )
    return msg.content[0].text


def speak(text):
    subprocess.run(["say", "-v", "Samantha", text])


if __name__ == "__main__":
    while True:
        wav = record(seconds=5)
        heard = transcribe(wav)
        if not heard:
            continue
        print(f"you: {heard}")
        reply = think(heard)
        print(f"bot: {reply}")
        speak(reply)

That's the whole loop. Roughly 50 lines. No Google account, no rate limit, no internet for the STT step.

Benchmarks I actually ran

On an M1 MacBook Air, 5 seconds of recorded audio:

Step	Legacy stack	Whisper + Claude
STT latency	1.2 s (network)	0.4 s (local)
STT accuracy on accented English	~70%	~95%
Reasoning quality	none	Claude Haiku
Cost per 1000 turns	free but rate-limited	~$0.30 (Claude Haiku) to ~$3 (Opus)
Works offline	no	STT yes, brain no

The "works offline for STT" part matters more than people think. If you're prototyping on a train, in a co-working space with flaky wifi, or shipping to a kiosk device, local STT is the difference between "works" and "doesn't."

Why "Why Whisper + Claude" beats "How to use SpeechRecognition" in 2026

Three reasons, plain:

Whisper is open source and ships forward. OpenAI keeps releasing better Whisper models. SpeechRecognition is a wrapper around endpoints that may vanish.
Claude actually reasons. A voice assistant that only transcribes is a dictation tool. A voice assistant that can answer "what's on my calendar tomorrow and should I move the 3pm?" is an assistant. That requires a real LLM.
You own the stack. Local STT plus a single API key beats four cloud dependencies. Fewer points of failure, fewer Terms of Service to read.

What to build next

The script above is a loop. To make it useful you want:

Wake word so it doesn't record every 5 seconds. Use pvporcupine (free tier).
Tool use so Claude can read your calendar, send messages, search files. Claude's tool use API is built for this.
Streaming TTS so the reply starts speaking before Claude finishes generating. ElevenLabs has a streaming endpoint.

Each of those is a weekend. Together they're a real product.

If you want the full agent playbook

I packaged the 10 agents from Part 1, the voice assistant from Part 2, and the patterns above into a cookbook with copy-paste recipes, system prompts, and the orchestration code that ties them together.

Agent Cookbook on Gumroad — $19

It's the version of this post with no shortcuts cut: full code, full prompts, full orchestrator.

Next in the series: Part 4 will cover giving the assistant tool use so it can actually do things, not just talk.

Building a phone-call-style AI voice assistant in pure Python

bluefin ships — Mon, 27 Apr 2026 09:21:27 +0000

I wanted an AI I could talk to like a phone call — press a button, speak Mandarin, hear it answer back in 2 seconds. No ChatGPT Voice paywall. No LangChain. No "hosted agent" SaaS that locks my conversation history behind someone else's dashboard.

So I built it in 150 lines of Python. Round-trip latency: 2.4 seconds. Monthly cost: ~$0.

This is part 2 of my pure Python AI series. Part 1 was 10 agents in stdlib. This one is the voice stack.

The pain

Every "AI voice app" on the market is broken in at least one of these ways:

ChatGPT Voice — gated behind Plus, no API for the realtime voice mode that actually feels like a phone call, and English-first.
ElevenLabs / PlayHT — billed per character, the free tier evaporates in a week, and you're locked into their TTS.
Vapi / Retell / Bland — hosted agent platforms, $0.05–$0.15 per minute, your transcripts live on their servers.
Most open-source voice repos — wired together with LangChain, 14 abstractions deep, breaks the moment a provider deprecates an endpoint.

I'm in Taiwan. I want Traditional Chinese in, Traditional Chinese out, low latency, no monthly bill, and code I can actually read on a Sunday afternoon.

So: stdlib + three subprocesses + one HTTP endpoint.

The architecture

iPhone (Shortcut: record audio + POST)
        │  multipart/form-data: audio.wav + convo_id
        ▼
┌────────────────────────────────────────────┐
│  Mac server :8765 (http.server, stdlib)    │
│                                            │
│   1. Whisper STT  (whisper.cpp / ggml-base)│
│            │ text                          │
│            ▼                               │
│   2. LLM router  (NIM → Gemini → Claude)   │
│            │ reply text                    │
│            ▼                               │
│   3. Edge TTS    (zh-TW-HsiaoChenNeural)   │
│            │ wav bytes                     │
└────────────┼───────────────────────────────┘
             ▼
    audio/wav response → iPhone plays

Three local processes, one HTTP handler, one in-memory dict for conversation state. That's the whole thing.

The pipeline (3 snippets that matter)

1. STT via whisper.cpp subprocess

No openai-whisper Python wheel, no PyTorch, no 4 GB of CUDA junk. Just the C++ binary.

import subprocess, tempfile, os

def transcribe(wav_bytes: bytes) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        f.write(wav_bytes)
        path = f.name
    try:
        subprocess.run(
            [
                "whisper-cli",
                "-m", "models/ggml-base.bin",
                "-l", "zh",
                "-f", path,
                "-otxt", "-of", path,
                "--no-prints",
            ],
            capture_output=True, text=True, timeout=30,
        )
        with open(path + ".txt") as t:
            return t.read().strip()
    finally:
        for p in (path, path + ".txt"):
            if os.path.exists(p): os.unlink(p)

ggml-base.bin is 142 MB. On an M-series Mac it transcribes a 5-second clip in ~600ms. Good enough.

2. LLM router with three-tier fallback

A single provider going down should not kill the call. Try the free fast one first, fall back to the free smart one, last resort the paid one.

import os, json, urllib.request

PROVIDERS = [
    ("nim",     "https://integrate.api.nvidia.com/v1/chat/completions",
                "meta/llama-4-maverick-17b-128e-instruct",
                os.environ["NIM_API_KEY"]),
    ("gemini",  "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
                "gemini-2.5-pro",
                os.environ["GEMINI_API_KEY"]),
    ("claude",  "https://api.anthropic.com/v1/messages",
                "claude-haiku-4-5",
                os.environ["ANTHROPIC_API_KEY"]),
]

def llm(messages: list[dict]) -> str:
    for name, url, model, key in PROVIDERS:
        try:
            if name == "claude":
                return _call_anthropic(url, key, model, messages)
            body = json.dumps({"model": model, "messages": messages,
                               "temperature": 0.6, "max_tokens": 400}).encode()
            req = urllib.request.Request(url, data=body, headers={
                "Authorization": f"Bearer {key}",
                "Content-Type": "application/json",
            })
            with urllib.request.urlopen(req, timeout=8) as r:
                data = json.loads(r.read())
                return data["choices"][0]["message"]["content"].strip()
        except Exception as e:
            print(f"[llm] {name} failed: {e}")
            continue
    return "（系統忙線中、請稍後再說一次）"

NVIDIA NIM gives free inference on Llama 4 Maverick at decent rate limits. Gemini Pro free tier covers the rest. Claude is the "I'm willing to pay 3 cents to not embarrass myself" tier.

3. Conversation memory + the HTTP handler

The whole point of "phone-call-style" is multi-turn. Each iPhone request carries a convo_id; we keep history in a dict.

import edge_tts, asyncio
from http.server import BaseHTTPRequestHandler, HTTPServer
import cgi, io

HISTORY: dict[str, list[dict]] = {}
SYSTEM = {"role": "system",
          "content": "你是一個說繁體中文的語音助理、回答簡短、口語、自然、不超過 80 字。"}

async def synth(text: str) -> bytes:
    buf = io.BytesIO()
    comm = edge_tts.Communicate(text, voice="zh-TW-HsiaoChenNeural")
    async for chunk in comm.stream():
        if chunk["type"] == "audio":
            buf.write(chunk["data"])
    return buf.getvalue()

class Voice(BaseHTTPRequestHandler):
    def do_POST(self):
        form = cgi.FieldStorage(fp=self.rfile, headers=self.headers,
                                environ={"REQUEST_METHOD": "POST"})
        convo_id = form.getvalue("convo_id", "default")
        wav = form["audio"].file.read()

        user_text = transcribe(wav)
        hist = HISTORY.setdefault(convo_id, [SYSTEM])
        hist.append({"role": "user", "content": user_text})

        reply = llm(hist)
        hist.append({"role": "assistant", "content": reply})
        HISTORY[convo_id] = hist[-21:]  # cap at 10 turns + system

        audio = asyncio.run(synth(reply))
        self.send_response(200)
        self.send_header("Content-Type", "audio/mpeg")
        self.end_headers()
        self.wfile.write(audio)

HTTPServer(("0.0.0.0", 8765), Voice).serve_forever()

iPhone Shortcut: record → POST https://your-tunnel/voice with audio and convo_id → play the response. Done. No app, no TestFlight.

The cost reality

Measured over a week of personal use, ~30 conversations/day, 4–6 turns each:

Component	Provider	Cost
STT	whisper.cpp local	$0
LLM (95% of calls)	NVIDIA NIM Llama 4 Maverick	$0 (free tier)
LLM (4% fallback)	Gemini 2.5 Pro	$0 (free tier)
LLM (1% fallback)	Claude Haiku 4.5	~$0.04/week
TTS	Microsoft Edge `edge-tts`	$0
Hosting	Mac mini at home + Cloudflare Tunnel	$0
Total		~$0.16/month

Compare to Vapi at $0.10/minute — same usage would be ~$45/month. The home-server tax is electricity.

Why no LangChain

I wrote the whole thing in one sitting because every component is the dumbest possible version of itself: a subprocess, an HTTP POST, a dict, an async TTS stream. When NIM changes their model name next month, I edit one tuple. When Edge TTS gets blocked, I drop in Piper without rewriting a "Chain".

Boring is good. Boring code survives provider deprecations. The day a framework abstracts your requests.post into a RunnableLambda, you've signed up to debug someone else's metaphor at 2 AM.

Try it yourself

Full source plus the iPhone Shortcut JSON, the Cloudflare Tunnel config, the Asterisk AGI bridge (so the same backend can answer real SIP phone calls), and 9 more pure-Python AI recipes — packaged as Agent Cookbook for $19, one-time, lifetime updates.

https://vampireheart3.gumroad.com/l/agent-cookbook

If you build something with it, leave a comment — I want to hear what your voice agent sounds like.

— BFO

Part 1: Building 10 AI agents in pure Python (no LangChain)
Part 2 (this one): Phone-call-style voice assistant
Part 3 (next): Giving the assistant tools — real function-calling without an SDK

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

bluefin ships — Sun, 26 Apr 2026 14:43:19 +0000

I tried LangChain. Then LangGraph. Then CrewAI. Then a Zapier subscription. I shipped nothing for a month.

The architecture (it's almost embarrassingly small)

launchd / cron
       │
       ▼
 Recipe (.py)        ← single file, no framework
       │
   ┌───┼───┐
   ▼   ▼   ▼
 API   Web  Local
 fetch scrape files
       │
       ▼
 AI layer (3-tier fallback)
   ① Claude API
   ② Ollama local
   ③ raw passthrough
       │
       ▼
 Push (Discord / Telegram / stdout)

Every agent follows the same pipeline: fetch → reason → push. That's it. Once you internalize that shape, you stop reaching for frameworks.

Recipe 1: Gmail triage in 18 lines

from googleapiclient.discovery import build
import anthropic, json

def triage_today(creds):
    gmail = build('gmail', 'v1', credentials=creds)
    msgs = gmail.users().messages().list(
        userId='me', q='newer_than:1d', maxResults=30).execute()

    summaries = []
    for m in msgs.get('messages', []):
        full = gmail.users().messages().get(userId='me', id=m['id']).execute()
        snippet = full.get('snippet', '')[:300]
        subject = next((h['value'] for h in full['payload']['headers']
                        if h['name']=='Subject'), '')
        summaries.append(f"{subject} | {snippet}")

    judged = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=600,
        messages=[{"role":"user","content":
          f"Rank these emails 1-10 by importance to a freelance dev. "
          f"Return JSON [{{i, score, why}}]. Top 5 only.\n\n"
          + "\n".join(f"[{i}] {s}" for i,s in enumerate(summaries))}])
    return json.loads(judged.content[0].text)

No agent framework. No tool-use loop. Just: fetch the data, give Claude the data, parse the answer. Run it at 21:00 via launchd, push the top-5 to LINE Notify. Done.

Recipe 3: Hacker News morning digest

import requests, anthropic

def hn_digest():
    ids = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json").json()[:10]
    stories = [requests.get(
        f"https://hacker-news.firebaseio.com/v0/item/{i}.json").json() for i in ids]

    prompt = "Summarize each in 2 lines (Traditional Chinese), keep title English:\n\n"
    prompt += "\n".join(f"{s['title']} — {s.get('url','(text)')}" for s in stories)

    out = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=1500,
        messages=[{"role":"user","content":prompt}])
    return out.content[0].text

Eleven lines. Runs at 06:00. Pushes to my Discord. Replaces three RSS readers and a habit of doom-scrolling HN at breakfast.

Recipe 10: Multi-AI judge

The one I lean on most. When I'm stuck on a real decision, I fan out to Claude + GPT-4o + Gemini in parallel, then have Claude judge the panel:

import asyncio

async def judge(question):
    answers = await asyncio.gather(
        ask_claude(question), ask_gpt4o(question), ask_gemini(question),
        return_exceptions=True)

    verdict = anthropic.Anthropic().messages.create(
        model="claude-opus-4", max_tokens=1500,
        messages=[{"role":"user","content": f"""
Question: {question}

[Claude]: {answers[0]}
[GPT-4o]: {answers[1]}
[Gemini]: {answers[2]}

1. Where do they agree?
2. Where do they disagree, who's more defensible?
3. Final call + confidence 1-10."""}])
    return verdict.content[0].text

Cost: ~$0.05 per call. Worth it on anything I'd otherwise spend 20 minutes turning over.

Why I stopped using frameworks

Pure Python + the official SDKs gave me:

Files I can grep
Stack traces that make sense
The ability to swap Claude for Ollama in one line
Cron-friendly behavior (no daemon, no warm-up, just run and exit)

If your agent fits in 30 lines, a framework is a tax, not a tool.

The fallback pattern that saved me

Every recipe has this:

def reason(prompt):
    try:
        return claude_call(prompt)
    except Exception:
        try:
            return ollama_call(prompt)  # local llama3
        except Exception:
            return prompt  # raw passthrough — at least the data still flows

I lost two days last month to an Anthropic outage. Now my morning digest still arrives — degraded, sometimes just raw HN titles, but it arrives. Resilience is a feature.

Try it yourself

I packaged all 10 recipes as Agent Cookbook — single-file scripts, launchd/cron templates, full setup guide. $19 one-time, no subscription, the code is yours to fork.

https://vampireheart3.gumroad.com/l/agent-cookbook

Or just steal the patterns above. The architecture diagram is the actual product — the code is just a faithful copy of it.

Taiwan-localized AI tools comparison: 15 tools tested for TW developers

bluefin ships — Sat, 25 Apr 2026 09:15:37 +0000

If you're building or working from Taiwan, you've probably hit the same wall I did:
most "best AI tools" lists are written for US developers and don't tell you whether the tool will accept your TW credit card or issue a Taiwan invoice (三聯式發票).

So I tested 15 popular AI tools from a Taiwan user's perspective. Here's the gist:

The 3 must-haves (free tier is enough for most)

ChatGPT free — solid baseline
Claude (anthropic.com) — strongest Chinese output, accepts TW cards
Perplexity — best for research with citations

4 worth upgrading (under $25/mo)

Claude Pro / Perplexity Pro / ChatGPT Plus — all ~$20
Grammarly — only useful if you write a lot of English

3 you probably shouldn't buy

Notion AI — only worth it if you're already a Notion power user
Jasper ($49/mo) — Chinese output is "Google Translate-flavored"
Copy.ai — pricing doesn't justify outputs vs Claude

Taiwan-specific notes (the part nobody else writes)

All 15 tools accept TW credit cards (with foreign-currency support)
None of them issue Taiwan三聯式發票 — companies that need invoices can't expense any of these
Some tools occasionally bundle with telecom carriers (e.g. Perplexity x 中華電信) — keep an eye out

Full comparison (in Chinese) with affiliate disclosure: https://abang.bluefin.work/posts/tw-ai-tools-2026-list

I'll re-test every 30 days. Curious what other regional gotchas you've hit elsewhere (EU VAT? Brazil? India?).

Forem: bluefin ships

I'll give you a brutal idea-validation call — free, 1 hour, Devil's Advocate mode

What I'm offering

Who this is for

Who this is not for

How to claim a slot

Why free, why now

3 lines I deleted from my AI cold email prompt — and reply rates jumped 8x

Line 1: "I hope this finds you well"

Line 2: "I came across your profile"

Line 3: "I'd love to connect"

The pattern: remove default-AI behavior, don't add personality

What this looks like in the actual workflow

TL;DR

I built a cold email AI agent for freelance devs in 8 hours — here's what I learned

The hypothesis

The build

What surprised me #1: the prompt does 80% of the work

What surprised me #2: GitHub enrichment is best-effort, and that's fine

What surprised me #3: the rate limit IS the product

What I'd do differently

Why this isn't a SaaS

The full workflow + 50 LinkedIn ICP queries

Appendix: The exact GPT-4o-mini system prompt I'm using

Appendix: Why I picked freelance devs as ICP #1

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

The architecture (it's almost embarrassingly small)

Recipe 1: Gmail triage in 18 lines

Recipe 3: Hacker News morning digest

Recipe 10: Multi-AI judge

Why I stopped using frameworks

The fallback pattern that saved me

Try it yourself

Why Your Python Voice Assistant Should Use Whisper + Claude (Not SpeechRecognition)

The legacy stack (what most tutorials still teach)

The 2026 stack: Whisper + Claude + a real TTS

Install

Minimal end-to-end script

Benchmarks I actually ran

Why "Why Whisper + Claude" beats "How to use SpeechRecognition" in 2026

What to build next

If you want the full agent playbook

Building a phone-call-style AI voice assistant in pure Python

The pain

The architecture

The pipeline (3 snippets that matter)

1. STT via whisper.cpp subprocess

2. LLM router with three-tier fallback

3. Conversation memory + the HTTP handler

The cost reality

Why no LangChain

Try it yourself

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

The architecture (it's almost embarrassingly small)

Recipe 1: Gmail triage in 18 lines

Recipe 3: Hacker News morning digest

Recipe 10: Multi-AI judge

Why I stopped using frameworks

The fallback pattern that saved me

Try it yourself

Taiwan-localized AI tools comparison: 15 tools tested for TW developers

The 3 must-haves (free tier is enough for most)

4 worth upgrading (under $25/mo)

3 you probably shouldn't buy

Taiwan-specific notes (the part nobody else writes)

ai #taiwan #devtools