This skill executes verification scenarios against a known expected behaviour (spec, acceptance criteria, or task description) and produces an evidence-backed verdict. It covers browser UI flows, API verification, and regression checks — always starting from a spec anchor, never from the current implementation.
When to Use
Use this skill when:
Verifying that a new feature works end to end
Confirming a bug fix resolved the reported issue
Running a regression check after any code change
Executing a functional test plan for a feature
Performing a smoke test before or after deployment
Do not use this skill when:
Writing new tests or designing test coverage → use test-driven-development
Isolating a bug's root cause → use debugging-and-error-recovery
Doing a visual/design audit → use browser-testing-with-devtools
Core Process
Step 1 — Establish Expected Behaviour (mandatory)
Before executing anything:
Look for a spec, under the project's external output location (see references/external-output-paths.md) — specs/<feature-slug>/SPEC.md's Success Criteria section — or a legacy in-repo SPEC.md, task description, acceptance criteria, or issue description
If found — list the specific behaviours to confirm (one per scenario)
If not found — stop and ask: "What is the expected behaviour for [X]? I need a reference before I can verify."
Never infer expected behaviour from the current implementation. That makes verification circular — you'd confirm the code matches itself, not that it matches intent.
Step 2 — Plan Scenarios
If a Gherkin test-cases.md already exists for the feature, its scenarios are already concrete verification scenarios — execute those directly rather than re-deriving them from the feature spec. Otherwise, map expected behaviours to concrete verification scenarios:
Don't stop once one scenario type is covered. Checking that all 6 endpoints reject unauthenticated requests is a real result, but it's one type (error handling) — it says nothing about whether the happy path actually works, whether validation rejects bad input, or whether the specific fix/edge case this feature exists for behaves correctly. Every scenario type that genuinely applies to this feature needs at least one concrete check before the verdict is reported — not just whichever type was easiest or fastest to exercise.
Step 3 — Select Transport
Choose the right execution channel for each scenario. For full auth setup and Playwright MCP guidance, see transport-and-auth.md.
Scenario
Transport
UI behaviour, visual correctness
Headless Playwright MCP (default)
API contract, response shape
curl / HTTP tool
Requires an authenticated session (Google/Microsoft/Okta SSO, or any login)
Reuse a saved session or the user's already-signed-in bridge/Chrome first; a one-time interactive login only if neither exists — see Authentication Blocking Live Verification below before falling back to anything else
Every transport here means a real, running instance — not a mocked stand-in. This skill's whole value is proving the feature works against real dependencies (a real server process, a real database, a real authenticated user), not a client double standing in for one. A project's own test suite naming isn't proof of this: a suite called "e2e" can still run fully mocked, or can hit a real server but have an earlier guard/middleware reject the request before the code under test ever runs — verify the request actually reached and exercised the target logic, don't take the suite's name at face value.
Authentication Blocking Live Verification: Try in This Order
Needing to be signed in is the single most common reason live verification stalls — and it's almost always solvable without any human doing manual work, let alone the agent handling a password. Full mechanics in transport-and-auth.md's Session Persistence section; the order itself:
Reuse an existing session first. Check whether the user's connected bridge/Chrome is already signed in as the right account (very often true — it's their daily-driver browser), or whether a saved Playwright storageState already exists for this project from a prior run. Either one means fully automated verification proceeds immediately, no human step at all.
Nothing to reuse? Ask once, via AskUserQuestion, for a one-time interactive login — the user signs in themselves, in whichever surface is active. The agent never sees or types the password. The instant they confirm, persist the session (save storageState, or rely on the bridge profile's own persistence) so this is never asked again for this project.
Never type a real password, and never ask the user for one to type on their behalf — this covers any real identity provider (Microsoft, Google, Okta, corporate SSO), full stop, regardless of how much friction the alternative is. The only credentials an agent types directly belong to the project's own local test account, a different and much narrower case.
Only after both 1 and 2 are genuinely unavailable — a disposable sandbox with no persistent storage, or no human present to click through even one login — does this fall through to the lighter graduated options below. Manual/screenshot verification by the user is the true last resort reached only after this whole chain has been tried, not the default response to any auth friction.
If genuine live verification needs something else not currently available — a live database connection, an API key, access that has nothing to do with the auth chain above — don't silently substitute a mocked check, and don't rigidly block on the heaviest option either. Assembling full live access can genuinely be tedious; when it is, use AskUserQuestion to offer the real tradeoff instead of deciding unilaterally:
Full live verification — real credentials/access, the most complete option, when it's not much friction to set up
A minimal live check via curl/CLI — against the real running dev server (real process, real database) but a narrower surface, e.g. without a fully authenticated session if that's the specific friction point
An automated test that boots/hits the real dev server and database — still genuinely live (real dependencies, not mocked), just run through the test framework rather than a manual browser/API session
All three are live in the sense this skill requires — none of them is a mocked substitute. Let the user pick the tradeoff; don't downgrade to mocks on your own, and don't insist on the full option when a lighter live check would do. If even the lightest live option isn't currently possible, say so explicitly in the report (Step 5) — "not verified live: requires X" is honest; a PASS verdict resting on mocks presented as equivalent is not.
Step 4 — Execute Scenarios
Drive each scenario to completion, against the real instance selected above:
Use role+name locators for browser interactions, not positional refs
Seed test state through the same channel as the test (browser state ≠ API session)
Apply the two-strikes rule: if a step fails twice with the same error, stop and report — do not iterate
Work through scenarios independently. A failure in one scenario stops that scenario, not the run — continue to the next one unless it has an explicit, stated dependency on the one that just failed. A verdict with 2 of 7 scenarios actually exercised, because the first failure halted everything, is far less useful than one with 7 of 7 attempted and the real pass/fail split reported.
Save screenshots and other evidence to one consistently-named location per run, not scattered temp paths that get overwritten pass to pass — e.g. <scratchpad>/quality-assurance/<feature-slug>/<scenario-slug>.png, with filenames specific enough to identify the scenario and step. This is what makes the Evidence column in Step 5's report actually useful after the fact, instead of a reference to a file that's since been overwritten or deleted.
Looking right is not a verdict. Run the scenario against the spec.
"The fix is obvious, I don't need a spec"
Every obvious fix has a different interpretation. Get the spec first.
"I'll try a few things until it works"
Two strikes and stop. Iteration without a baseline is guessing, not verification.
"The tests pass so it works"
Passing tests confirm what tests check — not that the feature works. Execute the scenarios.
"I can infer the expected behaviour from the code"
That makes verification circular. Spec or ask.
"I checked that all the endpoints reject bad requests, that's a solid check"
It's a real check of one scenario type — it says nothing about whether the happy path, validation, or the specific fix under test actually work. Cover every scenario type that applies, not just the one that was fastest to verify.
"The existing test suite is called 'e2e', running it counts as live verification"
A suite's name isn't proof — it can still run against a mocked client, or hit a real server while an earlier guard rejects the request before the code under test ever runs. Confirm the target logic was actually reached and exercised.
"I don't have a real token/test account, I'll just run the mocked unit tests instead and report what I have"
Silently substituting a mocked check misrepresents what was verified. Offer the lighter-but-still-live options (curl/CLI against the real server, or an automated test hitting real dependencies) via AskUserQuestion before falling back to mocks or state plainly that live verification didn't happen.
"Full live verification is too tedious to set up, I'll just skip straight to mocks"
Tedious doesn't mean impossible — a curl/CLI check or an automated test against the real dev server is still genuinely live and usually much less setup than a full authenticated session. Ask which live option to use; don't jump straight to a mocked substitute.
"I need credentials, I'll ask the user to type their password or hand it to me"
Never, for any real identity provider — check for a reusable session first, and if none exists, ask for a one-time interactive login where the user types their own password into their own browser. The agent never sees or handles it.
"The user signed in once, I'll just ask again next run — saving the session is extra work"
That defeats the entire point of the one-time login. Persist the session (storageState, or rely on the bridge's own persistence) immediately after a successful login so this is never asked twice for the same project.
"No saved session exists, I'll just ask the user to verify this manually"
Manual verification by the user is the last resort after session reuse and a one-time interactive login have both been tried — not the second option reached for as soon as auth gets involved.
"This scenario failed, I'll stop here rather than risk a confusing report"
Stopping the whole run over one failure throws away every result after it — run each remaining scenario unless it genuinely depends on the one that failed, and report the real pass/fail split.
"I'll just screenshot to whatever temp path is convenient this run"
A screenshot nobody can find again after the fact isn't evidence, it's a step that happened to produce a file. Use one consistently-named location per run so the report's Evidence column actually points somewhere real.
Red Flags
Producing a PASS verdict without observable evidence
Starting execution before identifying expected behaviour
Skipping regression scenarios because "only one thing changed"
Reporting a verdict having exercised only one scenario type (e.g., only that requests get rejected) when happy-path, validation, or fix-specific scenarios genuinely applied too
A verdict resting on mocked/unit-level tests, or a suite merely labeled "e2e"/"integration", presented as if it were live verification
Missing credentials or test access led to silently running a mocked check instead of offering the lighter live options first
Full live verification assumed to be the only acceptable option, with no AskUserQuestion offering the curl/CLI or real-dev-server-test alternatives when the full setup was genuinely tedious
Using API-seeded state for a browser test (separate sessions)
Retrying a failing step more than twice without stopping to report
Asking the user for their real password, or typing a password into a real (non-local-test) identity provider's login form, under any framing
A successful one-time interactive login that was never persisted (storageState/cookies saved), forcing the same question again on a later run for the same project
Jumping straight to manual/screenshot verification by the user without first trying session reuse (bridge/saved storageState) and a one-time persisted login
One scenario's failure halting the whole run instead of continuing to the remaining independent scenarios
Evidence screenshots/files saved to ad hoc or overwritten paths instead of one consistently-named location per run
A bridge/attached session torn down with a close/kill call instead of detach, closing the user's actual browser window
Verification
Exit criteria — all must be met before marking QA complete:
Expected behaviour source is documented (spec file, issue link, or user confirmation)
Every planned scenario has a recorded result (PASS / FAIL + evidence)
Every scenario type that genuinely applies (happy path, edge cases, error handling, fix confirmation, regression) was actually exercised — not just one type
Verification actually ran against a real, live instance (real server, real database, real authenticated user) — not a mocked client, and not just a suite that happens to be named "e2e"/"integration"
If full live verification was genuinely tedious to set up, graduated live alternatives (curl/CLI against the real dev server, or an automated test hitting real dependencies) were offered via AskUserQuestion rather than downgrading straight to mocks
If no live option was possible at all, that was stated explicitly in the report — never silently substituted with a mocked check reported as if equivalent
If authentication blocked live verification, session reuse (a saved storageState, or an already-signed-in bridge/Chrome session) was tried before anything else
If no reusable session existed, a one-time interactive login was requested via AskUserQuestion and the resulting session was persisted — not left to be re-requested on the next run
No real password for a non-local-test identity provider was ever typed by the agent or requested from the user
Manual/screenshot verification by the user was used only as the genuine last resort, after session reuse and the one-time login were both exhausted
Every independent scenario was attempted even after an earlier one failed, unless it had an explicit, stated dependency
Evidence (screenshots, responses) was saved to one consistently-named location per run, with filenames specific enough to identify the scenario/step
Regression scenarios were run (at least the scenarios most likely affected by the change)
Issues found are categorised by severity with reproduction steps
Overall verdict (PASS / FAIL / PARTIAL) is stated explicitly
1---2name: quality-assurance3description: "Guides agents through feature verification and fix validation — executing test scenarios against a spec, driving a browser or API, and producing a clear PASS/FAIL/PARTIAL verdict. Use when: verifying a feature works, confirming a fix resolved an issue, checking for regressions after changes, running a smoke test, executing a functional test plan, or any task where the goal is to confirm behaviour matches expected rather than to write new tests."4metadata:5 source: https://skillmd.com/skills/ghosteken/quality-assurance6---78# Quality Assurance910## Overview1112This skill executes verification scenarios against a known expected behaviour (spec, acceptance criteria, or task description) and produces an evidence-backed verdict. It covers browser UI flows, API verification, and regression checks — always starting from a spec anchor, never from the current implementation.1314## When to Use1516**Use this skill when:**17- Verifying that a new feature works end to end18- Confirming a bug fix resolved the reported issue19- Running a regression check after any code change20- Executing a functional test plan for a feature21- Performing a smoke test before or after deployment2223**Do not use this skill when:**24- Writing new tests or designing test coverage → use `test-driven-development`25- Isolating a bug's root cause → use `debugging-and-error-recovery`26- Doing a visual/design audit → use `browser-testing-with-devtools`2728## Core Process2930### Step 1 — Establish Expected Behaviour (mandatory)3132Before executing anything:33341. Look for a spec, under the project's external output location (see `references/external-output-paths.md`) — `specs/<feature-slug>/SPEC.md`'s Success Criteria section — or a legacy in-repo `SPEC.md`, task description, acceptance criteria, or issue description352. If found — list the specific behaviours to confirm (one per scenario)363. If not found — **stop and ask**: "What is the expected behaviour for [X]? I need a reference before I can verify."3738> **Never infer expected behaviour from the current implementation.** That makes verification circular — you'd confirm the code matches itself, not that it matches intent.3940### Step 2 — Plan Scenarios4142If a Gherkin `test-cases.md` already exists for the feature, its scenarios are already concrete verification scenarios — execute those directly rather than re-deriving them from the feature spec. Otherwise, map expected behaviours to concrete verification scenarios:4344| Type | What to check |45|---|---|46| Happy path | Core flow with valid inputs → expected output |47| Edge cases | Empty state, boundary values, optional fields absent |48| Error handling | Invalid input, network failure → correct error shown |49| Fix confirmation | Specific issue from bug report no longer occurs |50| Regression | Previously passing behaviour still works |5152**Don't stop once one scenario type is covered.** Checking that all 6 endpoints reject unauthenticated requests is a real result, but it's one type (error handling) — it says nothing about whether the happy path actually works, whether validation rejects bad input, or whether the specific fix/edge case this feature exists for behaves correctly. Every scenario type that genuinely applies to this feature needs at least one concrete check before the verdict is reported — not just whichever type was easiest or fastest to exercise.5354### Step 3 — Select Transport5556Choose the right execution channel for each scenario. For full auth setup and Playwright MCP guidance, see [transport-and-auth.md](references/transport-and-auth.md).5758| Scenario | Transport |59|---|---|60| UI behaviour, visual correctness | Headless Playwright MCP (default) |61| API contract, response shape | curl / HTTP tool |62| Requires an authenticated session (Google/Microsoft/Okta SSO, or any login) | Reuse a saved session or the user's already-signed-in bridge/Chrome first; a one-time interactive login only if neither exists — see **Authentication Blocking Live Verification** below before falling back to anything else |6364**Every transport here means a real, running instance — not a mocked stand-in.** This skill's whole value is proving the feature works against real dependencies (a real server process, a real database, a real authenticated user), not a client double standing in for one. A project's own test suite naming isn't proof of this: a suite called "e2e" can still run fully mocked, or can hit a real server but have an earlier guard/middleware reject the request before the code under test ever runs — verify the request actually reached and exercised the target logic, don't take the suite's name at face value.6566#### Authentication Blocking Live Verification: Try in This Order6768Needing to be signed in is the single most common reason live verification stalls — and it's almost always solvable without any human doing manual work, let alone the agent handling a password. Full mechanics in [transport-and-auth.md](references/transport-and-auth.md)'s Session Persistence section; the order itself:69701. **Reuse an existing session first.** Check whether the user's connected bridge/Chrome is already signed in as the right account (very often true — it's their daily-driver browser), or whether a saved Playwright `storageState` already exists for this project from a prior run. Either one means fully automated verification proceeds immediately, no human step at all.712. **Nothing to reuse? Ask once, via `AskUserQuestion`, for a one-time interactive login** — the user signs in themselves, in whichever surface is active. The agent never sees or types the password. The instant they confirm, persist the session (save `storageState`, or rely on the bridge profile's own persistence) so this is never asked again for this project.723. **Never type a real password, and never ask the user for one to type on their behalf** — this covers any real identity provider (Microsoft, Google, Okta, corporate SSO), full stop, regardless of how much friction the alternative is. The only credentials an agent types directly belong to the project's own local test account, a different and much narrower case.734. **Only after both 1 and 2 are genuinely unavailable** — a disposable sandbox with no persistent storage, or no human present to click through even one login — does this fall through to the lighter graduated options below. Manual/screenshot verification by the user is the true last resort reached only after this whole chain has been tried, not the default response to any auth friction.7475If genuine live verification needs something *else* not currently available — a live database connection, an API key, access that has nothing to do with the auth chain above — don't silently substitute a mocked check, and don't rigidly block on the heaviest option either. Assembling full live access can genuinely be tedious; when it is, use `AskUserQuestion` to offer the real tradeoff instead of deciding unilaterally:7677- **Full live verification** — real credentials/access, the most complete option, when it's not much friction to set up78- **A minimal live check via curl/CLI** — against the real running dev server (real process, real database) but a narrower surface, e.g. without a fully authenticated session if that's the specific friction point79- **An automated test that boots/hits the real dev server and database** — still genuinely live (real dependencies, not mocked), just run through the test framework rather than a manual browser/API session8081All three are live in the sense this skill requires — none of them is a mocked substitute. Let the user pick the tradeoff; don't downgrade to mocks on your own, and don't insist on the full option when a lighter live check would do. If even the lightest live option isn't currently possible, say so explicitly in the report (Step 5) — "not verified live: requires X" is honest; a PASS verdict resting on mocks presented as equivalent is not.8283### Step 4 — Execute Scenarios8485Drive each scenario to completion, against the real instance selected above:86- Use role+name locators for browser interactions, not positional refs87- Seed test state through the same channel as the test (browser state ≠ API session)88- Apply the two-strikes rule: if a step fails twice with the same error, stop and report — do not iterate89- **Work through scenarios independently.** A failure in one scenario stops that scenario, not the run — continue to the next one unless it has an explicit, stated dependency on the one that just failed. A verdict with 2 of 7 scenarios actually exercised, because the first failure halted everything, is far less useful than one with 7 of 7 attempted and the real pass/fail split reported.90- **Save screenshots and other evidence to one consistently-named location per run**, not scattered temp paths that get overwritten pass to pass — e.g. `<scratchpad>/quality-assurance/<feature-slug>/<scenario-slug>.png`, with filenames specific enough to identify the scenario and step. This is what makes the Evidence column in Step 5's report actually useful after the fact, instead of a reference to a file that's since been overwritten or deleted.9192### Step 5 — Produce Verification Report9394```markdown95## Verification Report9697**Feature / Fix:** [Name or issue reference]98**Spec reference:** [Source of expected behaviour]99100### Summary101**Overall verdict:** PASS | FAIL | PARTIAL102103### Scenario Results104105| Scenario | Expected | Observed | Verdict |106|---|---|---|---|107| [Name] | [Spec says] | [What happened] | PASS / FAIL |108109### Issues Found110- **[Critical / High / Medium]** — [Description + evidence]111112### Regressions113- [Any previously passing behaviour that now fails]114115### Evidence116- [Screenshots, response bodies, console output]117```118119## Common Rationalizations120121| Excuse | Reality |122|---|---|123| "I'll just check it looks right" | Looking right is not a verdict. Run the scenario against the spec. |124| "The fix is obvious, I don't need a spec" | Every obvious fix has a different interpretation. Get the spec first. |125| "I'll try a few things until it works" | Two strikes and stop. Iteration without a baseline is guessing, not verification. |126| "The tests pass so it works" | Passing tests confirm what tests check — not that the feature works. Execute the scenarios. |127| "I can infer the expected behaviour from the code" | That makes verification circular. Spec or ask. |128| "I checked that all the endpoints reject bad requests, that's a solid check" | It's a real check of one scenario type — it says nothing about whether the happy path, validation, or the specific fix under test actually work. Cover every scenario type that applies, not just the one that was fastest to verify. |129| "The existing test suite is called 'e2e', running it counts as live verification" | A suite's name isn't proof — it can still run against a mocked client, or hit a real server while an earlier guard rejects the request before the code under test ever runs. Confirm the target logic was actually reached and exercised. |130| "I don't have a real token/test account, I'll just run the mocked unit tests instead and report what I have" | Silently substituting a mocked check misrepresents what was verified. Offer the lighter-but-still-live options (curl/CLI against the real server, or an automated test hitting real dependencies) via `AskUserQuestion` before falling back to mocks or state plainly that live verification didn't happen. |131| "Full live verification is too tedious to set up, I'll just skip straight to mocks" | Tedious doesn't mean impossible — a curl/CLI check or an automated test against the real dev server is still genuinely live and usually much less setup than a full authenticated session. Ask which live option to use; don't jump straight to a mocked substitute. |132| "I need credentials, I'll ask the user to type their password or hand it to me" | Never, for any real identity provider — check for a reusable session first, and if none exists, ask for a one-time *interactive* login where the user types their own password into their own browser. The agent never sees or handles it. |133| "The user signed in once, I'll just ask again next run — saving the session is extra work" | That defeats the entire point of the one-time login. Persist the session (`storageState`, or rely on the bridge's own persistence) immediately after a successful login so this is never asked twice for the same project. |134| "No saved session exists, I'll just ask the user to verify this manually" | Manual verification by the user is the last resort after session reuse *and* a one-time interactive login have both been tried — not the second option reached for as soon as auth gets involved. |135| "This scenario failed, I'll stop here rather than risk a confusing report" | Stopping the whole run over one failure throws away every result after it — run each remaining scenario unless it genuinely depends on the one that failed, and report the real pass/fail split. |136| "I'll just screenshot to whatever temp path is convenient this run" | A screenshot nobody can find again after the fact isn't evidence, it's a step that happened to produce a file. Use one consistently-named location per run so the report's Evidence column actually points somewhere real. |137138## Red Flags139140- Producing a PASS verdict without observable evidence141- Starting execution before identifying expected behaviour142- Skipping regression scenarios because "only one thing changed"143- Reporting a verdict having exercised only one scenario type (e.g., only that requests get rejected) when happy-path, validation, or fix-specific scenarios genuinely applied too144- A verdict resting on mocked/unit-level tests, or a suite merely labeled "e2e"/"integration", presented as if it were live verification145- Missing credentials or test access led to silently running a mocked check instead of offering the lighter live options first146- Full live verification assumed to be the only acceptable option, with no `AskUserQuestion` offering the curl/CLI or real-dev-server-test alternatives when the full setup was genuinely tedious147- Using API-seeded state for a browser test (separate sessions)148- Retrying a failing step more than twice without stopping to report149- Asking the user for their real password, or typing a password into a real (non-local-test) identity provider's login form, under any framing150- A successful one-time interactive login that was never persisted (`storageState`/cookies saved), forcing the same question again on a later run for the same project151- Jumping straight to manual/screenshot verification by the user without first trying session reuse (bridge/saved `storageState`) and a one-time persisted login152- One scenario's failure halting the whole run instead of continuing to the remaining independent scenarios153- Evidence screenshots/files saved to ad hoc or overwritten paths instead of one consistently-named location per run154- A bridge/attached session torn down with a close/kill call instead of detach, closing the user's actual browser window155156## Verification157158Exit criteria — all must be met before marking QA complete:159160- [ ] Expected behaviour source is documented (spec file, issue link, or user confirmation)161- [ ] Every planned scenario has a recorded result (PASS / FAIL + evidence)162- [ ] Every scenario type that genuinely applies (happy path, edge cases, error handling, fix confirmation, regression) was actually exercised — not just one type163- [ ] Verification actually ran against a real, live instance (real server, real database, real authenticated user) — not a mocked client, and not just a suite that happens to be named "e2e"/"integration"164- [ ] If full live verification was genuinely tedious to set up, graduated live alternatives (curl/CLI against the real dev server, or an automated test hitting real dependencies) were offered via `AskUserQuestion` rather than downgrading straight to mocks165- [ ] If no live option was possible at all, that was stated explicitly in the report — never silently substituted with a mocked check reported as if equivalent166- [ ] If authentication blocked live verification, session reuse (a saved `storageState`, or an already-signed-in bridge/Chrome session) was tried before anything else167- [ ] If no reusable session existed, a one-time interactive login was requested via `AskUserQuestion` and the resulting session was persisted — not left to be re-requested on the next run168- [ ] No real password for a non-local-test identity provider was ever typed by the agent or requested from the user169- [ ] Manual/screenshot verification by the user was used only as the genuine last resort, after session reuse and the one-time login were both exhausted170- [ ] Every independent scenario was attempted even after an earlier one failed, unless it had an explicit, stated dependency171- [ ] Evidence (screenshots, responses) was saved to one consistently-named location per run, with filenames specific enough to identify the scenario/step172- [ ] Regression scenarios were run (at least the scenarios most likely affected by the change)173- [ ] Issues found are categorised by severity with reproduction steps174- [ ] Overall verdict (PASS / FAIL / PARTIAL) is stated explicitly
Run npx get-skill add ghosteken/quality-assurance in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
Quality Assurance It is listed under Coding & Dev Tools on SkillMD.
This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. Capability flags: executes scripts, makes network calls, reads secrets. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
Ghosteken (@ghosteken) published this skill. Their other Agent Skills are listed on their SkillMD profile.