⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
dogfood
Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to "dogfood", "QA", "exploratory test", "find issues", "bug hunt", "test this app/site/platform", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
GNO
Search finds. GNO proves.
A local knowledge engine for your notes, code, PDFs, and Office docs. Hybrid search, a browsable workspace with graph and editor, CLI, SDK, REST API, and MCP for ten AI clients — plus retrieval that can show its work.

bun install -g @gmickel/gno
gno setup ~/notes --name notes # returns only after retrieval actually works
gno skill install --target claude --scope user # choose your agent below
gno agents install --target claude # teach retrieval and writing discipline
gno agents verify --target claude
Custom fields such as project, approval status, and numeric confidence can constrain retrieval with typed metadata filters, across CLI, MCP, SDK, REST, and the Web UI.
What you get
One local index across everything you have. Markdown, PDFs, Office documents, plain text, source code, and portable mail, calendar and transcript exports. Point it at a folder that mixes all of them and it handles the mix.
Three ways to search it. Keyword (BM25), semantic (vector), and hybrid — fused, reranked, and explainable, with structured intent controls and metadata filters. Ask for "how we handle retries" and find the paragraph about exponential backoff that never uses the word.
A workspace, not a search box. Cross-collection folder tree, per-tab browse context, a markdown editor, provenance-carrying quick capture, and a navigable knowledge graph.
Answers with citations. Ask a question in natural language and get an answer built from your own documents, with citations that resolve to the source passage.
Six interfaces on one index. A fast CLI, a web UI, a REST API, a TypeScript SDK, an MCP server, and a headless daemon — plus one-command install into ten agent clients. Nothing drifts between them.
Optional hosted publishing at gno.sh when a slice needs a URL.
No GPU required, no account required, no telemetry. Free and MIT licensed.
Why not just another local RAG tool
The above is most of what people use day to day. Beyond it, four things here are different, and each one is measurable rather than adjectival:
| What it does | Why it matters | |
|---|---|---|
| Context Capsules | Compiles one bounded evidence bundle per goal: exact line spans, content hashes, one global token budget, collapsed duplicates, and a written list of what it could not find | Your agent reads once instead of searching five times. 48.94% fewer retrieval calls, 44.12% less model-visible context, 100% task accuracy retained across 48 paired benchmark tasks |
| Verified answers | gno ask --verify generates against one closed Capsule, classifies every substantive claim, and withholds the draft below 100% support | An abstention naming the failing claim beats a confident paragraph you have to fact-check by hand |
| Verified setup | gno setup returns only after lexical search finds a real hit derived from your corpus | No green checkmark over a folder that indexed but cannot be searched |
| Egress policy | Per-collection fail-closed local_only / lan / remote, inherited by every derived Capsule, trace, and export | Mixed setups are normal. Pin the client work local while your notes use the LAN GPU box |
Everything runs on your machine. Zero telemetry. The three network boundaries are explicit: downloading a model, configuring an HTTP inference endpoint, and uploading an artifact you exported for publishing.
And the receipts ship too. Every benchmark behind these numbers is committed to the repository against a pinned corpus, with its limitations stated alongside the result, so you can replay it rather than take it on trust.
Use it when
- your knowledge is split across Markdown, code, PDFs, Office files, and exported mail or transcripts
- you want one retrieval layer for the CLI, the browser, MCP, and a Bun/TypeScript SDK
- you want your coding agent to have a real memory without shipping your docs to a cloud API
- you want to search what you and your coding agents said in past sessions, kept apart from your curated notes
- you need to prove, later, which bytes supported a conclusion
Two minutes, end to end
# Install
bun install -g @gmickel/gno
# Activate a folder. Returns only after BM25 proves an exact corpus-derived hit;
# semantic embedding continues independently in the background.
gno setup ~/notes --name notes
# Connect your agent and teach the retrieval protocol (Claude shown)
gno skill install --target claude --scope user
gno agents install --target claude
gno agents verify --target claude
# Add more sources
gno collection add ~/work/docs --name work-docs --pattern "**/*.{md,pdf,docx}"
gno collection add ~/work/gno/src --name gno-code --pattern "**/*.{ts,tsx,js,jsx}"
# Tell retrieval what each collection is for
gno context add "work-docs:" "Architecture docs, runbooks, RFCs, meeting notes"
gno update --yes # sync
gno embed # embed when you want semantic retrieval
# Pick the search that fits the question
gno search "DEC-0054" # exact identifier
gno vsearch "retry failed jobs with backoff" # natural language
gno query "JWT refresh token rotation" --explain # hybrid, with score traces
# Compile checkable evidence for a goal, then re-check it later
gno context build "why we dropped the queue rewrite" \
--collection work-docs --budget 12000 --json --output capsule.json
gno context verify capsule.json
# Generate only what that evidence supports
gno ask "why did we drop the queue rewrite" --verify --show-sources
# Run the workspace (pick one — not both against the same index)
gno serve # browser/desktop Web UI
gno daemon --detach # headless indexing + resident MCP gateway
[!TIP] gno.sh/publish is live. Turn any GNO note or collection into a reader-first URL — editorial typography, scoped search, and four visibility modes from public to encrypted-before-upload. See the reader →
[!TIP] OpenClaw and Hermes Agent: Use GNO as a second brain or LLM wiki. Install the skill and retrieval
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
.agents/skills/dogfood/SKILL.md7.8 KBupstream ↗
--- name: dogfood description: Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to "dogfood", "QA", "exploratory test", "find issues", "bug hunt", "test this app/site/platform", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams. allowed-tools: Bash(agent-browser:*), Bash(npx agent-browser:*) --- # Dogfood Systematically explore a web application, find issues, and produce a report with full reproduction evidence for every finding. ## Setup Only the **Target URL** is required. Everything else has sensible defaults -- use them unless the user explicitly provides an override. | Parameter | Default | Example override | | -------------------- | ----------------------------------------------------- | ------------------------------------- | | **Target URL** | _(required)_ | `vercel.com`, `http://localhost:3000` | | **Session name** | Slugified domain (e.g., `vercel.com` -> `vercel-com`) | `--session my-session` | | **Output directory** | `./dogfood-output/` | `Output directory: /tmp/qa` | | **Scope** | Full app | `Focus on the billing page` | | **Authentication** | None | `Sign in to [email protected]` | If the user says something like "dogfood vercel.com", start immediately with defaults. Do not ask clarifying questions unless authentication is mentioned but credentials are missing. Always use `agent-browser` directly -- never `npx agent-browser`. The direct binary uses the fast Rust client. `npx` routes through Node.js and is significantly slower. ## Workflow ``` 1. Initialize Set up session, output dirs, report file 2. Authenticate Sign in if needed, save state 3. Orient Navigate to starting point, take initial snapshot 4. Explore Systematically visit pages and test features 5. Document Screenshot + record each issue as found 6. Wrap up Update summary counts, close session ``` ### 1. Initialize ```bash mkdir -p {OUTPUT_DIR}/screenshots {OUTPUT_DIR}/videos ``` Copy the report template into the output directory and fill in the header fields: ```bash cp {SKILL_DIR}/templates/dogfood-report-template.md {OUTPUT_DIR}/report.md ``` Start a named session: ```bash agent-browser --session {SESSION} open {TARGET_URL} agent-browser --session {SESSION} wait --load networkidle ``` ### 2. Authenticate If the app requires login: ```bash agent-browser --session {SESSION} snapshot -i # Identify login form refs, fill credentials agent-browser --session {SESSION} fill @e1 "{EMAIL}" agent-browser --session {SESSION} fill @e2 "{PASSWORD}" agent-browser --session {SESSION} click @e3 agent-browser --session {SESSION} wait --load networkidle ``` For OTP/email codes: ask the user, wait for their response, then enter the code. After successful login, save state for potential reuse: ```bash agent-browser --session {SESSION} state save {OUTPUT_DIR}/auth-state.json ``` ### 3. Orient Take an initial annotated screenshot and snapshot to understand the app structure: ```bash agent-browser --session {SESSION} screenshot --annotate {OUTPUT_DIR}/screenshots/initial.png agent-browser --session {SESSION} snapshot -i ``` Identify the main navigation elements and map out the sections to visit. ### 4. Explore Read [references/issue-taxonomy.md](references/issue-taxonomy.md) for the full list of what to look for and the exploration checklist. **Strategy -- work through the app systematically:** - Start from the main navigation. Visit each top-level section. - Within each section, test interactive elements: click buttons, fill forms, open dropdowns/modals. - Check edge cases: empty states, error handling, boundary inputs. - Try realistic end-to-end workflows (create, edit, delete flows). - Check the browser console for errors periodically. **At each page:** ```bash agent-browser --session {SESSION} snapshot -i agent-browser --session {SESSION} screenshot --annotate {OUTPUT_DIR}/screenshots/{page-name}.png agent-browser --session {SESSION} errors agent-browser --session {SESSION} console ``` Use your judgment on how deep to go. Spend more time on core features and less on peripheral pages. If you find a cluster of issues in one area, investigate deeper. ### 5. Document Issues (Repro-First) Steps 4 and 5 happen together -- explore and document in a single pass. When you find an issue, stop exploring and document it immediately before moving on. Do not explore the whole app first and document later. Every issue must be reproducible. When you find something wrong, do not just note it -- prove it with evidence. The goal is that someone reading the report can see exactly what happened and replay it. **Choose the right level of evidence for the issue:** #### Interactive / behavioral issues (functional, ux, console errors on action) These require user interaction to reproduce -- use full repro with video and step-by-step screenshots: 1. **Start a repro video** _before_ reproducing: ```bash agent-browser --session {SESSION} record start {OUTPUT_DIR}/videos/issue-{NNN}-repro.webm ``` 2. **Walk through the steps at human pace.** Pause 1-2 seconds between actions so the video is watchable. Take a screenshot at each step: ```bash agent-browser --session {SESSION} screenshot {OUTPUT_DIR}/screenshots/issue-{NNN}-step-1.png sleep 1 # Perform action (click, fill, etc.) sleep 1 agent-browser --session {SESSION} screenshot {OUTPUT_DIR}/screenshots/issue-{NNN}-step-2.png sleep 1 # ...continue until the issue manifests ``` 3. **Capture the broken state.** Pause so the viewer can see it, then take an annotated screenshot: ```bash sleep 2 agent-browser --session {SESSION} screenshot --annotate {OUTPUT_DIR}/screenshots/issue-{NNN}-result.png ``` 4. **Stop the video:** ```bash agent-browser --session {SESSION} record stop ``` 5. Write numbered repro steps in the report, each referencing its screenshot. #### Static / visible-on-load issues (typos, placeholder text, clipped text, misalignment, console errors on load) These are visible without interaction -- a single annotated screenshot is sufficient. No video, no multi-step repro: ```bash agent-browser --session {SESSION} screenshot --annotate {OUTPUT_DIR}/screenshots/issue-{NNN}.png ``` Write a brief description and reference the screenshot in the report. Set **Repro Video** to `N/A`. --- **For all issues:** 1. **Append to the report immediately.** Do not batch issues for later. Write each one as you find it so nothing is lost if the session is interrupted. 2. **Increment the issue counter** (ISSUE-001, ISSUE-002, ...). ### 6. Wrap Up Aim to find **5-10 well-documented issues**, then wrap up. Depth of evidence matters more than total count -- 5 issues with full repro beats 20 with vague descriptions. After exploring: 1. Re-read the report and update the summary severity counts so they match the actual issues. Every `### ISSUE-` block must be reflected in the totals. 2. Close the session: ```bash agent-browser --session {SESSION} close ``` 3. Tell the user the report is ready and summarize findings: total issues, breakdown by severity, and the most critical items. ## Guidance - **Repro is everything.** Every issue needs proof -- but match the evidence to the issue. Interactive bugs need video and step-by-step screenshots. Static bugs (typos, placeholder text, visual glitches visible on load) only need a single annotated screenshot. - **Don't record video for static issues.** A typo or clipped text doesn't benefit fromREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/gmickel-gno-agents-skills-dogfood.md