$5,000 in AI Credits: A System Inventory

What I Built With $5,000 in AI Tokens

In one month, spending roughly $5,000 on AI subscriptions and APIs (Claude Pro + Claude API + OpenAI API + Copilot Pro+ + Codex + Paseo + miscellaneous), I built out 18 major systems independently, with a total codebase of roughly 50,000+ lines of code (excluding auto-generated AI scripts).

For comparison: the same functionality, developed from scratch by 2 full-stack engineers, would conservatively take 6-12 months and cost at least ¥300,000-600,000.

This post is an inventory—organized by category, covering what each system does, what problems it solves, and how much human engineering time it would take to build from scratch. I’m not diving into technical nitty-gritty (follow the links for detailed architecture), just covering scale and efficiency gains.

I. Quant Trading Systems (Core)

Polaris Strategy Family (three coexisting strategies: polaris 1/5/6):

BTC trend-following / multi-asset portfolios / perpetual + spot arbitrage
Live dual-machine hot standby (automatic failover)
All strategies unified under Telegram signal broadcasts
Polaris Strategy Intro

Backtest Lab (two generations):

v1 (Streamlit 8501): Basic Python backtest, single asset single parameter
v2 (Streamlit 8502, Numba JIT acceleration): multi-asset portfolios, Walk-Forward validation, Monte Carlo simulation, parameter grid search
Auto-sync K-line data with live trading machine on aws-sg

Strategy Operations Toolchain:

Automated parameter optimization (nightly cron grid searches)
Daily review reports (aws-sg/jp vectorized computation → AI-generated summary → Telegram)
Strategy A/B/C comparison dashboard (Grafana)
Mac local sanitized standby machine (5-layer security locks + hourly pull from aws-sg)

Human Development Estimate: This stack alone takes 3-4 months minimum. Quant systems span backtest-to-live, parameter search to dual-machine failover—each stage is a medium-sized project.

Want to dip your toes into quant without coding? Pionex has 16 built-in bots—get started code-free in an hour.

II. panshi.io Blog + Growth System

Hugo Blog + PaperMod Customization:

64 technical articles covering quant / proxies / AI tools / VPS and more
3-column responsive card grid, dark mode by default (eliminates white-screen flicker)
Per-article OG cards + hero images (AI-generated, brand-consistent style)
List thumbnails + hero on detail pages

Multi-region Deployment:

Dual active: aws-hk + aws-us (rsync sync in seconds)
Cloudflare CDN front, md5 triple-check
10+ custom Workers (polaris-api / aff-tracker / vps-stock-api / freemail-w3fomo, etc.)

Affiliate Attribution System:

14 affiliate channels unified under tracker shortlinks
Attribution by article (?ref=/posts/xxx/)
Attribution by X source (?ref=x-slug)
Prometheus scrapes every 5 minutes + Grafana dashboard

Self-hosted Umami Event Tracking:

Page views / referrers / devices
Affiliate clicks (custom aff-click event)

Human Development Estimate: Blog itself is 2 weeks, but affiliate tracker + multi-region deployment + automation monitoring is 1 month minimum. Image pipeline alone is another month (see below).

III. Release Management System (Port 9891 · Standalone Web App)

A local web application (http://localhost:9891) dedicated to panshi.io publishing and operations:

10+ Admin Pages:

Article list + affiliate attribution + filtering (all/published/drafts)
Embedded Markdown editor (EasyMDE) + live preview
Draft/AI request queue
OG card preview (see how it looks on X before publishing)
Tweet management (list/refresh/delete)
Affiliate click dashboard
Image library (local + Unsplash/Pexels/Pixabay + AI-generated)
Settings (API keys + toggles)
Publish history + health dashboard

7-Step Publish Pipeline:

Pre-flight checks (frontmatter / content policy / bare affiliate links / structure linting)
Auto-generate OG + hero images
Tweet preview
Hugo build
rsync dual-region + md5 triple-check
Post to X (three modes: short tweet / Premium long tweet / thread digest)
Telegram notification + attribution refresh

10 Scheduled Tasks (all monitored via job_runner):

Article index refresh, link health scan, deployment drift detection, affiliate stats sync
Tweet history snapshot, raw affiliate link scan, affiliate exporter health, OG image health
Engagement analytics (best publish times + evergreen candidates), persistent publish monitor service

Brand-Consistent AI Image Generation:

Flux Schnell generates 64 hero images in brand colors (deep blue-purple gradient)
Homemade PIL generates OG cards (title + brand strip)
Auto-compress to WebP + multi-size (7MB hero → 80KB, 90x speedup)

Publish Monitoring System Full Architecture

Human Development Estimate: This standalone system alone is 2 months minimum.

IV. Backup & Disaster Recovery (3-2-1 Architecture)

Three-Tier Backup:

L1 Mac SSD: Second-level recovery, short-term history
L2 iCloud 2TB: Cross-device, medium-term
L3 AWS S3 Deep Archive Tokyo: Disaster recovery, ~¥0.15/month

20+ Backup Tasks covering:

openclaw workspace (daily + hourly)
Obsidian vault (notes)
Mac system config (LaunchAgents, etc.)
Quant code and datasets
Cloudflare KV / Workers / DNS
Remote VPS configs (cron / systemd)
Prometheus config + Grafana dashboards
panshi.io site + nginx configs
Weekly git bundles (cross-machine DR)
Monthly S3 archival

Standalone Status Page (port 9890): Health indicator for each task (green/yellow/red) + error details + Telegram alerts.

Boot-Up Backfill Mechanism: When Mac wakes from sleep, automatically re-runs any missed scheduled tasks.

Human Development Estimate: Full 3-2-1 backup + unified monitoring is 1.5 months minimum.

V. Mac Job Monitoring (Port 9888)

All Mac local cron / launchd tasks (currently 34) unified under a heartbeat system:

job_runner.sh wraps all tasks, writes heartbeat timestamps on success
Prometheus textfile + node_exporter collection
Standalone monitoring server Grafana visualization (Mac monitoring)
Real-time Telegram status changes
Auto-detect task creation/deletion

Human Development Estimate: Monitoring infrastructure + status page is 3 weeks minimum.

VI. Gateway / Proxy Architecture (Home Office + Quant Exit)

Dual Gateway Redundancy:

Primary: OpenWrt + passwall (deployed fresh 2026-04-13)
Secondary: mihomo (demoted from primary, now fallback)
Auto-failover on degradation

Home Broadband Proxy Chain:

7-node auto-fallback (US / Japan / Hong Kong residential ISP)
Used for AI tools (ChatGPT / Claude / Gemini account protection)
Residential IP exit guarantees quant strategies avoid exchange rate-limiting

Surge Fail-Closed Monitoring:

If Surge crashes, auto-activate PF firewall killswitch
Block all foreign traffic, ensure no domestic routing fallthrough
Status bar displays protection status (custom Swift app)

Protocol Stack:

Xray VLESS + XTLS + Reality
Hysteria2 (QUIC, high-speed)
Cloudflare Workers VLESS (zero-cost nodes)

Full Residential IP Exit Config · Buy DMIT VPS · IPRoyal Residential IPs

Human Development Estimate: Gateway + proxy + fail-closed monitoring is 1+ month.

VII. NetworkGuard Status Bar App (Swift Native)

Standalone macOS status-bar utility:

Real-time Surge process and PF firewall status monitoring
Status icon: green (protected) / red (compromised)
Web dashboard with detailed data
Prevents “MacBook accidental mainland IP on AIGC API → account ban”

See I Built a Network Security Guard on My Mac Status Bar.

Human Development Estimate: Swift + PF interaction is 2 weeks.

VIII. OpenClaw System (AI Toolchain Orchestration)

Foundation: Claude Code + external system integration platform

Telegram messages trigger AI task chains
Multi-agent collaboration (one queries API, one analyzes, one pushes)
Skill system extensibility (I have 10+ custom skills)
Quant workflow integration (“Check all account risk” → 3 seconds response)

IX. AI Tool Ecosystem (Claude Code / Codex / Copilot / Paseo)

Dual-Channel Claude Code:

Official Claude Pro channel (fixed monthly fee)
Copilot Pro+ backend channel (free piggyback)
One-click alias switching

Model Strategy:

Default Sonnet (best ROI)
Opus fallback when quality insufficient
Haiku for batch jobs (90% cost savings)
Three-tier mix reduces monthly API spend 60%

Session Management:

Paseo multi-agent mode
Claude Code long-session crash recovery
Image accumulation auto-cleanup

Usage Monitoring:

Copilot usage hourly + daily summary
OpenRouter daily balance check

X. cmux Session Management

Multiple Claude Code processes in parallel (this article is from one session), each with isolated workspace + isolated git worktree, preventing interference.

XI. VPS Inventory Real-Time Monitor (panshi.io/stock)

Tracks 5 major VPS providers (Bandwagon / RackNerd / CloudCone / DMIT / Akile) popular tier inventory
Primary + backup checker redundancy (domestic ISP VPS + overseas VPS)
CF Worker aggregation + 5-minute auto-refresh on frontend
Subscriber notifications: out-of-stock → in-stock via Telegram

Complete VPS Selection Matrix by Use Case.

Human Development Estimate: Anti-scraping + primary/backup switchover + subscription notifications is 1 month.

XII. Telegram Bot Ecosystem

7+ independent bots, each with a role:

as_monitor: ops alerts (gateway / backups / quant)
polaris-signal-to-x: strategy signals → X tweets
as_fam: home device monitoring
SSH login notifier: every SSH login logged + Telegram push
Several others, each with its domain

Each bot has its own token + chat_id + alert path, no cross-interference.

XIII. Monitoring & Alerting Chain (Standalone Monitor Server)

Full-Stack Observability:

Prometheus (metric collection)
Grafana (visualization, 13 dashboards)
Alertmanager + tg-webhook (Telegram alerts)

What’s Monitored:

10+ VPS (CPU/memory/disk/network/SSH logins)
Mac local 34 scheduled jobs
Quant strategy P&L real-time curves
Circuit health (Hysteria2 UDP / Xray TCP / home broadband proxy)
Gateway status overview
Affiliate clicks / subscriber count (new)
Publish system task health

XIV. Obsidian + Mac Config Auto-Backup

Notes auto-commit + hourly + daily tagged
Mac system configs (LaunchAgents / custom scripts / Surge profiles) daily auto-commit to iCloud
Auto-recovery flow documentation

XV. iPhone / iPad / Mac Surge Profile Sync

Three-device Surge profile version control:

Mac is the editor source
iPhone / iPad pull with auto domain-vs-IP validation
Prevents “one device out-of-sync → leaked exit”

XVI. Remote Desktop + SSH Patrol

RustDesk 8K:

Open-source + self-hosted relay
Cheaper than TeamViewer / AnyDesk, more private

SSH Patrol Automation:

Daily AI auto-inspection of 10+ machines
Reports resource use / exception logs / pending items
Summary to Telegram

X Bookmarks Sync: daily pull new bookmarks → organize into Obsidian
X API Publishing (polaris-signal-to-x bot)
X Thread Digest Publishing (new): Markdown article → AI generates 5-10 tweet thread

XVIII. Public GitHub Projects

Open-sourced tools (already sanitized):

claude-code-image-rescue: Fix Claude Code long-session image memory explosion bug

Three Shifts in AI-Assisted Development

After shipping all this, I have a few takes on “AI + solo development”:

1. Code isn’t the bottleneck anymore—requirements definition is

Writing a 500-line Python script with Claude Code usually takes 20-40 minutes of conversation. But “what exactly do I need?"—AI can’t figure that out for you.

Clear requirements + AI code generation + human review = best workflow.

2. Deployment and maintenance are worth more than initial dev

Of the 18 systems above, 70% of effort isn’t “write the code,” it’s:

Where does it run? (Mac / server / CF Worker)
How to daemonize? (launchd / systemd / cron)
How to monitor? (Prometheus + Grafana + alerts)
How to recover? (backup strategy)

AI shines in system integration scenarios—it won’t forget error handling, logging, health checks.

3. Consistency beats personal preference

All systems follow the same playbook:

Logs: ~/.openclaw/workspace/state/
Heartbeats: Prometheus textfile
Alerts: Telegram bot categories
Backups: 3-2-1 three-tier
Docs: Obsidian Infra-OPS/ 64 files

Claude Code’s memory system maintains these conventions across sessions better than I remember them myself.

Cost Breakdown (Where $5,000 Went)

Item	Share
Claude API (Anthropic direct billing)	~40%
ChatGPT Plus + OpenAI API	~25%
GitHub Copilot Pro+ × 2 (two accounts)	~20%
Cursor / Codex / other subscriptions	~10%
Miscellaneous (Replicate / Cloudinary / etc.)	~5%

Realistically, the top 3 (Claude + OpenAI + Copilot) account for 85%—Claude is the workhorse.

If You Want to Replicate This

Step 1: Start with a real problem to solve

Each of my 18 systems addresses a concrete pain point (quant account bans / data loss from crashes / job timeouts / low X publishing velocity). No pain point = no staying power.

Step 2: Go deep on one tool, not shallow on many

My setup:

Claude Code (80% of my time) — Cost guide
GitHub Copilot Pro+ backup — Dual-channel switching
ChatGPT Plus occasional data analysis + image generation

Skip the simultaneous Cursor + Copilot + ChatGPT + Claude stack—switching costs and subscription fatigue aren’t worth it.

Step 3: Standardize your infrastructure

Unified log paths
Standard task wrapper (mine’s job_runner.sh)
Unified Telegram notifications
Docs in one Obsidian vault

Standardization lets Claude Code transfer patterns across tasks—once it sees the structure of one task, the next one follows naturally.

Step 4: Allow yourself imperfect shipping

Many of my systems are “good enough” versions, not “engineering perfect.” For example, the backup status page (port 9890) is just a few hundred lines of Python, no framework. AI generates it, I review, it ships. Don’t over-engineer.

If You Want to Explore This Too

Recommended Tool Stack:

Best Hands-On Entry Point (understand the full chain):

Pionex Grid Bot Tutorial (code-free)
Using Claude Code to Monitor Pionex Bot (30-min practice)
Open a Pionex account, run $100/month, get tactile sense of AI-assisted quant value

Infrastructure Support Tools:

DMIT VPS (stable HK / JP routes)
IPRoyal Residential IPs (essential for AI tools + quant)
Google One AI Premium (Gemini Advanced + 2TB cloud storage)

An Honest Comparison

People ask “does AI actually help?” Here’s my real data:

Task	Without AI	With AI (my experience)
Write a new script	3-8 hours (docs / Stack Overflow / debugging)	20-40 min (describe need → review → test)
Debug an error	Sometimes a full day	Under 10 min to pinpoint
Maintain 30+ jobs	10 hours/month firefighting	1-2 hours/month (mostly AI-handled)
Write a tech post	3-4 hours	1 hour (outline manually + AI fills + human review)
Learn a new domain	1-2 weeks to baseline	Half day (AI tutoring + Q&A)

Multiply by 18 system categories + 365 days, and that’s where the 100x comes from.

Not “AI replaces people,” but “person who knows business + knows AI = past solo team of 3.”

Want to chat about AI workflows / quant / independent building: Telegram @panshi8848, or X @panshi8848 DMs.

Further Reading:

$5,000 in AI Credits: A System Inventory#

I. Quant Trading Systems (Core)#

II. panshi.io Blog + Growth System#

III. Release Management System (Port 9891 · Standalone Web App)#

IV. Backup & Disaster Recovery (3-2-1 Architecture)#

V. Mac Job Monitoring (Port 9888)#

VI. Gateway / Proxy Architecture (Home Office + Quant Exit)#

VII. NetworkGuard Status Bar App (Swift Native)#

VIII. OpenClaw System (AI Toolchain Orchestration)#

IX. AI Tool Ecosystem (Claude Code / Codex / Copilot / Paseo)#

X. cmux Session Management#

XI. VPS Inventory Real-Time Monitor (panshi.io/stock)#

XII. Telegram Bot Ecosystem#

XIII. Monitoring & Alerting Chain (Standalone Monitor Server)#

XIV. Obsidian + Mac Config Auto-Backup#

XV. iPhone / iPad / Mac Surge Profile Sync#

XVI. Remote Desktop + SSH Patrol#

XVII. X-Related Systems#

XVIII. Public GitHub Projects#

Three Shifts in AI-Assisted Development#

1. Code isn’t the bottleneck anymore—requirements definition is#

2. Deployment and maintenance are worth more than initial dev#

3. Consistency beats personal preference#

Cost Breakdown (Where $5,000 Went)#

If You Want to Replicate This#

Step 1: Start with a real problem to solve#

Step 2: Go deep on one tool, not shallow on many#

Step 3: Standardize your infrastructure#

Step 4: Allow yourself imperfect shipping#

If You Want to Explore This Too#

An Honest Comparison#