Agent skill

Test Suite Prioritizer

by ArabelaTso in ArabelaTso/Skills-4-SE

Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements.

Apache-2.0Auto-check passedTesting & QA

Install Test Suite Prioritizer

skills CLI
$ npx skills add ArabelaTso/Skills-4-SE --skill test-suite-prioritizer -a claude-code

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

GitHub CLI
$ gh skill install ArabelaTso/Skills-4-SE test-suite-prioritizer --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/ArabelaTso/Skills-4-SE.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/test-suite-prioritizer .claude/skills/test-suite-prioritizer && 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
test-suite-prioritizer
GitHub stars
253
Token cost
~3.8k tokens
SKILL.md length
740 words
Files
3 (incl. references)
Skills in repo
170
Repo updated
First seen
Licence
Apache-2.0

At a glance

Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements.

  • Works in 5 steps: Identify Code Changes → Analyze Test Coverage → Calculate Priority Scores → …
  • Optimizing CI/CD pipelines
  • SKILL.md covers Core Capabilities, Test Prioritization Workflow, Time Estimates and Recommendations, plus 6 more sections
  • Calls git, pytest and npm

What it does

Test Suite Prioritizer is an agent skill from ArabelaTso/Skills-4-SE. Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements. Use when optimizing CI/CD pipelines, deciding which tests to run before committing, or selecting critical tests under time constraints. Prioritizes tests by analyzing recently modified files, test dependencies, and coverage overlap. Outputs detailed rankings with priority scores and reasoning to help teams run the most impactful tests first.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/framework_guides.md` and `references/prioritization_algorithms.md`).

It sits in Testing & QA, covering Test generation. It works with pytest. The repository describes itself as: A curated list of 180+ useful Claude Skills for Software Engineering and resources for customizing AI for SE workflows. The licence is Apache-2.0.

When your agent uses it

  • Optimizing CI/CD pipelines
  • Deciding which tests to run before committing
  • Selecting critical tests under time constraints

Example prompts

  • “Use the test-suite-prioritizer skill to analyz test suites and suggests optimal test execution order based on code change impact and project…”
  • “/test-suite-prioritizer”

Requirements

  • Python 3

Workflow steps

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

  1. Identify Code Changes
  2. Analyze Test Coverage
  3. Calculate Priority Scores
  4. Generate Prioritized Test List
  5. Provide Execution Guidance

What it can do on your machine

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

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • pytest
    • npm
    • mvn

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

  • Network

    No URLs in SKILL.md. Its commands use git and npm, which can reach the network depending on how they are called.

    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

Test Suite Prioritizer loads about 3.8k tokens when it runs, and up to ~11k if it reads all its reference files. Until then it costs about 121 tokens; SKILL.md has 740 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~121
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~11k

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 passed

The automated check found no risky patterns in SKILL.md.

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 ArabelaTso/Skills-4-SE at commit 4f38503, republished under its Apache-2.0 licence (© ArabelaTso). 740 words, ~3,782 tokens.

Download SKILL.mdSave it as .claude/skills/test-suite-prioritizer/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
test-suite-prioritizer
description
Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements. Use when optimizing CI/CD pipelines, deciding which tests to run before committing, or selecting critical tests under time constraints. Prioritizes tests by analyzing recently modified files, test dependencies, and coverage overlap. Outputs detailed rankings with priority scores and reasoning to help teams run the most impactful tests first.

Test Suite Prioritizer

Intelligently prioritize test execution based on code changes and project impact.

Core Capabilities

This skill helps optimize test execution by:

  1. Analyzing code changes - Identifying which files were modified
  2. Mapping test coverage - Determining which tests cover changed code
  3. Calculating priority scores - Ranking tests by impact and relevance
  4. Generating execution order - Creating an optimized test run sequence
  5. Providing reasoning - Explaining why each test is prioritized

Test Prioritization Workflow

Step 1: Identify Code Changes

Determine what code has been modified to focus testing efforts.

Sources of Change Information:

  • Git diff (most recent commit or uncommitted changes)
  • Pull request file list
  • Specific files mentioned by user
  • Modified files in working directory

Collect Changed Files:

bash
# Recent commit changes
git diff --name-only HEAD~1 HEAD

# Uncommitted changes
git diff --name-only

# Changes in current branch vs main
git diff --name-only main...HEAD

# Files in last N commits
git diff --name-only HEAD~N HEAD

Example Output:

src/auth/login.py
src/payment/processor.py
src/models/user.py
tests/test_auth.py
Step 2: Analyze Test Coverage

Map which tests cover the changed code.

Strategies:

1. Direct Test-to-Code Mapping

  • Tests in same directory as changed code
  • Tests with similar names (e.g., user.py → test_user.py)
  • Integration tests that import changed modules

2. Static Analysis

  • Parse test files for imports
  • Identify which modules each test uses
  • Map dependencies transitively

3. Coverage Data (if available)

  • Use pytest-cov, coverage.py, JaCoCo output
  • Identify tests that execute changed lines
  • Most accurate but requires prior test run

Example Mapping:

Changed: src/auth/login.py
Covered by:
  - tests/test_auth.py::test_login_success
  - tests/test_auth.py::test_login_failure
  - tests/integration/test_user_flow.py::test_complete_registration
  - tests/e2e/test_authentication_flow.py::test_full_auth_cycle

Changed: src/payment/processor.py
Covered by:
  - tests/test_payment.py::test_process_payment
  - tests/test_payment.py::test_refund
  - tests/integration/test_checkout.py::test_complete_purchase
Step 3: Calculate Priority Scores

Assign priority scores based on change impact.

Scoring Formula:

Priority Score = Base Score × Change Impact Factor

Base Score factors:
- Direct coverage of changed file: +10 points
- Indirect coverage (imports changed file): +5 points
- Integration test covering changed area: +3 points
- Test in same module: +2 points

Change Impact Factor (multiply):
- Critical path code (auth, payments): ×1.5
- Recently failed test: ×1.3
- High historical failure rate: ×1.2
- Core business logic: ×1.2
- UI/cosmetic changes: ×0.8

Example Scoring:

python
# Example: test_login_success
base_score = 10  # Directly tests login.py (changed)
impact_factor = 1.5  # Auth is critical path
priority_score = 10 × 1.5 = 15

# Example: test_user_flow
base_score = 5 + 3  # Imports login.py + integration test
impact_factor = 1.2  # Core business logic
priority_score = 8 × 1.2 = 9.6

# Example: test_ui_styling
base_score = 2  # Same module as changed file
impact_factor = 0.8  # UI/cosmetic
priority_score = 2 × 0.8 = 1.6
Step 4: Generate Prioritized Test List

Create ordered execution sequence with scores and reasoning.

Output Format:

markdown
# Test Execution Priority List

## Summary
- Total tests analyzed: 45
- High priority (score ≥ 10): 8 tests
- Medium priority (score 5-9): 15 tests
- Low priority (score < 5): 22 tests
- Estimated time for high priority tests: ~2 minutes

## Recommended Execution Order

### Priority 1: Critical Tests (Run First)

1. **tests/test_auth.py::test_login_success** (Score: 15.0)
   - Directly tests modified file: src/auth/login.py
   - Critical path: Authentication
   - Reason: Core security functionality changed

2. **tests/test_auth.py::test_login_failure** (Score: 15.0)
   - Directly tests modified file: src/auth/login.py
   - Critical path: Authentication
   - Reason: Error handling for authentication changed

3. **tests/test_payment.py::test_process_payment** (Score: 15.0)
   - Directly tests modified file: src/payment/processor.py
   - Critical path: Payment processing
   - Reason: Payment logic modified, high business impact

### Priority 2: High Impact Tests

4. **tests/integration/test_user_flow.py::test_complete_registration** (Score: 9.6)
   - Indirect coverage: Imports src/auth/login.py
   - Integration test: End-to-end user flow
   - Reason: Validates auth changes in realistic scenario

5. **tests/integration/test_checkout.py::test_complete_purchase** (Score: 9.6)
   - Indirect coverage: Imports src/payment/processor.py
   - Integration test: Full checkout flow
   - Reason: Validates payment changes with real workflow

6. **tests/test_models.py::test_user_model** (Score: 7.0)
   - Related file: src/models/user.py modified
   - Dependency: Auth and payment depend on user model
   - Reason: Foundation for changed functionality

### Priority 3: Supporting Tests

7. **tests/test_validators.py::test_email_validation** (Score: 4.0)
   - Indirect dependency: Used by auth module
   - Reason: Input validation for authentication

8. **tests/e2e/test_authentication_flow.py::test_full_auth_cycle** (Score: 3.9)
   - E2E coverage: Complete authentication flow
   - Reason: Comprehensive validation but slow to execute

[... remaining tests with lower scores ...]

## Quick Commands

Run high priority tests only (8 tests, ~2 min):
```bash
pytest tests/test_auth.py::test_login_success \
       tests/test_auth.py::test_login_failure \
       tests/test_payment.py::test_process_payment \
       tests/integration/test_user_flow.py::test_complete_registration \
       tests/integration/test_checkout.py::test_complete_purchase \
       tests/test_models.py::test_user_model \
       tests/test_validators.py::test_email_validation \
       tests/e2e/test_authentication_flow.py::test_full_auth_cycle

Run critical tests only (3 tests, ~30 sec):

bash
pytest tests/test_auth.py tests/test_payment.py::test_process_payment

Time Estimates

  • Critical tests (3): ~30 seconds
  • High priority tests (8): ~2 minutes
  • All prioritized tests (23): ~5 minutes
  • Full test suite (45): ~15 minutes

Recommendations

  1. Pre-commit: Run critical tests (score ≥ 15) before committing
  2. CI fast lane: Run high priority tests (score ≥ 9) in first stage
  3. Full validation: Run all tests in parallel after merge

### Step 5: Handle Special Cases

Adjust prioritization for specific scenarios.

**Time-Constrained Testing:**

```markdown
## 1-Minute Quick Check (Top 3 Critical Tests)

pytest tests/test_auth.py::test_login_success \
       tests/test_auth.py::test_login_failure \
       tests/test_payment.py::test_process_payment

These cover the most critical changed functionality.

Post-Refactoring:

markdown
## Post-Refactor Validation

Changed file: src/utils/helpers.py (used by 25 modules)

Priority:
1. All tests directly importing helpers.py (18 tests)
2. Integration tests using helper functions (8 tests)
3. Tests in dependent modules (25 tests)

Reason: Wide-reaching refactor requires comprehensive validation.

Flaky Test Handling:

markdown
## Note: Flaky Tests Detected

The following tests have high failure rates but low priority scores:
- tests/test_cache.py::test_concurrent_access (30% failure rate)
- tests/test_api.py::test_rate_limiting (25% failure rate)

Recommendation:
- Fix flaky tests before relying on prioritization
- Consider quarantining or mocking timing-dependent code
Step 6: Provide Execution Guidance

Offer practical commands and strategies.

For CI/CD Pipelines:

yaml
# .github/workflows/ci.yml example
jobs:
  quick-tests:
    name: Critical Tests (Fast Feedback)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run critical tests
        run: |
          # Run tests with score ≥ 15 first
          pytest -v tests/test_auth.py tests/test_payment.py

  full-tests:
    name: Complete Test Suite
    runs-on: ubuntu-latest
    needs: quick-tests  # Only run if critical tests pass
    steps:
      - uses: actions/checkout@v2
      - name: Run all tests
        run: pytest

For Local Development:

bash
# Pre-commit hook (.git/hooks/pre-commit)
#!/bin/bash

# Get changed files
changed_files=$(git diff --cached --name-only)

# Run prioritized tests for changed files
if echo "$changed_files" | grep -q "src/auth/"; then
    pytest tests/test_auth.py || exit 1
fi

if echo "$changed_files" | grep -q "src/payment/"; then
    pytest tests/test_payment.py || exit 1
fi

For Selective Test Execution:

python
# pytest conftest.py - custom marker
import pytest

def pytest_collection_modifyitems(config, items):
    # Mark tests based on priority
    for item in items:
        if "test_auth" in item.nodeid or "test_payment" in item.nodeid:
            item.add_marker(pytest.mark.critical)

# Run only critical tests
# pytest -m critical

Prioritization Strategies

Strategy 1: Code Change Impact (Primary)

Focus on tests covering modified code:

  1. Direct coverage - Tests that explicitly test changed files
  2. Indirect coverage - Tests that import/use changed modules
  3. Dependency coverage - Tests for code that depends on changes

When to use:

  • After code modifications
  • Pre-commit validation
  • Pull request testing
Strategy 2: Risk-Based Prioritization

Prioritize based on business and technical risk:

High Risk Areas:

  • Authentication and authorization
  • Payment processing
  • Data integrity (database operations)
  • Security-critical functions
  • APIs and public interfaces

Medium Risk Areas:

  • Business logic
  • User workflows
  • Data validation
  • Email/notification systems

Low Risk Areas:

  • UI cosmetics
  • Logging
  • Internal utilities
  • Development tools
Strategy 3: Failure History

Prioritize tests that fail often:

python
# Example: Analyze test failure history from CI
# tests with >10% historical failure rate get boosted priority

Historical Failures:
- test_concurrent_access: 12 failures / 100 runs = 12% → Priority boost ×1.2
- test_database_connection: 5 failures / 100 runs = 5% → No boost
Show full SKILL.md (308 more words)Show less
Strategy 4: Execution Time Optimization

Balance coverage with speed:

Fast-First Strategy:

  • Run quick unit tests first (< 1 second each)
  • Get rapid feedback on basic functionality
  • Then run slower integration/E2E tests

Critical-First Strategy:

  • Run most important tests first regardless of speed
  • Better for catching major issues early
  • May take longer for initial feedback

Hybrid Approach (Recommended):

  • Run quick critical tests first (best of both worlds)
  • Then slow critical tests
  • Then fast non-critical tests
  • Finally slow non-critical tests

Analyzing Different Project Types

Python (pytest)

Analyze test structure:

bash
# Find all test files
find . -name "test_*.py" -o -name "*_test.py"

# Get test functions
pytest --collect-only -q

# Analyze imports in tests
grep -r "^import\|^from" tests/
JavaScript/TypeScript (Jest)

Analyze test structure:

bash
# Find test files
find . -name "*.test.js" -o -name "*.spec.js"

# Get test list
npm test -- --listTests

# Analyze coverage
npm test -- --coverage --coverageReporters=json
Java (JUnit)

Analyze test structure:

bash
# Find test classes
find . -name "*Test.java"

# Run with verbose output
mvn test -X

# Get test reports
cat target/surefire-reports/*.xml

Best Practices

  1. Update prioritization regularly - Re-analyze when code structure changes significantly
  2. Combine with coverage tools - Use actual coverage data when available
  3. Consider test stability - Deprioritize flaky tests or fix them first
  4. Balance speed and coverage - Don't sacrifice important slow tests
  5. Communicate reasoning - Explain why tests are prioritized to team
  6. Adjust for context - Pre-commit vs. CI vs. nightly runs need different priorities
  7. Monitor effectiveness - Track if prioritized tests catch bugs earlier
  8. Keep it simple - Start with basic change-impact prioritization
  9. Document critical paths - Maintain list of high-priority areas
  10. Automate where possible - Integrate into CI/CD workflows

Example Scenarios

Scenario 1: Pre-Commit Validation

Context: Developer modified src/auth/login.py

Prioritization:

Top 3 tests to run (30 seconds):
1. tests/test_auth.py::test_login_success
2. tests/test_auth.py::test_login_failure
3. tests/test_auth.py::test_session_creation

Reasoning: Direct tests of changed functionality, fast execution.
Scenario 2: CI/CD Fast Lane

Context: Pull request with 15 files changed across 3 modules

Prioritization:

Stage 1 - Critical Tests (2 min):
- All auth tests (5 tests)
- All payment tests (4 tests)
- Core user model tests (3 tests)

Stage 2 - Integration Tests (5 min):
- User flow integration (8 tests)
- API integration (6 tests)

Stage 3 - Full Suite (parallel, 10 min):
- Remaining tests (120 tests)

Reasoning: Fast feedback on critical paths, comprehensive validation in parallel.
Scenario 3: Time-Constrained Testing

Context: 5 minutes before deadline, need to validate changes

Prioritization:

Must-run tests (2 min):
1. Tests directly covering changed files (8 tests)
2. Integration tests for critical paths (4 tests)

Nice-to-run tests (3 min):
3. Related unit tests (15 tests)

Skip for now:
- E2E tests (too slow)
- Unrelated tests (no impact)

Reasoning: Maximum validation coverage in minimum time.

Resources

  • references/prioritization_algorithms.md - Detailed algorithms and formulas for calculating priority scores
  • references/framework_guides.md - Framework-specific commands for test analysis (pytest, jest, junit, etc.)

Quick Reference

ScenarioPriority StrategyRecommended Tests
Pre-commitCode change impactDirect tests of modified files
CI fast laneCritical path + changesHigh-priority + change-impacted
Time-limitedHighest scores onlyTop 10-20 by priority score
Post-refactorWide coverageAll tests touching refactored code
Nightly buildFull comprehensiveAll tests (no prioritization)

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

Files

SKILL.md and 2 other files (references) in skills/test-suite-prioritizer of ArabelaTso/Skills-4-SE.

  • SKILL.md
  • references/framework_guides.md
  • references/prioritization_algorithms.md

Open the folder on GitHubat commit 4f38503

Compare with similar skills

Test Suite Prioritizer 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.

Test Suite Prioritizer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Test Suite Prioritizer this skillArabelaTso/Skills-4-SE253—~3.8kAutomated safety check: PassApache-2.0
Adk Verify Snippetsgoogle/adk-python22k—~1.4kAutomated safety check: PassApache-2.0
Hermetic Python Unit TestsdimensionalOS/dimos4.6k—~1.4kAutomated safety check: PassCustom licence
Test Coverage Reviewareed1192/finance-news-aggregator149—~2.6kAutomated safety check: PassMIT
Write Test389ds/389-ds-base294—~1.8kAutomated safety check: PassCustom licence
MoAI TDD Workflowmodu-ai/moai-adk1.2k—~3.1kAutomated safety check: PassApache-2.0

Similar skills

  • Adk Verify Snippets

    google/adk-python

    Official

    Checks that every Python code block in a Markdown file actually compiles and runs, by extracting each block to a temporary file, executing it in an isolated subprocess, and writing a pass/fail…

    22k GitHub stars~1.4k tokensUpdated today
    Testing & QAAuto-check passed
  • Hermetic Python Unit Tests

    dimensionalOS/dimos

    Rules for writing, fixing and reviewing pytest unit tests that are hermetic: behavior-focused, deterministic, isolated and cheap to run.

    4.6k GitHub stars~1.4k tokensUpdated today
    Testing & QAAuto-check passed
  • Test Coverage Review

    areed1192/finance-news-aggregator

    Audit, plan, write, and verify unit tests for Python projects using pytest.

    149 GitHub stars~2.6k tokensUpdated 5 mo ago
    Testing & QAAuto-check passed
  • Write Test

    389ds/389-ds-base

    Add or extend a pytest integration test for 389 Directory Server under dirsrvtests/.

    294 GitHub stars~1.8k tokensUpdated yesterday
    Testing & QAAuto-check passed
  • MoAI TDD Workflow

    modu-ai/moai-adk

    Drives test-first development through the RED, GREEN, REFACTOR cycle, with a config switch that selects between TDD and a DDD workflow for existing code.

    1.2k GitHub stars~3.1k tokensUpdated yesterday
    Testing & QAAuto-check passed
  • BiSheng E2E Test Generator

    dataelement/bisheng

    Generates and runs end-to-end tests for BiSheng, pairing pytest API tests with a manual checklist for UI behavior, from a feature spec or a free description.

    12k GitHub stars~1.4k tokensUpdated today
    Testing & QAAuto-check passed

More from ArabelaTso/Skills-4-SE

All 170 skills in this repo
  • Framework Migration Assistant

    ArabelaTso/Skills-4-SE

    Automatically migrate Python web applications between frameworks (Flask → FastAPI, Django → FastAPI).

    253 GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check passed
  • Metamorphic Test Generator

    ArabelaTso/Skills-4-SE

    Generate test cases using metamorphic testing by applying transformations based on metamorphic properties.

    253 GitHub stars~798 tokensUpdated 1 mo ago
    Auto-check passed
  • Reproduction Trace Instrumenter

    ArabelaTso/Skills-4-SE

    Instruments programs to capture execution traces specifically for reproducing reported bugs, enabling consistent replay and diagnosis of failures.

    253 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed
  • Spring Mvc To Boot Migrator

    ArabelaTso/Skills-4-SE

    Automatically migrate Spring MVC applications to Spring Boot.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed
  • State Snapshot Instrumenter

    ArabelaTso/Skills-4-SE

    Instrument programs (Python, C/C++, Java) to capture snapshots of key program states at runtime, including variables, memory, and call stacks.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Test Suite Prioritizer

What does Test Suite Prioritizer do?

Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements. Test Suite Prioritizer is an agent skill from ArabelaTso/Skills-4-SE. Analyzes test suites and suggests optimal test execution order based on code change impact and project requirements.

When should I use Test Suite Prioritizer?

Test Suite Prioritizer fits situations like: optimizing CI/CD pipelines; deciding which tests to run before committing; selecting critical tests under time constraints.

How do I install Test Suite Prioritizer in Claude Code?

Run `npx skills add ArabelaTso/Skills-4-SE --skill test-suite-prioritizer -a claude-code`. Or copy the skill folder (skills/test-suite-prioritizer in ArabelaTso/Skills-4-SE) into .claude/skills/test-suite-prioritizer in your project. Claude Code loads it when a task matches its description.

How do I install Test Suite Prioritizer in Codex?

Run `npx skills add ArabelaTso/Skills-4-SE --skill test-suite-prioritizer -a codex`. Or copy the skill folder (skills/test-suite-prioritizer in ArabelaTso/Skills-4-SE) into .agents/skills/test-suite-prioritizer in your project. Codex loads it when a task matches its description.

Can I use Test Suite Prioritizer 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 ArabelaTso/Skills-4-SE --skill test-suite-prioritizer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/test-suite-prioritizer, .gemini/skills/test-suite-prioritizer, .github/skills/test-suite-prioritizer and .opencode/skills/test-suite-prioritizer in your project.

What does Test Suite Prioritizer need to run?

Going by SKILL.md and its folder, Test Suite Prioritizer needs the command-line tools its instructions call (git, pytest, npm and mvn). Our summary lists: Python 3.

Does Test Suite Prioritizer access the network?

SKILL.md contains no URLs. Its commands use git and npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Test Suite Prioritizer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Test Suite Prioritizer use?

Test Suite Prioritizer is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Test Suite Prioritizer use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 6.9k tokens, read only when the agent opens those files.

What are the alternatives to Test Suite Prioritizer?

Skills that share tags, products or a category with Test Suite Prioritizer: Adk Verify Snippets (google/adk-python, 22k stars), Hermetic Python Unit Tests (dimensionalOS/dimos, 4.6k stars), Test Coverage Review (areed1192/finance-news-aggregator, 149 stars) and Write Test (389ds/389-ds-base, 294 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Test Suite Prioritizer?

ArabelaTso (a GitHub user) maintains it in ArabelaTso/Skills-4-SE, which has 253 GitHub stars. The repository holds 170 skills in this directory. The repository was last updated on August 21, 2026.

Source: ArabelaTso/Skills-4-SE on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.