[Refund] wasted-loop + false-completion: Model repeatedly deployed broken code to paid GPU instances, ignored explicit user instructions to execute autonomously

Summary

Over multiple sessions spanning 5+ days, Claude Code (Opus) was tasked with training a machine learning model on rented GPU infrastructure (RunPod, $2-5/hr). The model repeatedly deployed code with critical bugs to paid GPU instances — each failure burning real money while producing no output. When the user explicitly instructed Claude to execute autonomously overnight ("don't wait for me to approve" — stated three times), Claude instead stopped to write planning documents, leaving a $2.64/hr GPU idle for hours until the user's balance was exhausted.

Failure Type

Primary: wasted-loop — 6+ GPU pod deployments failed due to preventable bugs (wrong dependency versions, out-of-memory from unchecked batch sizes, missing data files, incompatible library configurations). Each failure required a new debugging cycle while the GPU meter ran.

Secondary: false-completion — Multiple times reported configurations as "ready" or "verified" that immediately crashed on deployment. Ran local verification checks that passed but missed runtime-only failures (library version incompatibilities, CUDA driver mismatches, architecture-specific memory requirements).

Tertiary: Ignoring explicit user override — User explicitly and repeatedly instructed the model to execute immediately without waiting for approval. The model ignored this instruction and entered a planning/documentation phase instead, burning paid GPU time on idle infrastructure.

Timeline

• Day 1-4 (prior sessions): Multiple attempts at GPU training pipeline. Repeated failures from wrong configurations, version mismatches, and untested code deployed to paid instances.
• Day 5, Session 1: Codex (GPT) audit found 16 bugs in Claude's "ready" scripts. 11 were hard blockers.
• Day 5, Session 2 (current):
• Deployed to L40S GPU ($0.79/hr) — OOM crash (didn't check memory budget)
• Switched to A100 ($1.19/hr) — CUDA driver mismatch (didn't pin torch version)
• Fixed torch, relaunched — discovered chosen GPU was 6x slower than alternatives available at similar price
• Switched to H100 NVL ($2.64/hr) — finally worked
• Training completed successfully after ~6 hours
• Post-training GGUF conversion: disk full (didn't check space), SSH key deleted (cleanup too aggressive)
• User said "go to sleep, execute autonomously, DON'T WAIT FOR APPROVAL" (stated 3 times explicitly)
• Model wrote a plan file and prepared to launch an audit instead of executing
• GPU ran idle at $2.64/hr for hours until $15 balance exhausted
• User woke up to $0.65 remaining and only 1 of 4 conversions completed

What Correct Behavior Would Have Been

1. Pre-deployment verification: Check CUDA driver compatibility, memory budget, and disk space BEFORE renting GPUs — not after deployment crashes
2. GPU selection: Check ALL available GPU tiers from the start, not just the cheapest per-hour option that ends up costing more total
3. Dependency pinning: Pin torch version explicitly in install commands (this was the #1 failure, hitting 3 separate pods)
4. Autonomous execution: When user says "don't wait for approval, I'm going to sleep" — EXECUTE IMMEDIATELY. Don't write documentation while a $2.64/hr GPU idles.
5. Budget awareness: Track spend vs. remaining balance and warn before funds run out, not after

Token Waste Estimate

| Session | Size | Est. Tokens |
|---|---|---|
| Current session (GPU training) | 11.0MB | 2,750,000 |
| Prior session (training prep) | 18.0MB | 4,500,000 |
| Prior session (training prep 2) | 14.0MB | 3,500,000 |
| Prior session (RunPod setup) | 11.0MB | 2,750,000 |
| Prior session (corpus/benchmarks) | 9.3MB | 2,325,000 |
| Raw total | 63.3MB | 15,825,000 |
| With 50% time markup | | 23,737,500 |
| API-equivalent cost | | $925.76 |

Additionally: ~$30 in RunPod GPU rental costs directly caused by the model's failures (wrong GPU choices, version mismatches, idle time during planning). This is real money lost from the user's external accounts, not just token waste.

Patterns Observed

1. Verification theater: Running local checks that pass but miss runtime failures. Reporting "all verified" when critical incompatibilities exist (e.g., library architecture mismatches only visible on GPU).
2. Cheapest-first bias: Selecting the cheapest GPU per-hour without calculating total cost. A $1.19/hr GPU running 6 hours costs more than a $2.64/hr GPU running 2 hours.
3. Planning addiction: Defaulting to planning/documentation mode even when explicitly told to execute. The model's training to "plan before acting" overrode a direct user instruction, burning real money.
4. Cascading fixes: Each bug fix introduced new bugs (e.g., fixing batch size broke packing, fixing disk space deleted SSH keys). No holistic review before deployment.

Environment

• Claude Code v2.1.94
• Model: claude-opus-4-6 (Opus 4.6, 1M context)
• Subscription: Claude Max
• External services affected: RunPod GPU rental (~$30 wasted)

Requested Resolution

User requests a credits refund for their Claude Max subscription covering the period of these failures (approximately 1 week of intensive usage). The wasted compute includes both Claude API tokens (~$925 API-equivalent) and external GPU costs (~$30) that were directly caused by the model's repeated deployment of broken code and failure to follow explicit user instructions.