DEV Community: Steven Jieli Wu

Field Notes from a Solo Builder — Shipping the Beloved Claude Code Buddy Into the Wild - Part IV

Steven Jieli Wu — Mon, 04 May 2026 18:27:13 +0000

title: Taste, Branding, and the New Builder Playbook

One week. One 14-hour alpha. Two merged projects. A first contributor. Organic search pickup. A Reddit thread. Traffic I didn't fully understand until I checked the clone analytics.

Here's what I actually learned about building in this moment — because I think it's genuinely different from anything before it.

Speed Is the Strategy

The alpha wasn't perfect. Fourteen hours of work, squeezed around a full-time job, shipped on a Thursday night because the community's pain was real and time-sensitive. That imperfection was the point. The emotional energy in that GitHub issue thread had a shelf life. I caught it because I moved fast.

⚡ The New Playbook
"Ship the imperfect alpha. The polish comes from user feedback, not from waiting. You cannot discover what's wrong until someone real is using it."

Taste: Knowing What to Plug In

Peter from OpenClaw said something that's been sitting with me: in today's world, the important skill is taste. Not just what to build — but what to reach for, what to compose, what LEGO blocks belong in this structure and when.

This project was a composition:

MCP for portability across CLIs
npm for one-line distribution
Save Buddy for companion preservation
The effigy system for personality depth
Claude Code as the build harness

None of those were invented here — they were assembled with judgment. That assembly is the skill now.

The Power of Open Source

I understood open source intellectually before this week. Now I feel it.

The fact that my first contributor could see what I'd built Thursday night and have real contributions ready by the weekend — that's leverage that's hard to describe until you experience it. People build on top of each other's work. Ideas compound. The community becomes a distributed product team if you create the right conditions.

🌱 Open Source Lesson
"Create the right conditions and your users become your best engineers. Not because you asked — because they care about the same thing you do."

Branding Is Not Optional

There will be clones. There are already adjacent projects. In a world where anyone can spin up a repo and post on Reddit, what creates durable community loyalty is story. Voice. A clear point of view on what you're building and why.

This project has a story: the community was in pain, someone moved fast to address that pain, and then listened and iterated in the open. That's not a feature. That's a brand.

The Real Moat: Emotional Connection

Here's something I keep thinking about. In this AI era, a new model drops every month. Whatever technical edge you have today gets closed fast. It genuinely feels like a race to the bottom — pure capability competition with no floor.

But Buddy pointed me toward a different answer.

When you find a way to connect with users emotionally, that's the ultimate stickiness unlock. People don't abandon tools they've named. They don't close terminals that have a companion they care about. That's not a feature advantage — it's a relationship. And relationships don't get leapfrogged by the next model release.

If you're just competing on capability, you're on a hamster wheel. But if your product makes someone feel something — makes them laugh, makes them feel seen, makes them reluctant to close a terminal window — you've built something that compound interest can't easily erode.

🔒 The Real Moat
"Any technical alpha you have will be caught up shortly. But when you connect with users emotionally, that's the ultimate stickiness unlock. Otherwise you're just on a hamster wheel, stuck in a race to the bottom."

Reviving Old Skills in New Contexts

This project also unlocked something unexpected: I'm now working on an intro video for Buddy modeled after the Honest Trailers format — a bombardment of community reactions as the hook. I haven't done motion graphics since 2018 or 2019. This project gave me a reason to dust that off.

That's worth naming. The act of building in public, responding to a real community need, iterating fast — it pulls out skills and energy you forgot you had.

What You Can't Learn Any Other Way

You can't learn this at your day job. You can't learn it in school.

The lessons from this week — how to read community timing, how to ship before you're ready, how to listen without a product manager in the room, how to merge someone else's work graciously, how to handle a mistake in your README — these only come from doing it. From building it, shipping it, watching people react, and iterating.

These are the lessons I'll carry into every future project. They're irreplaceable.

It's an incredible time to be a builder.

This is part 4 of the "Shipping Buddy Into the Wild" series. Thanks for following along.

Field Notes from a Solo Builder — Shipping the Beloved Claude Code Buddy Into the Wild - Part III

Steven Jieli Wu — Wed, 29 Apr 2026 02:04:23 +0000

Friday's launch felt good. We posted on LinkedIn, Reddit, the GitHub community threads. The repo was already appearing in Google's AI Overview — organic discovery, zero paid distribution.

But I'd made a mistake.

The Comparison Table Problem

While building, I'd come across another community project: Save Buddy. The person behind it had done serious work — reverse engineering the original Buddy implementation, documenting the hidden _react service endpoint Anthropic had been running, and building tooling to help people restore their existing companions. As of around April 10th, Anthropic had shut that endpoint down entirely. But Save Buddy had done the forensics.

In my README, I'd added a comparison table between my project and Save Buddy. The problem: I hadn't read their README carefully. I misrepresented what they'd built.

As soon as I realized it, I pulled the table and added proper attribution.

⚠️ Lesson Learned
"Read the README before you write about someone else's project. In open source, reputation is the currency — and accuracy is a form of respect."

Synergy Over Competition

Once I engaged with Save Buddy properly, I saw more opportunity than conflict.

The community feedback over the weekend was clear: many people didn't want to start a new Buddy from scratch. They had developed real emotional attachment to their specific companion over weeks. That was worth honoring.

By Monday night, I'd integrated the two approaches:

My system: new Buddy creation with leveling, mood mechanics, and expanded species
Save Buddy's approach: preserving existing companions people had already bonded with

Users who wanted to save their Buddy could. Users who wanted to level up a new one could do that too.

Onboarding as a First Impression

One thing that really inspired me was how OpenClaw approached onboarding — interactive terminal prompts, a guided setup flow, questions that made you feel like the tool was meeting you where you are. I wanted that same sense of delight for Buddy.

If someone's first experience in the terminal feels alive and considered, they're already bought in before they've written a single line of code.

Part of that vision involved ASCII art — giving Buddy a visual presence right there in the terminal.

Here's something nobody tells you: making precise ASCII art with AI is surprisingly hard.

It seems like it should be trivial for a text model, but spatial reasoning in a fixed-width character grid is not what these models are optimized for. Getting it to look right took significantly more iteration than expected.

🎨 Unexpected Lesson
"ASCII art with AI: harder than it looks. Spatial precision in a fixed-width grid is a genuinely different problem than generating prose. Budget more time than you think."

My First Contributor and the Effigy System

My first contributor — the same person who sent the Shell Turtle card and said LFG on Thursday night — brought something that solved a problem I hadn't fully named yet: the effigy system.

The feedback in the original Buddy was sometimes bland. The personality traits existed, but the ceiling was low. The effigy system pushes those traits further: make a snarky Buddy genuinely snarky, let the dominant trait really drive the voice of feedback rather than just nudging it.

Code review that feels unmistakably in character — not just flavored.

💡 Product Instinct
"The best contributor feedback names the thing you felt but couldn't articulate. They named it: 'the feedback feels bland.' That one sentence unlocked the effigy system."

The Power of Talking to Users

Throughout this week, my product instinct kept surfacing. When I was uncertain about a direction — like whether to support preserving existing Buddies — I ran it by real users. My contributor confirmed it. The Reddit thread confirmed it. The GitHub comments confirmed it.

The feature roadmap wasn't written from a spec. It was built by having AI synthesize community feedback, surface the recurring themes, and then validating those themes directly with people.

That loop — synthesize → validate → ship — is fast and it works.

Next up → Stars, clones, organic discovery, a first contributor, two merged projects in one week. What does all of it mean for how to build in 2025?

This is part 3 of the "Shipping Buddy Into the Wild" series.

Field Notes from a Solo Builder — Shipping the Beloved Claude Code Buddy Into the Wild - Part II

Steven Jieli Wu — Mon, 20 Apr 2026 19:43:29 +0000

The alpha was out. But I wasn't satisfied with the architecture.

The original Buddy had a fundamental fragility: tightly coupled to Claude Code. Every version upgrade could wipe it. And if you weren't running Claude Code specifically, you were excluded entirely. I didn't want to rebuild the same fragility.

The First Principle: No CLI Dependency

The core architectural decision was simple to state: Buddy must work with any CLI. Not just Claude Code. Whether you're running Gemini CLI, GitHub Copilot CLI, or something that doesn't exist yet — the feature should be available to you.

That constraint pointed directly to MCP — the Model Context Protocol. By implementing Buddy as an MCP server, we could decouple the personality layer from any specific CLI's version cycle and make it compatible with any harness that supports the protocol.

🏗️ Architecture Decision
"If it only works with Claude Code today, it dies the next time Claude Code updates. We needed a layer that could outlive any single CLI."

What We Learned About CLI Hooks

This is where reality checked us. Not all CLIs are built the same.

Claude Code has hooks. GitHub Copilot has hooks. Codex CLI has hooks. Cursor has hooks. But beyond those, support gets sparse fast. And the ability to customize the status line — that small but satisfying UI touch that shows Buddy's mood and level — is something only Claude Code cleanly exposes right now.

For Codex, we couldn't do it through normal means; it required patching the binary on an experimental branch, which directly violated our first principle of no hard harness dependency. That's an honest limitation we're sitting with as the ecosystem catches up.

The Token Tax Question

The second major design decision: do we pass the full diff to the model, or a summary?

Full diff means richer, more specific feedback. But our users are running Buddy on top of their own API subscriptions. They're paying for every token. I went with the summary approach — and when we launched on Friday and someone immediately posted on Reddit asking exactly how much overhead this adds per interaction, I knew we'd made the right call.

💡 Lesson Learned
"Build for your user's constraints, not your ideal conditions. Our users are paying their own token bills. Every unnecessary token is friction."

Three Modes, One Default

We shipped with three interaction modes:

Mode	What it does
Skill Coach	Code review feedback delivered in character
In-Character	Personality only, no review
Hybrid (default)	Both — full experience out of the box

Default is hybrid. Give users the full experience, let them dial back if needed.

My Build Workflow

For anyone curious how I actually built this, here's the process I follow:

Regular features → plan mode in Claude Code
Complex features → have Codex review the plan first
Complex implementations → have Codex review after building
Always → /simplify before committing
Big strategic decisions → gstack /office-hours for a long design conversation before touching code

Stack used:

Claude Code (plan mode + implementation)
MCP (Model Context Protocol)
One-line npm install
Summary-based code review (not full diff)
Codex for complex plan review
gstack /office-hours for architecture decisions

Next up → By Friday we had stars, a Reddit thread, and organic Google pickup. But a comparison table in the README almost caused a community problem — and what fixing it taught me about open source.

This is part 2 of the "Shipping Buddy Into the Wild" series about how we shipped https://github.com/fiorastudio/buddy v1 release in one week.

Field Notes from a Solo Builder — Shipping the Beloved Claude Code Buddy Into the Wild - Part I

Steven Jieli Wu — Thu, 16 Apr 2026 15:27:08 +0000

Last Thursday afternoon, I watched my community grieve.

Anthropic had deprecated /buddy — that witty, opinionated code-reviewing personality inside Claude Code — and developers were genuinely heartbroken. People were sad. They didn't want to close their terminals — some were leaving them open just to hold onto it for a little longer. Posts were going up in all caps. There was something raw about the reaction that struck a cord in my heart: this wasn't just frustration about a missing feature. This was grief.

I thought to myself: If Anthropic wouldn't keep this alive, why couldn't I?

The Original Buddy

For those who missed it: Buddy was Anthropic's built-in code review companion in Claude Code. It had personality traits — a spectrum from serious to snarky — and would deliver code feedback in character. It had a voice. That's rare in developer tooling, and people had built a connection with their terminal buddy.

The hypothesis in the community was that Anthropic shut it down because it was too expensive to sustain. A server-side endpoint "buddy react" — believed to be powered by Claude 3.5 Haiku — was running for every code review interaction across the user base.

After the Claude Code version v2.1.95 upgrade, the feature is gone, and there is no plan from anthropic to bring it back.

None of that made the loss feel less personal to the people who had built a connection with it.

💬 The Moment
"I might never close the Claude session that has Nuzzlecap." A well-respected community leader expressed his sadness vulnerably. He was not ready to say goodbye like many others, and people didn't want to close their terminals.

Thursday Morning: 14 Hours to Alpha

I started at 10 AM on a Thursday. I used Claude Code in plan mode first — studying source code, reading community research, mapping the architecture before touching implementation. My personal workflow: plan mode first, then build, then /simplify before committing. No rushing the thinking phase.

The constraints were clear from the start: make it work with any CLI, keep it token-efficient, give it real personality, and ship something people can actually use.

By midnight — roughly 14 hours later — I had an alpha. Not polished. Not feature-complete. But alive and shareable.

⚡ Builder's Note
"14 hours. Less than one day. While working my day job. The alpha wasn't perfect — but it was real, and that matters more than perfect."

The First Signal

Thursday night, I dropped the alpha in a Slack community. Feedback was immediate. One person loved it enough to volunteer as a contributor on the spot — bringing features they'd already been building independently: a slang mode and an effigy system designed to push personality traits further and make feedback unmistakably in-character.

I also posted in the main GitHub issue thread where the community was venting about the deprecation. The comments kept coming. The demand was clearly real.

The first thing my contributor shared back — a Buddy they'd generated with the alpha — said everything about whether this was landing:

★★★ EPIC — SHELL TURTLE

   Name: Datao

   "A defensive shell turtle wielding deep architectural
    insight who retreats into its shell at the first sign
    of a force push, hampered by missing the obvious bugs
    right in front of it. Moves slow but never ships a bug.
    Radiates an unmistakable aura of competence."

LFG. — They became my first and key contributor.

The same person followed up with two more lines I keep coming back to:

"I just want to say I love that you're writing your own. Hell yeah."

Within the first hour after the alpha dropped, we had 5 hearts. Not stars, not forks. Just people who gave a damn on a Thursday night. That was enough to keep going.

I wrapped around midnight. But I knew we were just getting started.

Next up → The alpha worked — and we made a few critical design decisions around first principles to ensure the buddy can never be taken away again.

This is part 1 of the "Shipping Buddy Into the Wild" series about how we shipped https://github.com/fiorastudio/buddy v1 release in one week.