Agent skill

Error Explanation Generator

by ArabelaTso in ArabelaTso/Skills-4-SE

Explains test failures and provides actionable debugging guidance.

Apache-2.0Auto-check passedTesting & QA

Install Error Explanation Generator

skills CLI
$ npx skills add ArabelaTso/Skills-4-SE --skill error-explanation-generator -a claude-code

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

GitHub CLI
$ gh skill install ArabelaTso/Skills-4-SE error-explanation-generator --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/error-explanation-generator .claude/skills/error-explanation-generator && 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
error-explanation-generator
GitHub stars
253
Token cost
~3.8k tokens
SKILL.md length
836 words
Files
3 (incl. references)
Skills in repo
150
Repo updated
First seen
Licence
Apache-2.0

At a glance

Explains test failures and provides actionable debugging guidance.

  • Works in 5 steps: Gather Error Context → Parse and Categorize the Error → Extract Key Information → …
  • Tests fail (unit
  • SKILL.md covers Core Capabilities, Error Analysis Workflow, Verification and Prevention, plus 12 more sections
  • Calls go, pytest and npm

What it does

Error Explanation Generator is an agent skill from ArabelaTso/Skills-4-SE. Explains test failures and provides actionable debugging guidance. Use when tests fail (unit, integration, E2E), builds fail, or code throws errors. Analyzes error messages, stack traces, and test output to identify root causes and suggest concrete fixes. Handles pytest, jest, junit, mocha, vitest, selenium, cypress, playwright, and other testing frameworks across Python, JavaScript/TypeScript, Java, Go, and other languages.

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/debugging_strategies.md` and `references/error_patterns.md`).

It sits in Testing & QA, covering Unit testing, End-to-end testing and Debugging. It works with Jest, pytest, Cypress and JavaScript. 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

  • Tests fail (unit
  • Code throws errors

Example prompts

  • “Use the error-explanation-generator skill to explain test failures and provides actionable debugging guidance”
  • “/error-explanation-generator”

Requirements

  • Python 3
  • Node.js

Workflow steps

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

  1. Gather Error Context
  2. Parse and Categorize the Error
  3. Extract Key Information
  4. Identify Root Cause
  5. Provide Explanation

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:

    • go
    • pytest
    • npm
    • npx
    • mvn

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

  • Network

    No URLs in SKILL.md. Its commands use npm and npx, 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

Error Explanation Generator loads about 3.8k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 114 tokens; SKILL.md has 836 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~114
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
~10k

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). 836 words, ~3,766 tokens.

Download SKILL.mdSave it as .claude/skills/error-explanation-generator/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
error-explanation-generator
description
Explains test failures and provides actionable debugging guidance. Use when tests fail (unit, integration, E2E), builds fail, or code throws errors. Analyzes error messages, stack traces, and test output to identify root causes and suggest concrete fixes. Handles pytest, jest, junit, mocha, vitest, selenium, cypress, playwright, and other testing frameworks across Python, JavaScript/TypeScript, Java, Go, and other languages.

Error Explanation Generator

Analyze test failures and provide clear explanations with actionable fixes.

Core Capabilities

This skill helps debug failed tests by:

  1. Parsing error messages - Extract key information from test output
  2. Identifying root causes - Determine why tests fail
  3. Explaining clearly - Translate technical errors into understandable language
  4. Providing fixes - Suggest concrete, actionable solutions
  5. Recognizing patterns - Detect common error categories across frameworks

Error Analysis Workflow

Step 1: Gather Error Context

Collect all relevant information:

Essential Information:

  • Complete error message and stack trace
  • Test framework being used (pytest, jest, junit, etc.)
  • Test code that failed
  • Code being tested (if accessible)
  • Programming language

Additional Context (if available):

  • Recent code changes
  • Environment details (OS, language version, dependencies)
  • Test configuration files

How to gather:

bash
# Python pytest
pytest -v --tb=long

# JavaScript/TypeScript jest
npm test -- --verbose

# Java junit
mvn test -X

# Go tests
go test -v
Step 2: Parse and Categorize the Error

Identify the error category using references/error_patterns.md:

Common Categories:

  1. Assertion Failures - Expected vs actual value mismatch
  2. Exceptions/Errors - Runtime errors during test execution
  3. Timeout Errors - Tests taking too long
  4. Setup/Teardown Failures - Fixture or initialization issues
  5. Import/Dependency Errors - Missing modules or broken imports
  6. Type Errors - Type mismatches in typed languages
  7. Mock/Stub Issues - Problems with test doubles
  8. Configuration Errors - Test framework or build config issues
  9. Compilation Errors - Syntax or build failures
  10. Flaky Test Issues - Intermittent failures
Step 3: Extract Key Information

Pull out critical details:

From Error Message:

  • Error type (AssertionError, TypeError, NullPointerException, etc.)
  • Expected vs actual values
  • Error description
  • Line numbers where error occurred

From Stack Trace:

  • Failure point in test code
  • Failure point in source code
  • Call chain leading to error

Example Extraction:

FAILED tests/test_user.py::test_create_user - AssertionError: assert 201 == 200

Extracted:

  • Test file: tests/test_user.py
  • Test name: test_create_user
  • Error type: AssertionError
  • Expected: 200
  • Actual: 201
Step 4: Identify Root Cause

Analyze why the error occurred:

Questions to Ask:

  • What was the test expecting?
  • What actually happened?
  • Why did the actual behavior differ from expected?
  • Is this a test bug or a code bug?

Common Root Causes:

  • Logic error in implementation
  • Incorrect test expectations
  • Missing or wrong test data
  • Race conditions or timing issues
  • Environmental differences
  • Outdated mocks or fixtures
  • Dependency version conflicts
Step 5: Provide Explanation

Structure the explanation clearly:

markdown
## Error Summary

[One-sentence description of what went wrong]

## What Happened

[Explain the error in plain language]

**Expected:** [What the test expected to happen]
**Actual:** [What actually happened]

## Root Cause

[Explain why this happened - the underlying issue]

## How to Fix

### Option 1: [Most likely fix] ⭐

[Specific code change or action to take]

```[language]
// Before
[problematic code]

// After
[fixed code]

Why this works: [Brief explanation]

Option 2: [Alternative fix]

[Another possible solution if Option 1 doesn't apply]

Verification

[How to verify the fix works]

bash
[command to run test]

Prevention

[How to avoid this error in the future]


### Step 6: Suggest Next Steps

Provide actionable guidance:

**If fix is clear:**
- Show exact code change
- Provide test command to verify
- Mention related tests to check

**If diagnosis needs more info:**
- Suggest debugging steps
- Recommend logging/print statements to add
- Propose code to inspect

**If issue is environmental:**
- Suggest dependency checks
- Recommend configuration verification
- Propose environment comparison

## Error Pattern Examples

### Example 1: Assertion Failure (Python/pytest)

**Error Output:**

FAILED tests/test_calculator.py::test_divide - AssertionError: assert 2.5 == 2


**Analysis:**

```markdown
## Error Summary
Test expected integer division but got float division result.

## What Happened

**Expected:** `2` (integer)
**Actual:** `2.5` (float)

The test `test_divide` called a divide function with arguments that produce
a decimal result (e.g., 5 / 2 = 2.5) but expected an integer result.

## Root Cause

The implementation uses true division (`/`) which returns floats in Python 3,
but the test expects integer division behavior.

## How to Fix

### Option 1: Update implementation to use integer division ⭐

```python
# Before
def divide(a, b):
    return a / b

# After
def divide(a, b):
    return a // b  # Integer division

Why this works: The // operator performs floor division, returning integers when both operands are integers.

Option 2: Update test to expect float result
python
# Before
assert divide(5, 2) == 2

# After
assert divide(5, 2) == 2.5

Use this if float division is the intended behavior.

Verification

bash
pytest tests/test_calculator.py::test_divide -v

Prevention

  • Clarify division requirements in function documentation
  • Use type hints: def divide(a: int, b: int) -> int:
  • Add test cases for both integer and float division scenarios

### Example 2: TypeError (JavaScript/Jest)

**Error Output:**

TypeError: Cannot read property 'name' of undefined at getUserName (src/user.js:5:20) at Object.<anonymous> (tests/user.test.js:10:22)


**Analysis:**

```markdown
## Error Summary
Attempted to access property 'name' on undefined user object.

## What Happened

**Expected:** User object with 'name' property
**Actual:** `undefined`

Function `getUserName()` tried to access `.name` property on a value that
was undefined, causing a runtime error.

## Root Cause

The user object passed to `getUserName()` was undefined. This commonly
happens when:
- Function called without argument
- Async data not yet loaded
- Database/API query returned no result

## How to Fix

### Option 1: Add null/undefined check ⭐

```javascript
// Before
function getUserName(user) {
    return user.name;
}

// After
function getUserName(user) {
    if (!user) {
        return null; // or throw error, or return default
    }
    return user.name;
}

Why this works: Defensively handles cases where user might be undefined.

Option 2: Fix the test to provide valid user object
javascript
// Before
const name = getUserName(); // Called without argument

// After
const name = getUserName({ name: 'Alice', id: 1 });
Option 3: Use optional chaining (modern JS)
javascript
function getUserName(user) {
    return user?.name ?? 'Unknown';
}

Verification

bash
npm test -- user.test.js
Show full SKILL.md (352 more words)Show less

Prevention

  • Add input validation to functions
  • Use TypeScript for type safety
  • Define clear function contracts
  • Use optional chaining for property access

### Example 3: Timeout Error (E2E/Cypress)

**Error Output:**

Timed out retrying after 4000ms: Expected to find element: [data-testid="submit-btn"], but never found it.


**Analysis:**

```markdown
## Error Summary
Test couldn't find submit button within timeout period.

## What Happened

**Expected:** Element with `data-testid="submit-btn"` to appear on page
**Actual:** Element never appeared within 4 seconds

## Root Cause

Possible reasons:
1. Element takes longer than 4s to render
2. Element has different selector/ID
3. Element only appears under certain conditions
4. JavaScript error preventing element from rendering

## How to Fix

### Option 1: Increase timeout for slow-loading elements ⭐

```javascript
// Before
cy.get('[data-testid="submit-btn"]').click();

// After
cy.get('[data-testid="submit-btn"]', { timeout: 10000 }).click();
Option 2: Wait for prerequisite conditions
javascript
// Wait for page to fully load first
cy.get('[data-testid="form-container"]').should('be.visible');
cy.get('[data-testid="submit-btn"]').click();
Option 3: Check selector is correct

Inspect the page to verify:

javascript
// Verify element exists with different selector
cy.get('button[type="submit"]').click();

Verification

bash
npx cypress run --spec "cypress/e2e/form.cy.js"

Debugging Steps

  1. Add screenshot on failure:

    javascript
    cy.screenshot('before-submit-btn');
    cy.get('[data-testid="submit-btn"]').click();
  2. Check browser console:

    javascript
    cy.window().then((win) => {
        console.log(win.document.body.innerHTML);
    });
  3. Verify element in browser: Run test in headed mode: npx cypress open

Prevention

  • Use appropriate timeouts for async operations
  • Add explicit waits for dynamic content
  • Verify selectors match actual DOM
  • Test with network throttling to catch timing issues

### Example 4: Mock Issue (Python/pytest)

**Error Output:**

E AssertionError: Expected call: send_email('user@example.com', 'Welcome') E Actual calls: []


**Analysis:**

```markdown
## Error Summary
Mock expected a function call that never happened.

## What Happened

**Expected:** `send_email()` to be called with specific arguments
**Actual:** `send_email()` was never called

## Root Cause

The code being tested didn't call the mocked function. Common reasons:
- Different code path executed (conditional logic)
- Function called with different arguments
- Function called on different object instance
- Mock not properly configured

## How to Fix

### Option 1: Verify code path is reached ⭐

```python
# Add debug assertion to check if code executes
def test_registration_sends_email(mocker):
    mock_send = mocker.patch('app.email.send_email')

    result = register_user('user@example.com')

    # Check if registration succeeded
    assert result.success, "Registration failed, email won't be sent"

    mock_send.assert_called_once_with('user@example.com', 'Welcome')
Option 2: Check mock target path
python
# Ensure you're mocking where it's used, not where it's defined

# Wrong - mocking definition location
mocker.patch('app.email.send_email')

# Right - mocking where it's imported
mocker.patch('app.user.send_email')  # if user.py imports send_email
Option 3: Relax assertion constraints
python
# Instead of exact match
mock_send.assert_called_once_with('user@example.com', 'Welcome')

# Check if called at all
assert mock_send.called, "send_email was never called"

# Check call happened with first argument matching
mock_send.assert_called()
args = mock_send.call_args[0]
assert args[0] == 'user@example.com'

Verification

bash
pytest tests/test_registration.py::test_registration_sends_email -v

Debugging Steps

Print actual calls to see what happened:

python
print(f"Mock called: {mock_send.called}")
print(f"Call count: {mock_send.call_count}")
print(f"Call args: {mock_send.call_args_list}")

Prevention

  • Mock at the point of use, not definition
  • Verify code paths with unit tests first
  • Use assert mock.called before checking arguments
  • Print mock call history when debugging

## Framework-Specific Notes

### Python (pytest, unittest)

**Common error patterns:**
- `AssertionError` - Failed assertions
- `AttributeError` - Missing attributes/methods
- `ImportError/ModuleNotFoundError` - Import issues
- `FixtureNotFoundError` - Missing pytest fixtures

**Key files to check:**
- `pytest.ini`, `setup.cfg` - Configuration
- `conftest.py` - Shared fixtures
- `requirements.txt` - Dependencies

### JavaScript/TypeScript (Jest, Mocha, Vitest)

**Common error patterns:**
- `TypeError` - Type-related errors
- `ReferenceError` - Undefined variables
- `Timeout exceeded` - Async operation timeouts
- `Cannot find module` - Import/require issues

**Key files to check:**
- `jest.config.js`, `vitest.config.js` - Test configuration
- `package.json` - Dependencies and scripts
- `tsconfig.json` - TypeScript settings

### Java (JUnit, TestNG)

**Common error patterns:**
- `AssertionFailedError` - Failed assertions
- `NullPointerException` - Null reference access
- `ClassNotFoundException` - Missing classes
- `ComparisonFailure` - Value comparison failures

**Key files to check:**
- `pom.xml` (Maven) or `build.gradle` (Gradle) - Dependencies
- Test configuration annotations

### Go (testing package)

**Common error patterns:**
- Test panics - Runtime panics
- Comparison failures - Expected vs actual mismatches
- Race conditions - Data race detector failures

**Key commands:**
```bash
go test -v              # Verbose output
go test -race           # Race detection
go test -cover          # Coverage

Quick Reference: Error Categories

CategoryKeywordsCommon Fix
Assertion failureassert, expected, actualFix test expectation or implementation
Null/undefinednull, undefined, NullPointerAdd null checks or fix data flow
Type errorTypeError, type mismatchFix types or add type conversion
Timeouttimeout, exceededIncrease timeout or fix slow code
Import errorModuleNotFound, Cannot findInstall dependency or fix import path
Mock issueassert_called, Expected callFix mock configuration or code path
Async errorPromise, await, asyncProperly handle async operations
Setup failurefixture, beforeEach, setUpFix test initialization

Resources

  • references/error_patterns.md - Comprehensive error pattern catalog with detailed examples for each framework and language
  • references/debugging_strategies.md - Advanced debugging techniques, tools, and systematic approaches for complex failures

Best Practices

  1. Read the full error - Don't skip stack traces
  2. Identify the category - Categorize before diagnosing
  3. Check recent changes - Often related to recent code
  4. Reproduce consistently - Ensure error is reproducible
  5. Isolate the problem - Narrow down to minimal failing case
  6. Verify the fix - Always run tests after fixing
  7. Add regression tests - Prevent same error from recurring
  8. Keep tests simple - Complex tests are harder to debug

© 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/error-explanation-generator of ArabelaTso/Skills-4-SE.

  • SKILL.md
  • references/debugging_strategies.md
  • references/error_patterns.md

Open the folder on GitHubat commit 4f38503

Compare with similar skills

Error Explanation Generator 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.

Error Explanation Generator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Error Explanation Generator this skillArabelaTso/Skills-4-SE253—~3.8kAutomated safety check: PassApache-2.0
Python Testing Patternsjh941213/my-cc-harness12617 repos~5.4kAutomated safety check: PassNone
Playwright Testingchongdashu/vibejam-starter-pack149—~2.1kAutomated safety check: PassNone
Test Specialisttravisjneuman/.claude101—~3.7kAutomated safety check: PassMIT
React Testingaffaan-m/ECC275k1 repos~3.3kAutomated safety check: PassMIT
TDD Guidealirezarezvani/claude-skills28k—~3.4kAutomated safety check: PassMIT

Similar skills

  • Python Testing Patterns

    jh941213/my-cc-harness

    Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development.

    126 GitHub starsUsed in 17 repos~5.4k tokens
    Testing & QAAuto-check passed
  • Playwright Testing

    chongdashu/vibejam-starter-pack

    Plan, implement, and debug frontend tests: unit/integration/E2E/visual/a11y.

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

    travisjneuman/.claude

    Test-writing patterns for JS/TS, Python, Go, and Rust (unit, integration, E2E, visual regression).

    101 GitHub stars~3.7k tokensUpdated 2 days ago
    Testing & QAAuto-check passed
  • React Testing

    affaan-m/ECC

    React component testing with React Testing Library, Vitest/Jest, MSW for network mocking, accessibility assertions with axe, and the decision boundary between component tests and Playwright/Cypress…

    275k GitHub starsUsed in 1 repo~3.3k tokens
    Testing & QAAuto-check passed
  • TDD Guide

    alirezarezvani/claude-skills

    Test-driven development skill for writing unit tests, generating test fixtures and mocks, analyzing coverage gaps, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, Vitest, and…

    28k GitHub stars~3.4k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Claude Code QA

    PramodDutta/qaskills

    The complete QA skill for Claude Code — turn Claude into an expert QA engineer that picks the right test type, writes reliable Playwright, Cypress, and pytest tests, eliminates flaky tests, enforces…

    232 GitHub stars~2.3k tokensUpdated 4 days ago
    Testing & QAAuto-check passed

More from ArabelaTso/Skills-4-SE

All 150 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

Categories

Questions about Error Explanation Generator

What does Error Explanation Generator do?

Explains test failures and provides actionable debugging guidance. Error Explanation Generator is an agent skill from ArabelaTso/Skills-4-SE. Explains test failures and provides actionable debugging guidance.

When should I use Error Explanation Generator?

Error Explanation Generator fits situations like: tests fail (unit; code throws errors.

How do I install Error Explanation Generator in Claude Code?

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

How do I install Error Explanation Generator in Codex?

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

Can I use Error Explanation Generator 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 error-explanation-generator -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/error-explanation-generator, .gemini/skills/error-explanation-generator, .github/skills/error-explanation-generator and .opencode/skills/error-explanation-generator in your project.

What does Error Explanation Generator need to run?

Going by SKILL.md and its folder, Error Explanation Generator needs the command-line tools its instructions call (go, pytest, npm, npx and mvn). Our summary lists: Python 3; Node.js.

Does Error Explanation Generator access the network?

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

Is Error Explanation Generator 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 Error Explanation Generator use?

Error Explanation Generator 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 Error Explanation Generator 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.3k tokens, read only when the agent opens those files.

What are the alternatives to Error Explanation Generator?

Skills that share tags, products or a category with Error Explanation Generator: Python Testing Patterns (jh941213/my-cc-harness, 126 stars), Playwright Testing (chongdashu/vibejam-starter-pack, 149 stars), Test Specialist (travisjneuman/.claude, 101 stars) and React Testing (affaan-m/ECC, 275k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Error Explanation Generator?

ArabelaTso (a GitHub user) maintains it in ArabelaTso/Skills-4-SE, which has 253 GitHub stars. The repository holds 150 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.