generate-tests — Claude Code skill: what it does, how to install
generate-tests writes tests for a file, module or component, after first detecting the project's framework and conventions.
MIT ★ 328 updated 2026-10-29
npx skills add coco-research/coco --skill generate-tests -a claude-codeWhat generate-tests does
Before any code appears, the skill maps the repo: config files such as jest.config.*, vitest.config.*, pytest.ini, go.mod or Cargo.toml, the existing *.test.* and *.spec.* files, shared helpers, and the test script in package.json. Naming, imports and assertion style get copied from what is already there.
Then it reads the target file: exports, input and return types, outside calls, side effects, thrown errors. The plan splits into unit tests, integration tests and boundary inputs, with mocks on external dependencies only. After writing, it runs the suite and fills the gaps with branch coverage in mind; the targets go from 90%+ for critical logic down to 60%+ for config and glue code.
Step one is not optional. Until the framework and existing conventions are found, no tests get written, so on a repo with no test config you have to say what you actually use.
What it helps with
- add unit tests for the exported functions of a module
- cover error and
catchbranches nobody got around to - raise coverage before a release
- swap real API and database calls for mocks
- bootstrap a first suite in an untested repo
Example prompts for the agent
- Write tests for
src/lib/parseDate.tsand pick up the framework the repo already uses - Cover the error branches in
billing/invoice.ts, including empty and null input - Create a first test suite for the
UserCardcomponent and mock the API calls
How to install generate-tests
1Skills CLI (Vercel)
npx skills add coco-research/coco --skill generate-tests -a claude-code2Manually: put the files in place
~/.claude/skills/generate-tests/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/generate-tests/
1Skills CLI (Vercel)
npx skills add coco-research/coco --skill generate-tests -a codex2Manually: put the files in place
.agents/skills/generate-tests/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add coco-research/coco --skill generate-tests -a cursor2Manually: put the files in place
.cursor/skills/generate-tests/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install coco-research/coco skills/generate-tests2Manually: put the files in place
.github/skills/generate-tests/SKILL.md1Skills CLI (Vercel)
npx skills add coco-research/coco --skill generate-tests -a gemini-cli2Platform CLI
gemini skills install https://github.com/coco-research/coco --path skills/generate-testsManually: put the files in place
.devin/skills/generate-tests/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about generate-tests
How do I install generate-tests in Claude Code?
Run npx skills add coco-research/coco --skill generate-tests -a claude-code. The skill lands at ~/.claude/skills/generate-tests/SKILL.md.
What does generate-tests do?
It inspects the project's test setup, then writes unit, integration and edge-case tests for the file or component you point it at, and runs the suite.
Which test frameworks does it recognise?
Jest, Vitest, Cypress, Playwright, pytest, Go testing and Rust #[cfg(test)]. For components it follows React Testing Library, Vue Test Utils, Angular TestBed and Supertest patterns.
Source text
SKILL.md · MIT
---
name: generate-tests
description: "Use when asked to generate tests for a file, module or component, to raise coverage, or to bootstrap a suite for untested code. Detects the project's test framework and conventions first, then writes unit, integration and edge-case tests."
domain: engineering
supports: [claude-code, cursor, codex, generic]
version: 0.1.0
---
# Generate Tests — Comprehensive Test Suite Generator
Generate complete test coverage for any file, component, or module. Covers unit tests, integration tests, edge cases, error handling, and mocking — adapted to whatever testing framework the project uses.
**Use when**: you want tests generated for a file or component, need to improve test coverage, want edge case coverage, need mocks for external dependencies, or want to bootstrap a test suite for untested code.
---
## When This Skill Is Activated
Follow every step below. Do NOT generate tests without first analyzing the project's testing setup and the target code.
---
## Step 1: Detect the Testing Setup
Before writing any tests, discover the project's testing conventions:
1. **Find the test framework** — Check `package.json` (dependencies/scripts), or config files:
- `jest.config.*` / `jest` key in `package.json` → Jest
- `vitest.config.*` → Vitest
- `cypress.config.*` → Cypress
- `playwright.config.*` → Playwright
- `pytest.ini` / `pyproject.toml` [tool.pytest] → pytest
- `go.mod` → Go testing
- `Cargo.toml` → Rust (#[cfg(test)])
2. **Find existing test files** — Search for `*.test.*`, `*.spec.*`, `test_*.py`, `*_test.go` to understand naming conventions and patterns already in use.
3. **Check for test utilities** — Look for shared helpers, factories, custom matchers, or mock setups the project already provides (e.g., `test/utils.ts`, `__mocks__/`, `conftest.py`).
4. **Check the test script** — Read the `test` script in `package.json` (or equivalent) to understand how tests are run, what flags are used, and what coverage tool is configured.
**Match the project's existing conventions exactly.** File naming, import style, assertion style, describe/it vs test, etc.
---
## Step 2: Analyze the Target Code
Read the file or component the user wants tested. Identify:
- All exported functions, classes, methods, and components
- Input types and return types (or infer them)
- External dependencies (API calls, database, file system, third-party libs)
- Side effects (mutations, network calls, timers, DOM manipulation)
- Error paths (throw statements, catch blocks, error returns)
- Edge cases (null/undefined inputs, empty arrays, boundary values, large inputs)
- Async behavior (promises, callbacks, streams)
---
## Step 3: Plan the Test Suite
Before writing code, outline what you'll test:
### Unit Tests
- Every exported function with representative inputs
- Return values for happy path
- Error handling for invalid inputs
- Boundary values (0, -1, empty string, null, max int, etc.)
- Type coercion edge cases if applicable
### Integration Tests (if the code interacts with other modules)
- Component interactions and data flow
- API calls with mocked responses (success + failure)
- Service layer with mocked dependencies
- State management side effects
### Edge Cases and Error Handling
- Null, undefined, empty inputs
- Malformed data
- Network failures / timeouts
- Concurrent access / race conditions
- Extremely large inputs
---
## Step 4: Write the Tests
Follow these principles:
### Structure
```
describe("[ModuleName]", () => {
describe("[functionName]", () => {
it("should [expected behavior] when [condition]", () => {
// Arrange
// Act
// Assert
});
});
});
```
- **Descriptive test names** — Read like documentation: "should return empty array when input is null"
- **AAA pattern** — Arrange (setup), Act (execute), Assert (verify). Separate each visually.
- **One assertion per concept** — Multiple `expect()` calls are fine if they assert one logical thing
- **Group with `describe`** — One block per function/method/component behavior
- **Setup/teardown** — Use `beforeEach`/`afterEach` for test isolation. Clean up subscriptions, timers, mocks.
### Mocking Strategy
- Mock **external dependencies only** — Don't mock the code under test
- Use the project's existing mock patterns (e.g., `jest.mock()`, `vi.mock()`, `unittest.mock`)
- Create **test data factories** for complex objects instead of inline literals
- Mock timers (`jest.useFakeTimers()` / `vi.useFakeTimers()`) for time-dependent code
- Mock dates for deterministic snapshots
- Always **restore mocks** in `afterEach` to prevent test pollution
### Async Testing
- Always `await` async functions or return the promise
- Test both resolve and reject paths
- Use `waitFor` / `findBy` for async UI updates (React Testing Library)
- Test loading, success, and error states
### Framework-Specific Guidance
| Framework | Component Testing | Key Patterns |
|-----------|------------------|--------------|
| **React** | React Testing Library | `render()`, `screen.getByRole()`, `userEvent`, `waitFor` |
| **Vue** | Vue Test Utils | `mount()`, `shallowMount()`, `wrapper.find()`, `trigger()` |
| **Angular** | TestBed | `TestBed.configureTestingModule()`, `fixture.detectChanges()` |
| **Node.js** | Supertest | `request(app).get("/api/...").expect(200)` |
| **Python** | pytest | `@pytest.fixture`, `monkeypatch`, parametrize |
| **Go** | testing | `t.Run()`, table-driven tests, `t.Parallel()` |
---
## Step 5: Verify and Improve
After generating the tests:
1. **Run the tests** — Execute the test suite to make sure they pass
2. **Check coverage** — Identify untested lines or branches
3. **Add missing cases** — Fill gaps in coverage, especially error paths
4. **Review test quality** — Tests should fail when the code breaks, not just when the tests break
### Coverage Goals
| Priority | Coverage Target |
|----------|----------------|
| Critical business logic | 90%+ |
| Utility functions | 85%+ |
| UI components | 80%+ |
| Configuration/glue code | 60%+ |
Focus on **branch coverage** over line coverage — untested `else` and `catch` paths are where bugs hide.
---
## Output Checklist
Before finishing, verify:
- [ ] Tests follow the project's existing naming convention and file location
- [ ] All exported functions/components have at least one test
- [ ] Happy path tested for every function
- [ ] Error/failure path tested for every function that can fail
- [ ] Edge cases covered (null, empty, boundary values)
- [ ] External dependencies are mocked (no real API calls, no real DB)
- [ ] Async code is properly awaited
- [ ] Mocks are cleaned up in afterEach
- [ ] Tests are independent — can run in any order
- [ ] Test names read like documentation
© coco-research · MIT · coco-research/coco