Dogfooding

Scope

Covers

• Designing and running a dogfooding loop where the product team uses the product like a real user would

• Creating “creator commitments” when the product is for creators (e.g., publish a podcast, ship a workflow, run weekly reports)

• Capturing issues as reproducible artifacts (not vibes): logs, severity, decisions, owners, and follow-through

When to use

• “Set up a dogfooding program / dogfooding sprint for our product team.”

• “We’re shipping soon—make sure we’re using the product daily and fixing the biggest pain.”

• “We built this for creators; our team needs to be creators to understand the workflow.”

• “Create an internal beta plan and a weekly dogfooding report template.”

When NOT to use

• You need to validate market demand or solve who is the customer / what is the problem (do discovery first)

• The product team cannot realistically represent the workflow (e.g., regulated roles, hardware constraints) without proxies

• You’re looking for user research replacement (dogfooding complements—not replaces—external user feedback)

• The only goal is “QA everything” (use a QA/test plan; dogfooding is for experience + value + workflow realism)

Inputs

Minimum required

• Product summary + target user persona (who it’s for; what job it does)

• 1–3 core workflows to dogfood (end-to-end)

• Time box + cadence (e.g., 1 week sprint; 20 min/day; weekly triage)

• Participants (roles) + any “creator commitments” required

• Environment constraints (prod vs staging; data/privacy constraints; access constraints)

Missing-info strategy

• Ask up to 5 questions from references/INTAKE.md.

• If answers aren’t available, proceed with explicit assumptions and label unknowns. Offer 2 scope options (lean vs thorough).

Outputs (deliverables)

Produce a Dogfooding Pack in Markdown (in-chat; or as files if requested):

• Context snapshot (product, persona, workflows, constraints, time box)

• Dogfooding charter (goals, participants, rules, cadence, definitions)

• Scenario map + routines (daily/weekly tasks + “creator commitments”)

• Dogfooding log + triage board spec (fields, severity scale, decision rules)

• Weekly dogfooding report (insights, decisions, shipped fixes, next experiments)

• Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md

Workflow (7 steps)

1. Frame the dogfooding goal (experience, not just bugs)

• Inputs: Product summary; desired outcomes; references/INTAKE.md.

• Actions: Define what “success” means for this cycle (e.g., “team can complete workflow A in <10 min without workarounds”). Set constraints (environment, data, access).

• Outputs: Context snapshot + explicit success criteria.

• Checks: Success criteria are measurable and tied to a real workflow outcome (not “feel better”).

2. Define representative scenarios + “creator commitments”

• Inputs: Target persona + workflows.

• Actions: Create 3–8 scenarios that represent real user goals. If the product is for creators, define a publish cadence (e.g., “each PM publishes 1 artifact/week”).

• Outputs: Scenario map + routine plan.

• Checks: At least 1 scenario is “from scratch → shipped/published” end-to-end.

3. Set up the capture system (log, severity, triage)

• Inputs: Existing tools (Jira/Linear/Notion/Sheets) or “none”.

• Actions: Define the dogfooding log schema, severity scale, and triage rules. Decide labels/tags to link issues to scenarios and workflow steps.

• Outputs: Dogfooding log + triage board spec.

• Checks: Any issue can be reproduced with a clear “steps to reproduce + expected vs actual + evidence”.

4. Run daily dogfooding sessions (time-boxed)

• Inputs: Scenario map + routines.

• Actions: Each participant runs 1–2 scenarios/day, captures friction immediately, and attaches evidence (screens, logs, timestamps). Record “workarounds used”.

• Outputs: Daily log entries + a rolling “top pains” list.

• Checks: Entries are concrete (repro steps) and prioritized by impact on completing the workflow.

5. Triage weekly: decide, assign, and protect focus

• Inputs: Log + top pains.

• Actions: Run triage: cluster duplicates, classify (bug/UX debt/gap/docs), assign owners, and decide “fix now / schedule / won’t fix (with reason)”. Update scenario map if it was unrealistic.

• Outputs: Prioritized backlog + decision notes.

• Checks: Top 3–5 issues map directly to blocked/slow scenarios and have an owner + next action.

6. Ship loop: verify fixes by dogfooding again (no-ship gate)

• Inputs: “Fix now” items + release plan.

• Actions: For each fix, re-run the scenario end-to-end. Apply a simple gate: “We can complete the scenario with no hidden workarounds in the chosen environment.”

• Outputs: Verified fixes list + any regressions.

• Checks: The gate is based on completing scenarios, not just closing tickets.

7. Report + quality gate + next cycle plan

• Inputs: Final log + triage outcomes.

• Actions: Produce the weekly report. Run references/CHECKLISTS.md and score with references/RUBRIC.md. Add Risks/Open questions/Next steps and propose the next dogfooding cycle focus.

• Outputs: Final Dogfooding Pack.

• Checks: Report contains decisions (what changed) and shows evidence-backed learning (not just a bug list).

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.

• Always include: Risks, Open questions, Next steps.

Examples

Example 1 (Creator product): “We’re building a podcast creation tool. Create a dogfooding program where the whole team publishes 1 short episode/week, and produce a weekly report template.”

Expected: scenarios from “idea → published episode”, creator commitments, log schema, triage cadence, and ship gate tied to publishing.

Example 2 (B2B workflow product): “Set up a 2-week dogfooding sprint for our AI meeting notes tool focused on ‘record → summary → share → action items’.”

Expected: scenario map, daily routine, severity scale, triage rules, weekly report, and a verified-fixes list.

Boundary example: “Dogfood this idea we haven’t built yet.”

Response: dogfooding requires a usable artifact; propose discovery + prototype/usability testing first, then a dogfooding sprint once there’s something to run end-to-end.