Improves code reliability by assisting in the writing and execution of comprehensive test suites across the testing pyramid.

Install

mkdir -p .claude/skills/testing-nguyenhuuca && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13205" && unzip -o skill.zip -d .claude/skills/testing-nguyenhuuca && rm skill.zip

Installs to .claude/skills/testing-nguyenhuuca

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Write effective tests for code quality and reliability. Use when implementing features, fixing bugs, or improving coverage. Covers unit, integration, and E2E testing.
166 chars✓ has a “when” trigger
Intermediate

Key capabilities

  • →Write unit tests for single code units
  • →Create integration tests for component interactions
  • →Develop end-to-end tests for complete user flows
  • →Automate user flows in a real browser using Chrome DevTools
  • →Capture screenshots for visual regression testing
  • →Run Lighthouse for accessibility testing during test runs

How it works

The skill supports creating tests at different levels of the testing pyramid, from isolated unit tests to browser-automated E2E tests using Chrome DevTools.

Inputs & outputs

You give it
Code to be tested or a bug fix requiring a regression test
You get back
Unit, integration, or E2E tests for the provided code

When to use testing

  • →Writing unit tests for new logic
  • →Automating user flow tests
  • →Adding regression tests for bug fixes

About this skill

Testing Software

Verification Loop First

Give every change a check it can run before calling it done: red-then-green for new logic, a failing-then-passing regression test for bug fixes, or the existing suite for anything else. No change ships without one.

Red-green-observe, not red-green-assume: "confirm it fails" (the Regression workflow item below, and TDD's "watch it fail" step) means actually run the test and read the failure output before touching the fix or the implementation — never reason your way to "this must fail" and skip the run.

Falsifiable done-when: before writing a feature's implementation, state one concrete, checkable condition that defines done — not "should work now," a condition a test or command can confirm or refute.

Evidence over narration: a completion claim is only as good as what it cites — a pasted test-run result, a real exit code, a pushed commit SHA. Describing what the code should now do is not evidence; re-running the check and quoting its output is.

MCP Tools

Chrome DevTools (E2E testing):

  • Automate user flows in real browser
  • Capture screenshots for visual regression
  • Run Lighthouse for accessibility testing
  • Profile performance during test runs

Workflow

  • Analyze: Use Glob and Grep to identify untested code
  • Unit Tests: Cover all public functions
  • Edge Cases: Test boundaries and error conditions
  • Integration: Test external dependencies
  • E2E: Use Chrome DevTools for browser automation
  • Regression: Add a test that reproduces the bug, confirm it fails against the current code, then fix — keep it passing and in the suite afterward (never delete or skip it)

Test-Driven Development

When writing new logic, default to red-green-refactor:

  1. Red: Write a failing test for one behavior before writing the implementation.
  2. Green: Write the minimum code needed to make that test pass.
  3. Refactor: Clean up structure only while the suite is green — no new behavior in this step.
  • One behavior per test — if a test needs "and" to describe it, split it.
  • Never write production code without a failing test driving it, except for spikes/throwaway exploration (delete or backfill tests before merging).
  • Don't refactor and add behavior in the same commit; commit on green before switching hats (see code-quality.md Two Hats Rule).

When TDD is the right default: new business logic, bug fixes (write the regression test first, watch it fail, then fix), and any code with clear input/output contracts.

When it isn't: exploratory spikes, throwaway scripts, UI layout/styling tweaks, and generated boilerplate — write tests after the shape stabilizes instead.

Test Quality Standards

Deterministic

Tests must produce the same result every time — no reliance on wall-clock time, random values, or uncontrolled external state.

Isolated

Tests must not depend on each other or share mutable state.

Clear

Test names describe the behavior under test, not just the function name.

When not to use it

  • →When only static analysis or linting is needed
  • →When performance profiling is the sole objective without testing
  • →When the code is not intended for execution

Limitations

  • →It requires Chrome DevTools for E2E browser automation
  • →It focuses on testing and not on code generation
  • →It does not cover all possible testing methodologies

How it compares

This skill provides a structured approach to testing across unit, integration, and E2E levels, including browser automation and visual regression, unlike just running a test runner.

Compared to similar skills

testing side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
testing (this skill)09moReviewIntermediate
python-testing-patterns776moReviewIntermediate
chrome-devtools4110moReviewIntermediate
bats911moReviewIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

python-testing-patterns

wshobson

Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.

77204

chrome-devtools

mrgoonie

Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.

41157

bats

OleksandrKucherenko

Bash Automated Testing System (BATS) for TDD-style testing of shell scripts. Use when: (1) Writing unit or integration tests for Bash scripts, (2) Testing CLI tools or shell functions, (3) Setting up test infrastructure with setup/teardown hooks, (4) Mocking external commands (curl, git, docker), (5) Generating JUnit reports for CI/CD, (6) Debugging test failures or flaky tests, (7) Implementing test-driven development for shell scripts.

991

browser-daemon

noiv

Persistent browser automation via Playwright daemon. Keep a browser window open and send it commands (navigate, execute JS, inspect console). Perfect for interactive debugging, development, and testing web applications. Use when you need to interact with a browser repeatedly without opening/closing it.

587

performance-profiling

davila7

Performance profiling principles. Measurement, analysis, and optimization techniques.

633

obsidian-local-dev-loop

jeremylongshore

Configure Obsidian plugin development with hot-reload and fast iteration. Use when setting up development workflow, configuring test vaults, or establishing a rapid development cycle. Trigger with phrases like "obsidian dev loop", "obsidian hot reload", "obsidian development workflow", "develop obsidian plugin".

328

Search skills

Search the agent skills registry