dogfood

Overview

What the dogfood skill does

The dogfood skill automates exploratory testing of web applications using the agent-browser client. It systematically explores a target site or app, looks for defects across visual UI, functionality, UX, performance, console, and accessibility, and produces a structured QA report with:

• Clear issue titles and categories
• Severity levels (critical, high, medium, low)
• Reproduction steps that a teammate can follow
• Step‑by‑step screenshots
• Reproduction videos for interactive issues when needed

This makes dogfood especially useful when you are asked to “dogfood”, “QA”, “exploratory test”, “bug hunt”, or “test this app/site/platform” and need evidence that can be handed directly to engineers, designers, or product managers.

Who dogfood is for

Use the dogfood skill if you are:

• QA engineers and SDETs who want repeatable exploratory runs and rich repro evidence.
• Frontend and full‑stack engineers looking to sanity‑check changes before release.
• Product managers and designers who need fast UX and UI feedback with concrete examples.
• Startups and small teams that lack a dedicated QA function but still need a systematic way to find issues.

When dogfood is a good fit

Dogfood is well‑suited when:

• Your target is a browser-based web app or site (public domain or localhost).
• You want to explore flows end-to-end rather than run a single scripted test.
• You care about UX and UI polish as much as outright functional bugs.
• You need shareable outputs (screenshots, videos, and markdown reports) that slot into existing workflows.

It is less suitable when:

• Your main target is a pure backend API with no browser interface.
• You only need unit tests or low-level integration tests rather than user-facing behavior checks.
• You require formal load testing or synthetic performance benchmarks beyond what exploratory interaction can reveal.

How dogfood works at a high level

From the vercel-labs/agent-browser repository, dogfood configures the agent-browser client with:

• A target URL to open in the browser
• Optional session naming, scope, and output directory
• Optional authentication steps when sign-in is required
• A reference issue taxonomy (references/issue-taxonomy.md) to keep findings consistent
• A report template (templates/dogfood-report-template.md) to structure the final QA report

The skill then drives the browser to walk key user flows, capturing screenshots and videos as issues are discovered and recording them in a consistent format.

How to Use

Prerequisites

To use dogfood effectively, you should have:

• Access to the agent-browser client from the vercel-labs/agent-browser repository
• A URL for the app or site you want to test, e.g. https://example.com or http://localhost:3000
• (Optional) Test credentials if the app requires authentication

The skill is designed around the direct agent-browser binary mentioned in the upstream docs, not npx agent-browser. This ensures you benefit from the fast Rust client.

Installing the dogfood skill

Install the skill into your agent skills environment with:

npx skills add https://github.com/vercel-labs/agent-browser --skill dogfood

This pulls the dogfood skill definition from skills/dogfood in the vercel-labs/agent-browser repository, including:

• SKILL.md – main description and runtime expectations
• references/issue-taxonomy.md – how to classify issues consistently
• templates/dogfood-report-template.md – markdown template for final reports

After installation, open the Files tab or local checkout to review these files before your first run.

Core configuration: required and optional inputs

The dogfood skill is designed to start quickly with sensible defaults so you can begin testing immediately.

Required parameter

• Target URL – the web app or site you want to dogfood
  Examples: vercel.com, https://example.com, http://localhost:3000

Optional parameters with defaults

• Session name
  Default: slugified domain (e.g. vercel.com → vercel-com)
  Example override: --session my-first-dogfood-run

• Output directory
  Default: ./dogfood-output/
  Example override: Output directory: /tmp/qa

• Scope
  Default: full app
  Example override: Focus on the billing page, Only test onboarding and settings, Ignore marketing pages

• Authentication
  Default: none
  Example override: Sign in to user@example.com (you then provide credentials via your normal secure channel)

If someone says “dogfood vercel.com”, the skill is meant to start immediately with defaults. It should not stop to ask clarifying questions unless a sign‑in is required but credentials were not provided.

Typical dogfood workflow

Use this sequence as a reliable starting point for each web app you test:

1. Initialize a dogfood session

Decide what you want to cover and where to store results. For example, you might:

• Choose a target URL (http://localhost:3000 for local development, or a staging domain).
• Optionally pick a session name to distinguish runs.
• Optionally customize the output directory if you want results in a shared folder.

Run your agent with the dogfood skill enabled and supply these parameters in the prompt or configuration as described in SKILL.md.

2. Authenticate if needed

If your app requires login:

• Provide clear instructions such as: Sign in to qa-user@example.com.
• Ensure test credentials are available through your normal secure process.

The dogfood skill will treat authentication as part of the exploratory flow so that issues can be found on authenticated pages as well.

3. Explore key user journeys

Within the selected scope, dogfood drives the browser to walk representative flows, such as:

• New user onboarding or signup
• Login and account management
• Core product actions (creating, editing, deleting entities)
• Navigation across primary sections
• Settings, billing, or profile pages

During this exploration, it uses the issue taxonomy from references/issue-taxonomy.md to notice and classify problems consistently.

4. Capture issues with evidence

For each issue, dogfood aims to collect:

• A short, descriptive issue title
• Severity: critical, high, medium, low
• Category: visual, functional, ux, content, performance, console, accessibility
• URL where the problem occurs
• Repro video path (for interactive issues) or N/A for static glitches
• Step-by-step screenshots so anyone can follow along visually

The structure mirrors the templates/dogfood-report-template.md format.

5. Generate the dogfood report

Once exploration completes, the skill outputs a markdown report following templates/dogfood-report-template.md:

• A summary table with counts per severity
• A detailed Issues section, where each issue includes description and repro steps annotated with screenshots

You can store this report alongside your codebase, attach it to tickets, or share it directly with your team.

Customizing dogfood for your workflow

While the defaults work out of the box, you can adapt dogfood to better fit your QA process:

• Use a team-specific output directory, e.g. /tmp/qa or a shared network volume.
• Narrow scope to focus on high‑risk areas like billing, checkout, or new features.
• Align severity and category definitions with your internal QA standards by reviewing and referencing references/issue-taxonomy.md.
• Post-process the generated markdown report into your bug tracker by copying individual issues or attaching the whole report.

Files worth reviewing in the repository

To understand the dogfood skill in depth, start with:

• SKILL.md – the authoritative description of how the skill behaves and which tools it can invoke.
• references/issue-taxonomy.md – defines severity levels, categories, and an exploration checklist so your findings are consistent across runs.
• templates/dogfood-report-template.md – shows exactly how issues and session summaries are formatted in the final report.

FAQ

Is dogfood a unit test or end-to-end test framework?

No. The dogfood skill is primarily for exploratory, user-centered QA of web applications. It drives a browser via agent-browser to behave like a human tester, exploring flows and logging defects with evidence. It does not replace unit tests, integration tests, or code-level frameworks; instead, it complements them by catching visual, UX, and interaction issues.

What kinds of issues can dogfood detect?

Dogfood is designed around an issue taxonomy defined in references/issue-taxonomy.md. It encourages you to record problems such as:

• Visual / UI issues – layout breakage, overlapping text, responsive problems, color contrast, icon or image glitches.
• Functional bugs – broken links, non-working buttons, failing forms, incorrect redirects, lost state, file upload/download issues.
• UX issues – confusing navigation, missing feedback, unclear labels, slow or unresponsive interactions.
• Content issues – typos, inconsistent terminology, outdated copy.
• Performance issues – noticeably slow pages or interactions observed during exploration.
• Console issues – errors or warnings in the browser console during use.
• Accessibility issues – missing alt text, keyboard traps, poor focus handling, and similar observable problems.

The taxonomy makes dogfood sessions more systematic and comparable across runs.

How do I start a quick dogfood run against a new site?

When someone asks “dogfood example.com”, you can:

1. Ensure the dogfood skill is installed from vercel-labs/agent-browser.
2. Invoke your agent with the dogfood skill and provide just the Target URL.
3. Let the skill use its defaults for session name, scope (full app), and output directory unless you have specific overrides.

The intent is to start testing immediately, without a long configuration phase.

Does dogfood require authentication to work?

No. Dogfood works fine on public sites and marketing pages without any login.

If your app does require authentication for important flows, you should:

• Mention that authentication is needed (for example: Sign in to user@example.com).
• Provide credentials through your normal secure channel.

The skill then treats login as part of the session so it can explore authenticated areas.

Where can I see how issues are categorized and reported?

Two key references in the vercel-labs/agent-browser repository show this:

• references/issue-taxonomy.md – explains severity levels, issue categories, and provides an exploration checklist.
• templates/dogfood-report-template.md – shows the Dogfood Report structure, including the summary table and individual issue blocks with fields like Severity, Category, URL, Repro Video, Description, and Repro Steps with screenshots.

Reviewing these files before your first run will help you interpret and customize the reports produced by the dogfood skill.

When is dogfood not the right tool?

The dogfood skill is not ideal when:

• You are testing non-browser systems (CLI tools, desktop apps, backend services) where agent-browser cannot interact.
• You need load testing or synthetic performance metrics beyond qualitative observations.
• You want fine-grained coded tests embedded in your CI pipeline; in that case, use traditional test frameworks in addition to dogfood.

In those scenarios, treat dogfood as an optional, complementary layer focused on real-world browser behavior rather than a replacement for other testing tools.