testforge-skills
TestForge's testing-judgment and engineering-concern skills.
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-structureDecide 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-checkChecks 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-auditRead 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-auditAudit 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-capabilitiesDiagnose 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
doraMeasure 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-agentsRun 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-architectureDesign-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-codeCoding 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-costBudget 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-integrityProtect 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-incidentRun 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-monitoringDesign 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-overloadKeep 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-postmortemWrite 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-releaseMake 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-sloSet 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-testingDecide 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-toilIdentify 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
sreRouter 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-pagesMap 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-proveReview 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-testsGiven 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-platformAudit 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-coverageAfter 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-specsExpand 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-netAfter 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-testTurn 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
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.