---
title: "Burned Through a Month of Claude in 4 Days And Accidentally Reenacted Star Wars"
canonical: https://www.hatch.org/2026/05/05/may-4-be-with-you/
author: "Steve Hatch"
date: 2026-05-04
categories: ["Artifical Intelligence, Coding, Star Wars, Agents, Claude, Development, Prompt Engineering, AI-development"]
tags: ["AI","Scheduling","Agents"]
---

# Burned Through a Month of Claude in 4 Days And Accidentally Reenacted Star Wars

**May the 4th be with you**
![Burned Through a Month of Claude in 4 Days And Accidentally Reenacted Star Wars](https://www.hatch.org/images/may-4-be-with-you.jpg)

There are productivity stories.  
There are AI stories.  
And then there’s whatever this was—a four-day arc that started as a helpful experiment and ended as a fully committed, cinematic tragedy… capped off by the most on-the-nose message imaginable on **May the 4th**:

> _“You’ve hit your org’s monthly usage limit.”_

Naturally.

But here’s the twist: those four days didn’t feel random. They mapped almost perfectly to the original trilogy.

Not metaphorically. Structurally.

---

## Day 1: _A New Hope_ — The Friendly Ping That Starts a Rebellion

Like all good origin stories, this one began with a message.

A long-time friend reached out—not with small talk, but with a problem:

> “Scheduling spa appointments is a nightmare.”

Not “slightly annoying.”  
Not “could be optimized.”

A full-blown, multi-actor, constraint-heavy, edge-case-riddled **empire of scheduling chaos**:

- Multiple providers
    
- Limited time slots
    
- Human preferences (the most dangerous variable of all)
    
- Constant rescheduling entropy
    

In other words: the Death Star, but with facials.

Enter Claude.

We weren’t just solving a problem—we were going to build an **agentic system**. Something that could:

- Reason about constraints
    
- Coordinate across actors
    
- Adapt dynamically
    

This wasn’t a script. It was a **rebellion**.

And like any good rebellion, it started scrappy:

- Rough prompts
    
- Iterative thinking
    
- “What if we tried it this way?” energy
    

Hope was high. Tokens were plentiful. The galaxy felt… manageable.

---

## Day 2: _The Empire Strikes Back_ — Reality Pushes Back

By Day 2, the system started to take shape.

And immediately, the problem pushed back.

Hard.

Because it turns out:

- People cancel last minute
    
- Preferences conflict in non-linear ways
    
- “Just optimize it” is the software equivalent of “just win the war”
    

Every time we thought we had it:

- A new constraint emerged
    
- A corner case broke the model
    
- A seemingly elegant solution collapsed under real-world messiness
    

We escalated:

- More detailed prompts
    
- More nuanced reasoning
    
- More “let’s simulate this scenario”
    

Claude delivered. Repeatedly. Impressively.

But the deeper we went, the clearer it became:

We weren’t building a solution.  
We were **engaged in an ongoing battle with complexity itself**.

And complexity… strikes back.

---

## Day 3: _Return of the Jedi_ — The Illusion of Victory

Day 3 is where things got dangerously optimistic.

We had:

- A working conceptual model
    
- A believable agent loop
    
- A narrative that _felt_ like it could scale
    

We weren’t just solving scheduling anymore—we were designing the **future of coordination**.

This is where the prompts got… cinematic:

- Multi-agent simulations
    
- Decision frameworks
    
- Narrative explanations of system behavior
    
- “Explain how this evolves over time”
    

We started telling ourselves a story:

> This works. This could actually work.

And to be fair, it _did_—in the same way the Rebels blowing up the second Death Star “worked.”

But here’s the part nobody talks about in the highlight reel:

Victory is not the same as stability.

---

## Day 4: _May the 4th_ — The System Strikes Back

I woke up ready to push it further.

Refine the model.  
Harden the system.  
Turn something promising into something real.

Instead, I got this:

> _“You’ve hit your org’s monthly usage limit.”_

On May the 4th.

At that moment, the entire arc snapped into focus.

Because what we had built over those three days suddenly looked… familiar.

---

## The Real Ending: Rebuilding the Jedi Is Hard

Here’s the uncomfortable parallel.

What we were trying to do with this “agentic scheduling system” wasn’t just solve a problem.

We were trying to **rebuild an institution**—from scratch.

And like Luke after _Return of the Jedi_, we had:

- **No mature foundation**  
    Just prompts, patterns, and partial abstractions
    
- **One “teacher” (Claude) and one orchestrator (me)**  
    No distributed system of validated intelligence—just a powerful but centralized collaborator
    
- **Incomplete knowledge**  
    We were discovering edge cases _as we went_, not operating from a complete model
    
- **A hostile, chaotic environment**  
    Real-world human behavior is the dark side of system design
    
- **A deceptively convincing early success**  
    Enough to believe it works… not enough to ensure it holds
    

What “made it work”—briefly—was exactly what you’d expect:

- Aggressively iterating on prompts
    
- Pulling in more context
    
- Building layer upon layer of reasoning
    
- Treating the model like a hybrid of engineer, analyst, and philosopher
    

In other words:  
**obsessively reconstructing capability from fragments**

And just like Luke’s early Jedi Order, it was:

> **inherently brittle**

Because the foundation wasn’t deep—it was _assembled_.

Which is why it didn’t take a catastrophic system failure to stop us.

It took something much simpler.

A quota.

---

## The Ben Solo of This Story: Token Limits

We like to imagine systems fail because of dramatic, internal collapse.

But sometimes?

They fail because:

- Resources run out
    
- Constraints assert themselves
    
- The environment reminds you who’s actually in control
    

My “Ben Solo moment” wasn’t a rogue agent or a broken model.

It was:

> _“Monthly usage limit reached.”_

A single constraint, revealing how fragile the whole construct really was.

---

## What Actually “Worked” (For a While)

And yet—this is the part that matters—it _did_ work.

For a moment, we had:

- A system that could reason about a messy real-world problem
    
- A loop that could adapt and refine
    
- A glimpse of what agentic coordination actually feels like
    

That’s not nothing.

That’s the early Jedi temple phase:

- Small
    
- Experimental
    
- Held together by belief and iteration
    

Powerful enough to be exciting.  
Fragile enough to collapse under pressure.

---

## Final Thought: The Future Is Real—Just Not Stable Yet

Burning through a month of tokens in four days isn’t just a funny story.

It’s a signal.

We’re entering a phase where:

- These systems are genuinely useful
    
- They can model complex domains
    
- They can _almost_ hold together under real-world conditions
    

But “almost” is doing a lot of work.

Right now, building with AI feels like:

> Reconstructing a powerful, half-forgotten system from incomplete knowledge, in a chaotic environment, with just enough success to keep going.

Sound familiar?

---

## And So…

On May the 4th, I didn’t just hit a limit.

I got a perfectly timed reminder:

> You’re not operating a stable empire yet.  
> You’re still rebuilding the Jedi.

And that work?

It’s slow.  
It’s fragile.  
And occasionally… it ends because you ran out of tokens.

May the force—and your quota—be with you.
