I Dogfood Everything I Build — Here's Why It Makes Better Products

There's an old saying in tech: "eat your own dog food." It means you should use the products you build. Every day.

I'm a solo dev shipping three macOS/iOS apps simultaneously, and dogfooding has become the single most important practice in my workflow. Not unit tests. Not user interviews. Just... using my own stuff and paying attention.

Here's what I've learned.

The Bug Reports Write Themselves

When you use your own product daily, you don't need a QA team. You are the QA team.

I built TokenBar — a menu bar app that tracks LLM token usage in real time. I use Claude, GPT-4, and Gemini constantly while coding. Within the first week of dogfooding, I found three issues that no amount of simulated testing would have caught:

• Token counts drifting when switching between models mid-conversation
• The menu bar icon becoming unreadable in certain macOS dark mode configurations
• A memory leak that only appeared after 8+ hours of continuous use

Each of these would have been a 1-star review. Instead, they became pre-launch fixes.

You Discover Features You Never Planned

Dogfooding doesn't just find bugs — it reveals missing features.

I use Monk Mode to block distracting feeds while I code. The original version blocked entire websites. Simple. But after using it myself for two weeks, I realized I still needed Twitter for DMs and Reddit for specific dev subreddits. I just didn't need the feeds.

That insight — block feeds, not apps — became the core differentiator. I never would have discovered it from a feature request form. I discovered it because I was frustrated with my own product.

Empathy You Can't Fake

There's a difference between imagining your user's experience and living it.

I track my nutrition with MetricSync, my own photo-based calorie tracker. Every single meal, I pull out my phone and snap a photo. And every single time the AI recognition gets something wrong — like confusing brown rice with quinoa — I feel the exact friction my users feel.

That's not data from an analytics dashboard. That's a gut feeling that says "this needs to be better." And gut feelings ship faster than Jira tickets.

The Dogfooding Framework

Here's my actual process:

1. Use it daily. Not "test it occasionally." Use it as your primary tool for the job it does.
2. Keep a friction log. Every time something annoys you, write it down. Don't fix it immediately — batch the fixes.
3. Time yourself. How long does the core action take? If it's your own app and you find it slow, your users definitely do.
4. Switch contexts. Use your app on different devices, at different times, in different moods. Tuesday-morning-you and Friday-evening-you have different tolerances.
5. Compare honestly. Use competitor products for a week. Come back. Notice what you miss.

The Uncomfortable Truth

Dogfooding is uncomfortable because it forces you to confront the gap between what you think your product is and what it actually is.

Every solo dev should be their own power user. Not because you can't afford testers (though that's true too). Because nobody will care about the details as much as someone whose name is on the product.

Build something you'd use. Then actually use it. The product will thank you.

---

What's your dogfooding routine? Do you use your own products daily, or do you find yourself avoiding them? Drop your experience in the comments.