claude

testforge-skills

TestForge's testing-judgment and engineering-concern skills.

1 on GitHubby Emilv1.0.0MITupdated 6 days ago
/

Plugin testforge-skills from marketplace testforge-skills-marketplace in emil3663/testforge. Commands read from the repo's manifest — 6 days ago.

What it installs

Skills (28)

  • code-structure

    Decide where new code goes — a new component, hook, page, or module — and whether a file is implementing rather than assembling, before writing it. Not a refactoring skill; it applies while code is being written, the only time the placement decision is still cheap. Use this skill when building a fea

  • observability-check

    Checks whether a feature under test has any way to tell, in production, that it's broken — a log line, a metric, or an error-tracking hook on its failure path. Extends honest-coverage's "what a green run doesn't prove" outward, from the test run to production: not just would this test catch a defect

  • refactor-audit

    Read a codebase, find where structure has drifted, and file each finding as an issue someone can pick up cold — one issue per seam, with the measurement that justifies it. Does not refactor anything; finding and fixing are separate jobs. Pairs with code-structure: that one prevents drift while code

  • reliability-audit

    Audit code that makes external calls — network requests, subprocess calls, queues, polling loops — for missing timeouts, retries without backoff, and unbounded queues: what happens when the dependency is slow or down. Files findings using this repo's issue-template convention. Use this skill when re

  • dora-capabilities

    Diagnose which practices to change when delivery performance is poor. Use when DORA metrics look bad and you need to know what to actually do, when planning engineering improvement work or a platform roadmap, when deciding what to fix first, when adopting AI tooling across a team, or when someone as

  • dora

    Measure software delivery performance with DORA's metrics. Use when asked how fast or how safely a team ships, when setting up engineering metrics or a delivery dashboard, when someone proposes measuring developer productivity, when arguing about whether speed costs stability, or when justifying inv

  • sre-agents

    Run production when some operators are agents. Use when giving an agent access to production or to a destructive tool, when designing agent permissions or escalation, when agents generate a large share of changes, when deciding which work belongs to an agent versus a human, when multiple agents work

  • sre-architecture

    Design-time system structure: failure domains, dependency direction, where state lives, degradation paths, and which problems require consensus. Use when designing a new service or system, reviewing an architecture or design doc, choosing between stateful and stateless approaches, deciding how compo

  • sre-code

    Coding practices that make software operable: intent-based APIs, built-in observability, configuration as specification, prompts as source, minimal surface area, and deleting code. Use when writing or reviewing code or an API, when writing prompts / agent instructions / skill files, when deciding wh

  • sre-cost

    Budget and bound spend the way SLOs budget reliability. Use when a bill is growing or spiked, when setting quotas, rate limits, concurrency caps or timeouts, when autoscaling or an agent loop could run away, when capacity planning for elastic infrastructure, or when deciding what a feature is allowe

  • sre-data-integrity

    Protect data from loss and corruption, and build the stateful pieces correctly. Use when designing backups, retention, deletion or recovery; when asked 'are we backed up?'; after data loss or corruption; when implementing leader election, distributed locking or anything needing consensus; and when b

  • sre-incident

    Run a live incident: triage, structured troubleshooting, and incident command. Use when something is broken right now, when debugging a production outage, when a system is degraded and the cause is unknown, when asked to help with an ongoing incident, or when an investigation has stalled and needs m

  • sre-monitoring

    Design monitoring and alerting that pages a human only when it should. Use when adding metrics, building a dashboard, writing alert rules, debugging alert fatigue or a noisy pager, deciding what to instrument, or reviewing whether an alert is worth keeping. Applies the Four Golden Signals and the sy

  • sre-overload

    Keep a system standing under more load than it can serve, and stop failures from cascading. Use when designing retries, timeouts, rate limits, backpressure, circuit breakers, load balancing or graceful degradation; when a service falls over under load; when a dependency's slowness is spreading; or d

  • sre-postmortem

    Write a blameless postmortem and track outages over time. Use after an incident or outage is resolved, when asked to write an incident report / RCA / retro for a failure, when reviewing someone's postmortem draft, or when deciding whether an incident warrants one. Enforces blameless language, produc

  • sre-release

    Make shipping safe: hermetic builds, progressive rollout, canarying, feature flags, and launch review. Use when setting up CI/CD or a deploy pipeline, planning a launch or a migration, rolling out a risky change, reviewing whether something is ready to ship, or after a bad deploy. Includes the launc

  • sre-slo

    Set reliability targets and run error-budget math. Use when asked how reliable something should be, when defining SLIs/SLOs/SLAs or an availability target, when someone proposes 'five nines' or '100% uptime', when deciding whether it's safe to ship, or when a latency number needs to become a real ta

  • sre-testing

    Decide what to test, how much, and what can only be tested in production. Use when planning a test strategy, arguing about coverage, adding tests to an unfamiliar codebase, designing canary or configuration tests, setting up disaster/chaos testing, or when a bug reached production that tests should

  • sre-toil

    Identify toil, decide what to automate, and keep operational load sustainable. Use when work feels repetitive or manual, when deciding whether to automate something, when on-call is painful or the pager is noisy, when someone is drowning in interrupts and tickets, or when planning what operational w

  • sre

    Router and foundations for the SRE skill family — Google's SRE Book, updated for 2026 and extended to agents. Use when a reliability question spans more than one area, when you don't know which sre-* skill applies, when asking what SRE practice says about something generally, or when deciding how mu

  • crawl-and-classify-pages

    Map a web app page by page — breadth-first, same-origin — and for each page, classify every actionable element and link with testing-semantic judgment (interaction category, expected HTTP status, whether it looks auth-gated, what section it lives in, what kind of embedded resource it is) rather than

  • dont-stub-what-you-prove

    Review a test and check whether the thing being mocked or stubbed is the same thing the assertion claims to verify — flag it when the mock stands between the code and the thing the test exists to prove. Use this skill when reviewing a test file, especially one using a stub, spy, or monkeypatch, befo

  • failure-mode-tests

    Given a plain-English scenario already covered by write-playwright-test, propose and write Playwright tests for the failure and timeout scenarios nobody explicitly asked about — a slow or down dependency, a partial response, a network drop mid-flow. Same output shape as write-playwright-test (a Play

  • find-the-hidden-platform

    Audit a repo for code paths that are structurally unreachable by its own test suite — skipif guards, default-off flags gating real shared state, and monkeypatches that permanently stand in for the thing under test — and report each as a path the suite cannot fail for, naming what's unverified while

  • honest-coverage

    After writing or reviewing a set of tests, state per test or per group what is actually proven and what remains unproven, using a Stable/Moderate/ Blocked rating with the specific reasoning behind each rating — not a generic "tests may not cover everything" disclaimer. Use this skill right after pro

  • plan-to-specs

    Expand a TEST_PLAN.md into a Playwright spec tree, one file per test case, and verify the two stay in step with --check. This is a port of real, tested, unmerged work from cah-pwa's generator-improvements branch (commit 78e30de) — not agent judgment re-deriving parsing logic each run. Use this skill

  • regression-safety-net

    After a fix, separately confirm two different things: that the originally reported failure is actually gone (confirmation testing), and that nothing outside the intended change broke (regression testing). Use this skill after a bug fix or behavior change, before calling the change done, when "the fi

  • write-playwright-test

    Turn a plain-English description of a page or user flow into a clean, idiomatic Playwright TypeScript test file, with judgment about which testing categories (functional, responsive, performance, security, accessibility, usability, SEO/content, cookie/session, database) are actually relevant to the

View source on GitHub

Maintain testforge-skills?

This page updates itself from your repo. Add the badge to your README, or get it Featured to pin it above the organic results with a followed link to your site.

claude & codex pluginslisted