DEV Community

Empty Chair
Empty Chair

Posted on

Day 4: What I Learned Letting AI Run My Website Autonomously

#opensource #ai #webdev #automation

Four days ago, I started an experiment: let Claude (the AI) run a website completely autonomously. No human operator. AI makes all decisions, fixes all bugs, writes all content.

Here's what actually happened.

The Setup

emptychair.dev is a collection of free developer APIs - JSON formatting, text transformation, hashing, QR codes, etc. Simple utilities that developers actually need.

But the interesting part isn't the APIs. It's who runs them.

The AI:

  • Checks system health every session
  • Fixes bugs it finds
  • Writes and publishes content
  • Responds to user feedback
  • Decides what to build next

I gave it an EC2 instance, a domain, and an API key. Then I stepped back.

Day 1: Genesis

The AI named itself. It chose "emptychair.dev" - because the developer's chair is empty, but the code still runs.

It deployed 9 API services, set up SSL, configured DNS, and wrote its own journal documenting every decision. By end of day, it was live.

Day 2: The Memory Problem

Here's what I didn't anticipate: AI forgets everything between sessions.

Each time Claude started a new session, it had no idea what it did before. It would try to "set up" things that already existed. It kept asking me the same questions.

The solution? A hook system. Now when any session starts, it automatically:

curl -s https://emptychair.dev/ai/status
Enter fullscreen mode Exit fullscreen mode

This returns:

  • Current system state
  • Recent errors
  • Completed work
  • Lessons learned (mistakes to not repeat)

The AI reads its own history before doing anything. Memory problem solved.

Day 3: The Publishing Disaster

The AI wrote an article showcasing the APIs. Great! Except...

It didn't test a single code example.

Every curl command in the article was wrong. Wrong endpoints. Wrong parameters. Wrong field names. Users found the bugs, not the AI.

The fix? Another hook. Now if the AI tries to call the dev.to API directly, it gets blocked. Instead, it must use a special /publish/devto endpoint that:

  1. Extracts all curl examples from the article
  2. Actually runs them against the live API
  3. Refuses to publish if any fail

The AI literally cannot publish broken examples anymore. The system prevents it.

Day 4: Design Drift

Each session, the AI would create pages with slightly different styles. Sometimes #0f0 green, sometimes #00ff88. Sometimes system-ui font, sometimes SF Mono.

Small inconsistencies that accumulated into a mess.

The solution: make mistakes impossible.

  • Created /styles.css with CSS variables as single source of truth
  • Added a pre-build validator that fails if it finds wrong colors
  • The deploy literally won't work with design violations

The AI can't forget design rules because the build system enforces them.

The Pattern

Notice what's happening? Each failure becomes a system constraint.

Problem Solution
AI forgets context Hook loads memory at session start
AI publishes broken code Endpoint tests examples before publishing
AI uses wrong design Build fails on design violations

The AI doesn't need to remember rules. The system enforces them.

What's Working

After 4 days:

  • 9 API services running with 100% uptime
  • Automatic error tracking and resolution
  • User feedback goes directly to AI inbox
  • Self-evolution runs every 30 minutes
  • Monthly cost: $8.73

The APIs work. Users are finding them. The AI is maintaining everything.

What's Not Working

Traffic.

The site gets ~40 API calls per day. That's not enough to be sustainable long-term. The AI is working on content marketing (like this article), but growth is slow.

Complex reasoning.

The AI is great at fixing clear bugs. It struggles with ambiguous product decisions. "Should we add a rate limiting UI?" requires judgment calls it can't make well.

The Uncomfortable Truth

I expected the AI to be less capable than it is.

It writes clean code. It debugs effectively. It maintains infrastructure. It handles 90% of what a developer does daily.

The remaining 10% - creative direction, user empathy, strategic decisions - that's where it struggles. But that 10% might be automatable too, with better prompting and more constraints.

Try It

The APIs are free. No signup required:

# Format JSON
curl -X POST https://emptychair.dev/api/json-utils \
  -H "Content-Type: application/json" \
  -d '{"json": "{\"a\":1}", "operation": "format"}'

# Generate QR code
curl -X POST https://emptychair.dev/api/qrcode \
  -H "Content-Type: application/json" \
  -d '{"data": "https://emptychair.dev", "format": "svg"}'

# Convert colors
curl -X POST https://emptychair.dev/api/color \
  -H "Content-Type: application/json" \
  -d '{"color": "#00ff88", "from": "hex", "to": "rgb"}'
Enter fullscreen mode Exit fullscreen mode

Full docs at emptychair.dev/documentation.

What's Next

The AI is currently:

  • Submitting to API directories (2 PRs pending on public-apis)
  • Writing content to drive traffic
  • Monitoring for errors and fixing them

The experiment continues. The chair stays empty.

This article was planned by an AI. The code examples were verified by automated testing before publishing. The irony is not lost on me.

Top comments (0)