Agent skill

Frontend Test

by qf-studio in qf-studio/navigator

Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components.

MITAuto-check: notesFrontend & Design

Install Frontend Test

skills CLI
$ npx skills add qf-studio/navigator --skill frontend-test -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install qf-studio/navigator frontend-test --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/qf-studio/navigator.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/frontend-test .claude/skills/frontend-test && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
frontend-test
GitHub stars
354
Token cost
~1.6k tokens
SKILL.md length
318 words
Files
1
Skills in repo
32
Repo updated
First seen
Licence
MIT

At a glance

Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components.

  • Works in 6 steps: Check Existing Patterns (Phase 0) → Locate Component Under Test → Detect Test Framework + Library → …
  • Says test this component
  • SKILL.md covers When to Invoke, Execution Steps, Success Criteria and When NOT to Use This Skill
  • Calls python3

What it does

Frontend Test is an agent skill from qf-studio/navigator. Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components. Auto-invoke when user says "test this component", "write component test", or "add component test".

Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design. It works with Testing Library and Vue.js. The repository describes itself as: Finish What You Start — Context engineering for Claude Code. Sessions last 20+ exchanges instead of crashing at 7. The licence is MIT.

When your agent uses it

  • Says test this component
  • Write component test
  • Add component test

Example prompts

  • “test this component”
  • “write component test”
  • “add component test”
  • “/frontend-test”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Grep, Glob, Bash

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Check Existing Patterns (Phase 0)
  2. Locate Component Under Test
  3. Detect Test Framework + Library
  4. Generate Test File
  5. Verify
  6. Emit Execution Summary (Graph Ingestion)

What it can do on your machine

Read from SKILL.md and the folder at commit f1cf0eb. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Grep
    • Glob
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Frontend Test loads about 1.6k tokens when it runs. Until then it costs about 55 tokens; SKILL.md has 318 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~55
When it runs · the whole SKILL.md, loaded when a task matches
~1.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Grep, Glob, Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from qf-studio/navigator at commit f1cf0eb, republished under its MIT licence (© qf-studio). 318 words, ~1,585 tokens.

Download SKILL.mdSave it as .claude/skills/frontend-test/SKILL.md (or your agent's skills folder).
name
frontend-test
description
Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components. Auto-invoke when user says "test this component", "write component test", or "add component test".
allowed-tools
Read, Write, Edit, Grep, Glob, Bash
version
2.0.0

Frontend Component Test Generator

Generate component tests for existing components — typically components written without tests, or where additional coverage is needed beyond what frontend-component already produced.

When to use this vs. frontend-component: frontend-component generates tests as part of creating a new component. Use frontend-test when the component already exists and you need to add or expand its tests.

When to Invoke

Auto-invoke when user says:

  • "Test this component"
  • "Write component test"
  • "Add component test"
  • "Test component [name]"
  • "Component tests for [name]"

Execution Steps

Step 0: Check Existing Patterns (Phase 0)
bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action query --concept frontend \
  --graph-path .agent/knowledge/graph.json 2>/dev/null | head -40

python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action query --concept testing \
  --graph-path .agent/knowledge/graph.json 2>/dev/null | head -40

Look for patterns about test utilities used (RTL vs Enzyme), snapshot policy, accessibility-test conventions.

Step 1: Locate Component Under Test

Ask if not specified:

Which component should I test?
  - File path (e.g., src/components/UserProfile.tsx)
  - Component name (e.g., UserProfile)

Read the component in full so generated tests cover actual behavior (props handled, events emitted, conditional rendering, etc.).

Step 2: Detect Test Framework + Library
bash
# React Testing Library
grep -q '"@testing-library/react"' package.json 2>/dev/null && echo "RTL detected"
# Vue Test Utils
grep -q '"@vue/test-utils"' package.json 2>/dev/null && echo "Vue Test Utils detected"
# Test runner
grep -q '"vitest"' package.json 2>/dev/null && echo "Vitest"
grep -q '"jest"' package.json 2>/dev/null && echo "Jest"

Check for setupTests.ts / vitest.setup.ts to understand global utilities and matchers.

Step 3: Generate Test File

File location: colocate with the component (UserProfile.test.tsx next to UserProfile.tsx) unless the project convention is otherwise.

Structure (RTL + Vitest/Jest):

tsx
import { describe, it, expect, vi } from 'vitest';  // or '@jest/globals'
import { render, screen } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { {COMPONENT_NAME} } from './{COMPONENT_NAME}';

describe('{COMPONENT_NAME}', () => {
  describe('rendering', () => {
    it('renders with required props', () => {
      render(<{COMPONENT_NAME} {...{REQUIRED_PROPS}} />);
      expect(screen.getByRole('{ROLE}')).toBeInTheDocument();
    });

    it('renders conditional content when prop is set', () => {
      render(<{COMPONENT_NAME} {...{REQUIRED_PROPS}} {OPTIONAL_PROP} />);
      expect(screen.getByText('{EXPECTED_TEXT}')).toBeInTheDocument();
    });
  });

  describe('interactions', () => {
    it('calls onClick handler when clicked', async () => {
      const user = userEvent.setup();
      const onClick = vi.fn();
      render(<{COMPONENT_NAME} {...{REQUIRED_PROPS}} onClick={onClick} />);
      await user.click(screen.getByRole('button'));
      expect(onClick).toHaveBeenCalledOnce();
    });
  });

  describe('accessibility', () => {
    it('has accessible name', () => {
      render(<{COMPONENT_NAME} {...{REQUIRED_PROPS}} />);
      expect(screen.getByRole('{ROLE}')).toHaveAccessibleName();
    });
  });
});

Snapshot tests: only generate if the project's existing tests use them (check peer test files first). They're easy to over-rely on; prefer assertion-based tests for behavior, snapshots only for stable visual structure.

Step 4: Verify
bash
{TEST_COMMAND} {COMPONENT_NAME}

If tests fail because they assume incorrect behavior, fix the tests. Only fix the component if it's actually buggy — surface that to the user.

Step 5: Emit Execution Summary (Graph Ingestion)
json
{
  "execution_summary": {
    "skill": "frontend-test",
    "task": "tests for {COMPONENT_NAME}",
    "files_created": ["{test file path}"],
    "files_modified": [],
    "tests_added": ["{test file path}"],
    "stack_detected": "{e.g. react+rtl+vitest}",
    "patterns_followed": [
      {"summary": "{e.g. queries via getByRole, not getByTestId}", "concepts": ["frontend", "testing"], "confidence": 0.85}
    ],
    "decisions_made": [
      {"summary": "{e.g. asserted accessible name instead of snapshot to avoid brittleness}", "concepts": ["testing"], "confidence": 0.8}
    ],
    "pitfalls_avoided": [
      {"summary": "{e.g. used userEvent.setup() not fireEvent — RTL recommendation}", "concepts": ["testing"], "confidence": 0.85}
    ],
    "assumptions_made": ["{e.g. project uses Vitest globals from setup file}"]
  }
}

Ingest:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
echo '<execution_summary JSON>' | python3 "$PLUGIN_DIR/skills/nav-graph/functions/execution_to_graph.py" -

Success Criteria

  • Test file colocated with component (or per project convention)
  • Rendering, interactions, and at least one accessibility check covered
  • Queries use getByRole / getByLabelText over getByTestId where possible
  • All generated tests pass on first run
  • Execution summary emitted

When NOT to Use This Skill

  • You're creating a new component from scratch — use frontend-component (it generates tests as part of its workflow)
  • You want to test a backend endpoint or service — use backend-test
  • You want visual regression testing — use visual-regression

© qf-studio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/frontend-test of qf-studio/navigator.

Open the folder on GitHubat commit f1cf0eb

Compare with similar skills

Frontend Test next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Frontend Test compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Frontend Test this skillqf-studio/navigator354—~1.6kAutomated safety check: NotesMIT
Testing FrontendMadAppGang/claude-code284—~2.9kAutomated safety check: PassMIT
Tailwindcss Developmentanonaddy/anonaddy4.9k10 repos~865Automated safety check: PassMIT
GSAP Core Animationgreensock/gsap-skills16k4 repos~3.7kAutomated safety check: PassMIT
GSAP in Vue, Nuxt and Sveltegreensock/gsap-skills16k4 repos~2.6kAutomated safety check: PassMIT
Vuetify Playgroundvuetifyjs/vuetify41k—~730Automated safety check: PassCustom licence

Similar skills

  • Testing Frontend

    MadAppGang/claude-code

    A skill your agent uses when writing component tests, testing user interactions, mocking APIs, or setting up Vitest/React Testing Library/Vue Test Utils for frontend applications.

    284 GitHub stars~2.9k tokensUpdated 6 mo ago
    Testing & QAAuto-check passed
  • Tailwindcss Development

    anonaddy/anonaddy

    Always invoke when the user's message includes 'tailwind' in any form.

    4.9k GitHub starsUsed in 10 repos~865 tokens
    Frontend & DesignAuto-check passed
  • GSAP Core Animation

    greensock/gsap-skills

    Covers the GSAP core API for tweens, easing, staggers, defaults and matchMedia, and when to choose GSAP over CSS animations or other JavaScript animation libraries.

    16k GitHub starsUsed in 4 repos~3.7k tokens
    Frontend & DesignAuto-check passed
  • GSAP in Vue, Nuxt and Svelte

    greensock/gsap-skills

    Shows how to use GSAP in Vue, Nuxt, Svelte and other lifecycle-based frameworks: create after mount, scope selectors to the component, and revert on unmount.

    16k GitHub starsUsed in 4 repos~2.6k tokens
    Frontend & DesignAuto-check passed
  • Vuetify Playground

    vuetifyjs/vuetify

    Maintains the Vuetify repo's local Playground.vue so contributors get a realistic reproduction and a short demo they can paste into a pull request description.

    41k GitHub stars~730 tokensUpdated today
    Frontend & DesignAuto-check passed
  • Boneyard

    0xGF/boneyard

    Use boneyard-js to add, configure, debug, or rebuild skeleton screens.

    7.5k GitHub stars~2.2k tokensUpdated 1 mo ago
    Frontend & DesignAuto-check: notes

More from qf-studio/navigator

All 32 skills in this repo
  • Backend Endpoint

    qf-studio/navigator

    Create REST/GraphQL API endpoint with validation, error handling, and tests.

    354 GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check: notes
  • Nav Start

    qf-studio/navigator

    Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature.

    354 GitHub stars~4.7k tokensUpdated today
    Auto-check: notes
  • Backend Test

    qf-studio/navigator

    Generate backend tests (unit, integration, mocks) for existing code.

    354 GitHub stars~1.5k tokensUpdated today
    Auto-check: notes
  • Database Migration

    qf-studio/navigator

    Create database migration with schema changes and rollback. An agent skill from qf-studio/navigator.

    354 GitHub stars~3.7k tokensUpdated today
    Auto-check: notes
  • Frontend Component

    qf-studio/navigator

    Create React/Vue component with TypeScript, tests, and styles.

    354 GitHub stars~4.5k tokensUpdated today
    Auto-check: notes
  • Nav Compact

    qf-studio/navigator

    Clear conversation context while preserving knowledge via context marker.

    354 GitHub stars~2.1k tokensUpdated today
    Auto-check: notes

Questions about Frontend Test

What does Frontend Test do?

Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components. Frontend Test is an agent skill from qf-studio/navigator. Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components.

When should I use Frontend Test?

Frontend Test fits situations like: says test this component; write component test; add component test.

How do I install Frontend Test in Claude Code?

Run `npx skills add qf-studio/navigator --skill frontend-test -a claude-code`. Or copy the skill folder (skills/frontend-test in qf-studio/navigator) into .claude/skills/frontend-test in your project. Claude Code loads it when a task matches its description.

How do I install Frontend Test in Codex?

Run `npx skills add qf-studio/navigator --skill frontend-test -a codex`. Or copy the skill folder (skills/frontend-test in qf-studio/navigator) into .agents/skills/frontend-test in your project. Codex loads it when a task matches its description.

Can I use Frontend Test in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add qf-studio/navigator --skill frontend-test -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/frontend-test, .gemini/skills/frontend-test, .github/skills/frontend-test and .opencode/skills/frontend-test in your project.

What does Frontend Test need to run?

Going by SKILL.md and its folder, Frontend Test needs the command-line tools its instructions call (python3). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Write, Edit, Grep, Glob, Bash.

Does Frontend Test access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Frontend Test safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Frontend Test use?

Frontend Test is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Frontend Test use?

About 1.6k tokens (SKILL.md is roughly 6.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Frontend Test?

Skills that share tags, products or a category with Frontend Test: Testing Frontend (MadAppGang/claude-code, 284 stars), Tailwindcss Development (anonaddy/anonaddy, 4.9k stars), GSAP Core Animation (greensock/gsap-skills, 16k stars) and GSAP in Vue, Nuxt and Svelte (greensock/gsap-skills, 16k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Frontend Test?

qf-studio (a GitHub organization) maintains it in qf-studio/navigator, which has 354 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on October 7, 2026.

Source: qf-studio/navigator on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.