Infrastructure
Multi-agent AI command center
Problem
Running dozens of automated products and content pipelines as a single person means the operator becomes the bottleneck — every workflow, every failure, every daily task needs a human to notice and act.
What I built
A Claude Code-based multi-agent command system: custom subagents, hooks, and a set of governing "institution" documents that let AI agents plan, execute, and self-verify work with minimal supervision. The system coordinates production automation through a dedicated Discord command channel and daily scheduled jobs.
Claude Code / Claude Agent SDK
Custom subagents & hooks
n8n (self-hosted)
Discord bot integration
Python automation
Cron scheduling
161
n8n workflows in production
Daily
automated scheduling
Read the full story →
Content automation
Fully-automated podcast network
Problem
Producing daily episodes across multiple shows — writing, recording, editing, publishing — is a full production team's job. Doing it manually across five shows doesn't scale for one person.
What I built
An end-to-end pipeline covering 5 podcast channels: AI script generation, Taiwanese-accented text-to-speech voice synthesis, automated cover art, and automatic publishing to Apple Podcasts and Spotify. The entire chain runs daily without manual intervention.
LLM script generation
TTS voice synthesis
Automated cover art
Podcast distribution APIs
n8n orchestration
100%
script-to-publish automated
SaaS product
LBK — LINE auto-reply bot SaaS
Problem
Local businesses in Taiwan run customer service through LINE, but can't staff it 24/7 — and most owners can't write code or prompts to set up an AI assistant themselves.
What I built
A live LINE auto-reply SaaS that answers customer questions 24 hours a day and hands off to a human when needed. No coding or prompt-writing required — merchants import past chat exports and coach the AI in plain Chinese through a 4-tab admin panel (import conversations, voice-train the AI, simulate conversations, monitor live chats). Automation rate climbs from roughly 60% in the first month to about 90% by month six as the bot learns from real conversations.
DeepSeek V3
Supabase (Postgres + RLS)
LINE Messaging API
Merchant self-service admin panel
NT$1,000
starting monthly price
Public API
Taiwan Data API
Problem
Taiwan's government open datasets are spread across dozens of portals with inconsistent formats, making them painful to use in real applications.
What I built
A clean REST API that normalizes Taiwan public open data into a single consistent interface, deployed on Cloudflare Workers' edge network for low-latency global access. One API key unlocks the whole catalog.
Cloudflare Workers
REST API design
Government open-data ingestion
More case studies
Eight earlier projects, broken down teaching-style: the problem, how I split it into solvable pieces, the stack, and what I'd tell someone tackling something similar.
Document automation
Proposal-deck generation engine
Problem
A studio producing business proposal decks was doing it by hand, and every project arrived with a differently-designed PowerPoint template — a script hardcoded for one template doesn't transfer to the next job.
How I broke it down
Instead of hardcoding one template, I built a generic pipeline: parse any .pptx into a structural catalog plus per-slide thumbnails, let an AI model read the catalog and thumbnails to decide which content belongs on which slide, then run a plain script to do the mechanical part — copy slides, replace text, fill tables — with a self-verification pass that re-renders every output slide to catch broken layouts. When purely programmatic layout couldn't match the visual polish a client-facing proposal needs, I added a design-tool finishing layer on top of the automated content fill instead of trying to hand-code visual design.
n8n
Python (python-pptx, lxml)
AI-driven layout mapping
Canva (design finishing layer)
3
structurally different templates, one pipeline
4
n8n modules in the operations system
Live
opportunity-scouting module in production
Takeaway
"When output quality matters more than raw automation, don't force one tool to do everything — let scripts handle the mechanical work and let a purpose-built design tool handle the polish."
SEO & content ops
SEO content site with an automated publish pipeline
Problem
A content site monetizing through affiliate placements needed a steady flow of articles across dozens of product categories. Writing and QA-checking every article by hand doesn't scale — but shipping low-quality AI drafts on autopilot is worse than not publishing at all.
How I broke it down
I built a Hugo static site deployed to Cloudflare Pages, with an n8n pipeline that generates draft articles with an LLM and routes every draft through a second AI pass that scores it against a quality rubric (completeness, internal/external links, a call-to-action) before anything reaches GitHub. Separately, an automated browser bot logs into merchant affiliate backends to fetch and verify commission-tracked short links on a weekly schedule, since one wrong link format means zero tracked commission. When the deploy pipeline looked healthy — green execution logs, on schedule — while the site quietly stopped publishing new content for weeks, I traced it back to the QA gate silently rejecting every draft. A passing pipeline isn't the same as a working one.
Hugo
Cloudflare Pages
n8n
Vertex AI (Gemini)
Automated browser QA bot
47
affiliate channels integrated
11
commission-tracked links auto-verified
Weekly
automated link-integrity checks
Note: this system is currently paused for a content-quality strategy review, not actively publishing.
Takeaway
"A green execution log only tells you the pipeline ran — not that it produced anything useful. Instrument actual output quality, not just uptime."
Data parsing
Turning a messy group chat into a clean spreadsheet
Problem
A group-buy coordinator needed to divide purchase allocations among two dozen buyers, sourced from a 240,000-line LINE group chat export where each person's intent was buried in informal, inconsistent messages — prices written as emoji digits, spelled-out English numbers, or shorthand — and the correct answer changed by the minute as people updated their orders.
How I broke it down
Rather than one big regex, I split the parsing into stages: isolate the relevant date range first (the full log is too large to read in one pass), keep only each buyer's most recent message within that range (latest intent wins), track a buy/sell state machine across each message, extract stock codes with a regex that excludes false positives like years, then run price extraction through a six-tier fallback ladder — from explicit "@price" tags down to spelled-out English number decoding — so one quirky format didn't break the whole run. Every iteration was checked against a growing set of real edge cases the client had personally flagged as previously missed, not synthetic test data.
Python
Regex-based state machine
Google Sheets API
8
parser iterations to reach reliability
119
entries allocated, 23 buyers, 0 conflicts
10/10
client-supplied edge cases passing
Takeaway
"Messy real-world text rarely fits one clean regex. Build a fallback ladder ordered from most-specific to most-general, and validate against real edge cases the client actually hit — not ones you invented."
Systems & security
Self-hosted operations hub, built like production
Problem
An interior-design studio wanted a wiki, asset library, low-code forms, and workflow automation running entirely on its own infrastructure with no dependence on external SaaS vendors — but "self-hosted" often means "install it once and hope."
How I broke it down
I split the build into 8 stages across a single PostgreSQL database backing a wiki, photo/asset library, low-code app builder, and workflow automation, enforcing role-based access at the workflow level rather than trusting the front end — for example, non-admin roles can't read cost data even if they tamper with the request. I treated the security review as a real audit, not a formality: red-team passes on my own workflows found and fixed a privilege-escalation bug (a publish workflow that let a non-approver push content live by exploiting execution order) and a SQL-injection point, closing both with an atomic status lock and parameterized queries. I also ran an actual backup-and-restore drill against a disposable database rather than just writing a backup script and assuming it worked, then tied all four services together behind a single-entry reverse-proxy portal.
Docker Compose
PostgreSQL
n8n
Self-hosted wiki, asset library & low-code platform
Nginx reverse proxy
5+
internal workflows live with verified RBAC
1
privilege-escalation bug found & fixed pre-launch
Drilled
backup/restore actually rehearsed, not just documented
Takeaway
"Self-hosting isn't done when the containers start. Red-team your own workflows, run a real backup-restore drill before you need it, and assume version one has a security hole — because it usually does."
Payments automation
Payment reconciliation chain on edge workers
Problem
Digital products need fully automated fulfilment: once a buyer pays, the system has to confirm the funds and deliver the product within minutes, with no human in the loop. The catch is that payment-gateway webhooks are not guaranteed delivery — one missed notification means a customer who paid and received nothing.
How I broke it down
I built the whole chain on a Cloudflare Worker: the landing page creates a short-lived session carrying product and language parameters, checkout writes the order into Workers KV, and order state is tracked through four key prefixes (session / order / pending / processed). Reliability comes from two complementary paths: besides the real-time webhook, a cron job every 5 minutes sweeps "pending" orders and actively queries the gateway for their transaction status, catching any notification that never arrived. On the fulfilment side, a short-lived "processed" lock makes delivery idempotent — no duplicate product emails. Pending orders carry a 3-day TTL so stale entries clean themselves up.
Cloudflare Workers
Workers KV
Payment gateway API (webhook + active query)
n8n (fulfilment email chain)
<5 min
payment to product email, fully automated
2
complementary reconciliation paths (webhook + cron)
0
manual steps in the loop
Takeaway
"Payment webhooks are 'usually delivered', not 'guaranteed delivered'. Design for the miss from day one with active reconciliation as the safety net — and an idempotency lock so the safety net can't turn into double delivery."
Browser automation
Multi-account shareholder e-voting automation
Problem
Every AGM season, seven accounts need their votes cast stock-by-stock on the central securities depository's e-voting portal. Each account has its own digital certificate — which can silently expire mid-run and log the session out. A missed vote is a real loss of shareholder rights, and afterwards you need evidence that every vote was actually cast.
How I broke it down
A Selenium pipeline across accounts — but the real work isn't clicking through pages, it's failure-proofing: before every account switch the tool re-imports that account's certificate via the OS certificate utility (the root fix for mid-run expiry), and an import failure only logs a warning rather than aborting, letting the login flow decide whether it can proceed. Chrome profiles run a three-tier fallback (preferred → backup → fresh temporary), with lock files cleared at startup to survive prior crashes. After each account finishes all its stocks, an audit pass verifies every vote screenshot exists, re-captures any that are missing, and raises a red banner in the GUI if one still can't be produced — an incomplete evidence chain doesn't count as done.
Python (2,330 lines)
Selenium
Tkinter GUI
Windows certutil certificate management
7
accounts in one automated pipeline
0
missed votes across real AGM seasons
100%
screenshot audit with auto-recapture
Takeaway
"In browser automation the flow is the easy part. Certificates break, profiles lock, screenshots go missing — every fragile link needs automated recovery, and anything that can't recover needs to shout loudly."
Computer vision (research prototype)
Real-time card-table recognition & decision engine
Problem
A self-directed research question: from raw screen pixels alone, can a system "read" a live poker table — hole cards, board cards, whose turn it is — and produce a strategically sound decision within a few hundred milliseconds? The goal was integrating computer vision, state machines and a large strategy database into one low-latency pipeline.
How I broke it down
I split "reading the table" into independently verifiable layers. A capture layer handles four tables on concurrent threads. A recognition layer combines a CNN classifier with template-match disambiguation (a second opinion triggered only under low confidence), reaching 100% on hand-verified ground truth for both hole and board cards. A decision layer sits on a 59.6-million-row, 8.6GB precomputed strategy cache mounted read-only — with an end-to-end proof that production lookups actually hit the cache, instead of assuming "wired up" means "working". A safety layer adds a stale-frame gate: any frame older than one second is skipped, never acted on. Finally, independent AI agents ran adversarial red-team/blue-team review rounds until multiple consecutive rounds surfaced zero critical findings.
Python
OpenCV + CNN classifier
SQLite (59.6M-row strategy cache)
Multi-threaded screen capture
Red/blue adversarial review
100%
hole + board recognition on verified ground truth
123,109
historical detections audited offline, zero out-of-vocabulary outputs
4
tables captured concurrently
Note: research prototype — all validation offline and in simulation; never deployed in live play.
Takeaway
"Offline metrics can lie. A '0% error' figure that's true by construction proves nothing — separate real evidence from tautologies before trusting a number."
Generative AI
AI virtual-persona content pipeline
Problem
Generating one beautiful AI image is easy. The hard part is the same person: running a virtual-persona IP means keeping the same face and body consistent across dozens of scenes, outfits and lighting setups — in batch production, not one lucky roll at a time.
How I broke it down
I started by writing each persona as a structured spec — appearance lock terms, banned terms and scene templates managed separately — across a 10-character spec system. Prompt engineering became a versioned "prompt lock" system: facial and body features pinned, scene elements left free, feeding a dual pipeline of local ComfyUI and a hosted generation platform. A persona's 25-image production set ran batch-generate → per-image review → reroll-on-fail, producing roughly 46 candidates to converge on the final set. The bigger job wasn't image generation at all: it was the pre-launch due diligence across platform policy, payment rails, identity verification and legal constraints — which concluded the commercial launch should pause. That decision was itself a deliverable.
ComfyUI
Hosted generation platform
Versioned prompt-lock system
Character spec system
10
structured persona specs
46→25
candidates converged into a production set
v4.1
prompt-lock system, four major versions in
Note: pipeline and consistency system built and used for real production sets; commercial launch deliberately paused after platform & compliance review.
Takeaway
"In generative-AI products the image pipeline is maybe 20% of the work. Character consistency, platform policy, payments and compliance are the other 80% — and 'we investigated and chose not to launch' is a valid, valuable outcome."