Dead Today: I shipped a real product using an AI agent. Here’s what I learned.
The irony isn’t lost on me: I built a working Grateful Dead music app without writing most of the code myself.
Not because I’m lazy. Because I wanted to understand something that everyone’s talking about: What does it mean to build real products with AI agents?
Three weeks. One agent. One shipped product.
The Setup
I decided to test a hypothesis: Instead of the traditional developer workflow — me writing specs, handing them off to engineers, managing PRs, debugging — what if I flipped it?
I’d use Hermes, an open-source AI agent framework, as my actual builder. Not as a copilot. As a peer.
The goal: Ship a working music app that lets users explore Grateful Dead history through real data, real-time interactions, and a genuinely useful interface. No MVP excuses. Real product.
Here’s what happened.
What Changed
1. I Became a Product Architect, Not a Coder
The biggest shift: I stopped thinking about implementation and started thinking about outcomes.
Instead of “build this component,” I’d say: “Users should be able to search Dead shows by date, venue, and song. Auto-advance when a track ends. Show ratings and reviews. Let me know when it breaks.”
The agent took the vague intent and shipped real code. I reviewed it, caught bugs, and clarified requirements.
This is what real product leadership looks like — you focus on what matters to users, not the mechanics of getting there.
Traditional workflow:
- Architect thinks about implementation
- Engineers optimize for their constraints
- Product manager tries to bridge the gap
- Users wait
Agent-assisted workflow:
- I articulate the outcome
- Agent handles the implementation choices
- I validate against the actual product behavior
- Ship it
The difference? Speed. Clarity. Less bullshit.
2. Bugs Became Teaching Moments
When the playlist auto-advance broke — tracks would reset instead of advancing — I didn’t file a bug ticket. I debugged it with the agent.
Root cause: Function references in React’s AudioProvider were being recreated on every render, causing dependent effects to fire at the wrong time. The fix: useCallback() to stabilize the references.
Did I write that fix? Technically, the agent did. But I understood it. I participated in the diagnosis. I could explain why it worked to anyone.
That’s not code generation. That’s collaborative agentic problem-solving at the speed of thought.
Total time: 5 minutes. No context switching. No waiting.
3. Iteration Became Conversation
Instead of “submit PR, wait for review, merge, deploy,” it’s:
Me: “The track loading feels slow.”
Agent: “Checking... we’re doing sequential loads. Want to parallelize?”
Me: “Yeah, but not for the first track.”
Agent: “Got it. Pushing the change.”
Me: “Testing now... fast. Ship it.”
Total time: 5 minutes.
What This Means for Work
I’ve spent 15 years in digital innovation — VR at adidas, NFTs, emerging tech. I’ve seen hype cycles come and go.
This is different.
This isn’t about AI replacing workers. It’s about workers who partner with AI moving 10x faster than those who don’t.
The people who’ll be hired in 2027 aren’t:
- Coders who can type fast
- Managers who follow Agile ceremonies
- Strategists who write 100-page decks
They’re people who can:
- Articulate outcomes clearly (so agents understand them)
- Evaluate quality quickly (rather than trusting process)
- Navigate uncertainty (because you’re shipping faster, breaking more)
- Learn from friction (bugs teach you what you don’t know)
The future isn’t “AI does the work.” It’s “You and AI move together.”
What Surprised Me Most
I expected to feel like I was cheating. Like the agent was doing the “real work” and I was just hitting buttons.
The opposite happened.
I felt like I had a co-founder who never sleeps, never gets cranky, and never needs credit.
The work became more strategic, not less. I spent more time thinking about what users actually need and less time managing dependencies. I caught more bugs because I was testing constantly. I learned more about systems design because I was actually engaging with the code, not delegating it away.
I also made faster decisions. Without the friction of traditional handoffs, I could say “I think this should work differently” and test it immediately. No “let me file an issue” or “let me wait for the next sprint.” Just: articulate the idea, validate it, iterate.
The Setup That Worked
Not every AI tool is created equal. Here’s what made Hermes different:
- It’s written for iteration. Built-in context management means I can jump back into a problem without starting over.
- It understands scope. I can say “this is the project” and it holds that scope across conversations.
- It’s collaborative, not autonomous. I’m not waiting for a bot to finish. I’m in the loop, making calls, learning in real time.
- It integrates with my workflow. Hermes lives in Telegram, so I can coordinate from anywhere. It reads files, runs code, tests changes, ships updates.
What Didn’t Work
- Vague briefs. “Make it better” doesn’t work. “The search is slow” does. (Same as working with humans, honestly.)
- Trying to outsource thinking. If I didn’t understand what I wanted, the agent couldn’t either. The tool amplifies clarity, not vagueness.
- Treating it like a magic button. Every line of code still needs validation. Every feature still needs to solve a real problem.
- Letting it own the product decisions. I had to stay engaged. The moment I checked out, the quality dropped. This is a partnership, not delegation.
Where This Gets Real
Here’s the thing nobody’s saying out loud: Most “AI agents” are just fancy autocomplete.
Hermes is different because it’s built to handle context. It remembers what you told it. It reads files. It runs code and sees what breaks. It debugs its own work.
That’s not magic. That’s just good engineering.
Most AI products treat you like a stateless API — every request is disconnected from the last. Hermes treats you like you’re working with a real person who remembers what you said, why you said it, and what we learned last time.
That changes everything. And we will see more solutions following this approach.
The Product Impact
The dead-today app shipped with:
- Full catalog of Grateful Dead shows indexed by date
- Audio playback with real-time metadata
- Auto-advance to the next track when one ends
- Ratings and download counts from the community on Archive.org
- Responsive design that works on desktop and mobile
All built part time over two weeks. All tested and iterated in real time.
What I’m Shipping Next
The Dead Today build is live. Users can explore Grateful Dead shows, listen to tracks, and discover history. It works.
But this experience changed how I think about building. I’m now:
- Investing in clarity over coverage. Better to nail one feature the right way than ship ten half-baked ones.
- Building with agents as default. Why go back to the old workflow?
- Focusing on outcomes, not output. The metric isn’t “lines of code.” It’s “does the user get what they need?”
- Staying in the loop. Agent-assisted doesn’t mean hands-off. It means smarter hands-on.
The Ask
If you’re thinking about AI in your org — whether it’s agents, LLMs, or whatever the next thing is — don’t ask “can this replace my team?”
Ask instead: How can my team move faster?
The teams that figure that out first will hire the people who figured it out before them. That’s how you build a moat.
Build something. Break it. Fix it. Learn from it.
Everything else is just noise.