lobster debugging
A systematic 4-phase debugging framework to find root causes, eliminate flaky tests, and prevent regressions.
Skills for writing unit tests, integration tests, and end-to-end tests. Improve coverage, catch regressions, and automate QA.
📖 Related guide: Best Testing & QA Skills for Claude Code →
133 skills
A systematic 4-phase debugging framework to find root causes, eliminate flaky tests, and prevent regressions.
Build and curate high-quality prompt datasets for fine-tuning and eval — deduped and labeled.
Systematic runtime bug detection and automated patching for Firebase, Next.js, and Vercel stacks.
Turn OpenAPI specs into exhaustive, framework-ready test suites covering happy paths, edge cases, and security gaps.
Bypass OS-native file upload dialogs in browser automation using JavaScript interception and DataTransfer injection.
Automated test generation with edge case analysis and framework-native syntax for TS, Python, Go, and Rust.
SeleniumLibrary is the flakiest part of your Robot Framework suite. This skill swaps it for Browser library, structure intact
Most 'migrations' rewrite your tests from scratch. This one maps your existing keywords and locators automatically.
Diagnoses unreliable tests, identifies root causes, creates stabilization plans, and generates safe AI coding prompts for fixing flaky unit, integration, E2E, and CI tests.
Scored WCAG 2.2 accessibility audits with prioritized, copy-paste fix snippets for any webpage.
Generate realistic JSON or CSV test data from plain-English schema descriptions with up to 1,000 rows.
High-precision test gap analysis that prioritizes untested code by risk and identifies missing edge cases.
Automated risk classification and regression checking to stop AI agents from breaking your codebase.
Designs robust Windows desktop automation workflows using pywinauto, UI Automation, hotkeys, image matching, OCR, retries, logging, screenshots, and safety controls.
A rigorous 5-phase debugging framework to systematically reproduce, isolate, and resolve complex software bugs.
Bypass Cloudflare WAF, reCAPTCHA v3, and Vue.js bot detection in one skill.
Convert plain English into tested regex patterns and explain existing ones across multiple language flavors.
The ultimate pre-commit checklist agent for cleaning code, updating docs, and validating repository state.
Select the smallest honest verification set for a change, including targeted tests, manual checks, missing-test recommendations, a broader fallback, and named remaining risk.
An evidence-first debugging workflow for agents to identify, reproduce, and surgically fix software defects.
Finds accessibility problems in UI code and turns them into prioritized fixes, WCAG-aware checklists, test plans, remediation tickets, and safe AI coding prompts.
Most 'TDD' skips the failing test. This mentor enforces Red before Green, even on legacy code.
Turn vague bug reports into structured reproduction kits, diagnostic plans, and precise AI coding prompts.
Run real Playwright E2E tests on your web app: login, checkout, and form flows across desktop and mobile viewports, with screenshots, traces, and console logs captured on every failure. Catches broken flows and UI regressions before release, and tells you the likely fix, not just that something broke.
Enforce small, verified, and rollback-safe code increments to prevent AI scope creep and broken builds.
Reliable UIA-based Windows desktop automation with OCR and image matching fallbacks.
Generate high-quality Jest unit tests with automatic dependency mocking for JavaScript and Angular applications.
Automated 8-point release audit for project templates, ZIP packages, and developer starter kits.
Deep repository inspection to generate a pragmatic quality risk strategy and interactive HTML dashboard.
Detect, diagnose, and fix intermittent test failures to stabilize your CI pipeline and restore developer trust.
Apply Clean Code and Clean Architecture standards to automate refactoring, reviews, and dependency management.
Generate a personalized before-you-ship checklist for your app, with the things you already have checked off. Pick your app type (web app, SaaS, store, or content) and it builds a tailored list covering security, legal basics (privacy policy, terms, cookie consent), social preview, payments and refunds, accessibility, analytics, and backups, then scans your repo and pre-checks what is already there. Every item says why it matters in plain English.
Automatically detect accessibility issues in websites and applications following WCAG and accessibility standards.
Map the blast radius of a code change before you run the whole suite. For the files and functions you changed, it lists what imports or calls them, which tests cover them, flags any change with no covering test, and warns when a file has a lot of dependents. It tells an agent what its edit might break instead of making it guess. Resolves Python and JavaScript/TypeScript.
A risk-first QA agent that hunts bugs via personas, extracts BDD requirements, and drives TDD fixes.
One-line summary description Stop your agent from claiming "done" before it's proven. A verification gate that classifies each change by risk (payment, auth, database, user-facing), picks the tests that actually cover it, demands evidence, maps regression risk, and outputs an honest pass/fail report. Turns "looks good to me" into "here's what I ran, and here's what's still unverified."
Find the unit tests that pass without testing anything. Flags tests with no assertions, trivial existence-only checks (toBeDefined, assertIsNotNone), tests that assert the exact value they just mocked, snapshot-only tests, tautological assertions (expect(true).toBe(true)), empty placeholders, and over-mocked tests with more setup than assertions. Works on Jest/Vitest and pytest/unittest.
Generate runnable accessibility regression tests, not just a findings report. Detects a11y issues, missing alt text, unlabeled controls, keyboard and focus gaps, in your routes, components, or HTML, then emits Playwright + axe-core spec files with targeted assertions and remediation tickets for each. Previews the tests first and writes them only on your confirmation.
Lint an OpenAPI spec and diff two versions to catch breaking API changes before they reach consumers. Within a spec it flags missing operationId, success responses with no schema, untyped parameters, operations with no security requirement, and unbounded arrays/strings. Across two versions it flags removed paths and operations, removed response codes, a parameter becoming required, narrowed parameter types, removed enum values, and removed response fields. Analyzes JSON specs (convert YAML to JSON first).
Architect, scaffold, and audit enterprise-grade Playwright test suites with professional CI and auth patterns.
Audit your frontend build against a performance budget and catch size regressions before you ship. Flags total bundle over budget, initial bundle over budget, individual chunks over a threshold, oversized image assets, source maps shipped to production, and large unminified JavaScript. Reads a webpack or Vite-style stats.json plus a perf-budget.json you control.
Produces a scored go/no-go pre-launch audit for a WordPress site across code quality, security, accessibility, and SEO. Use when the user says "is this WordPress site ready to launch", "run a pre-launch QA check", "go/no-go audit for my site", "re-audit after fixes", or "launch readiness scorecard". Do not use when only one domain needs auditing — use that domain-specific WP audit skill instead.
Run structural QA on your translation files across locales. Flags missing keys, placeholder mismatches ({name}, %s, {{var}}), strings left untranslated and identical to the source, length-overflow risk that breaks UI, terminology drift against a glossary, empty targets, and plural-category gaps. Works on JSON, gettext .po/.pot, and .properties. It checks form, not meaning, so you do not need to speak the target language to use it.
Detect and analyze flaky tests across multiple frameworks with automated repeated execution and severity reporting.
Produces a verification plan that proves a code change actually works — observable "working" definitions, evidence-over-inference checks, evidence trail. Use when the user says "verify this works", "is it actually done", "prove the fix works", "did the fix actually work", or "definition of done for this change". Do not use before the change is written — use structured-impl-planner instead.
Systematic root cause analysis skill to find and fix the source of bugs, not just the symptoms.
Produces an exhaustive test suite (happy-path, edge-case, negative, contract, security tests) and coverage matrix from an OpenAPI spec, or audits an existing suite for gaps. Use when the user says "generate tests from my OpenAPI spec", "test my API contract", "find gaps in my test suite", or "check contract conformance". Do not use when the user wants the API contract designed, not tested.
Physically installs and launches your APK before the agent declares the build done. Catches broken artifacts every time.
Generate professional pytest suites using behavior-driven matrices, AAA patterns, and resilient fixture architecture.
Produces a QA/UAT pack (acceptance criteria, UAT scripts, edge-case matrix, regression checklist) for an AI automation, or audits an existing one's test coverage. Use when the user says "write UAT for this automation", "QA this AI workflow", "find test coverage gaps", or "build a regression checklist". Do not use when the deliverable is the agent itself, not its test coverage.
Teaches AI coding agents to generate production-quality Playwright end-to-end tests from page analysis, user stories, or existing code. Covers selector strategy, test structure patterns, flakiness prevention, and CI integration — for QA engineers and solo devs tired of AI-generated tests that break on first run.
Makes your coding agent work like a senior developer: exact money, configurable rules, real audit trails, honest testing. Any stack, any country.
⚠️ Attention. This is 1 of 6 skills that cover the entire product build lifecycle. Feel free to download other OptiTech skills to build your production-ready products.
Turns a function, module, or class into a risk-prioritized unit test suite: a test plan, edge cases, idiomatic test code, coverage gaps, and the commands to run it.
Transforms software requirements into planned, implemented, tested, reviewed, and production-ready engineering changes.
Turns model test results, prompts, outputs, benchmarks, scoring notes, evaluation datasets, failure examples, comparison results, and reviewer observations into clear model evaluation reports with findings, recommendations, evidence gaps, deployment considerations, and repeatable evaluation documentation for AI teams.
Audit AI-generated code for hallucinations, security flaws, and architectural drift before you merge.
Converts GitHub issues into repository-aware implementation plans, code changes, tests, and review-ready pull requests.
Diagnose nondeterministic test failures and race conditions with a structured 25-step technical audit.
Standardizes end-to-end customer support workflows from intent identification to verified resolution.
Checks whether a React or Next.js site is ready to launch — scores 8 areas, lists what to fix first, and gives a clear SHIP, FIX-FIRST, or BLOCK decision.
Systematic QA of CLI tools with structured evidence and verdicts.
Detects mismatches between API specifications, code implementations, and client expectations to prevent breaking changes.
Diagnose flaky, timed-out, or CI-only Playwright test failures using traces and logs.
Finds why an app bug is happening using a step-by-step method (reproduce, isolate, test ideas, 5 Whys), then gives a small correct fix and a regression test — without guessing first.
Automates the generation and registry of stable, unique test IDs for UI components and testing suites.
Repair guest-to-account cart merge bugs including duplicate lines, stale prices, coupon leakage, replay races, and checkout state drift.
Orchestrate and verify large-scale, cross-module codebase refactors with automated planning and testing.
Takes software work from coding and debugging through testing, release readiness, deployment verification, and production recovery.
An evidence-based, checklist-driven workflow for auditing and verifying AI-generated code before deployment.
Repair rounding, floating-point, tax, discount, and total mismatches across existing apps.
Review annotation guidelines in files the user supplies or is authorized to share.
Designs Make.com scenario blueprints, module sequences, trigger logic, routers, filters, data mappings, transformations, webhooks, error handlers, retries, fallback paths, testing notes, documentation templates, and build-ready automation briefs for agencies, no-code builders, operations teams, founders, consultants, and small businesses planning reliable workflows before building.
A six-phase independent QA auditor that finds hidden bugs in green test suites and production code.
Cluster and rank CI test failures by root cause to find the one bug breaking your entire build.
Turns repeated business tasks, team processes, client delivery steps, admin routines, content workflows, sales operations, onboarding actions, support tasks, and internal procedures into clear standard operating procedures with step-by-step instructions, checklists, role responsibilities, screenshot placeholders, QA checks, escalation notes, review cycles, and team-ready documentation.
Repair feature-flag lifecycle drift in a repository using Cursor.
Automatically add reliable end-to-end tests to existing applications.
Repair GraphQL nullability drift across schemas, resolvers, loaders, ORM models, generated types, clients, caches, tests, and docs.
Transform vague coding requests into production-ready AI coding prompts with context, constraints, architecture, tests, acceptance criteria, and verification gates.
Scrape pages that block plain requests: impersonate real browsers with curl_cffi, keep a session cookie jar, rotate to Playwright when JavaScript rendering or a
Architect production-ready system prompts, evidence policies, and failure-handling logic for AI agents.
Trace bugs from symptoms to evidence-backed root causes, affected code paths, fixes, and regression tests.
Verify and benchmark DSP audio plugins by identifying harness bugs, measuring real THD, and auditing CPU load.
Align end-to-end request deadlines, retries, cancellation, database work, and side-effect ownership so server work stops when its budget is gone.
Verify AI-generated code against task requirements, evidence, tests, and merge-readiness criteria.
Audit AI agent behavior against definitions using evidence-based scorecards and failure diagnosis.
Map every code, API, database, test, and dependency affected by a feature change before implementation.
Repair lost cancellation signals, orphaned async work, retry-after-cancel bugs, stale completions, and unclear request-vs-durable task lifetimes.
Architect production-ready AI systems with deployable prompts, evidence policies, schemas, and test suites.
Paste your Python code and get a plain-English test report — what works, what doesn't, what's unfinished, and exactly what to do next.
Most quality strategies are generic templates nobody follows. This one is built from your actual repo
Safely capture and inspect test emails in a staging environment without sending to real recipients.
Developers waste time re-explaining their project to AI agents every session.
Produces a strict red-green-refactor TDD workflow — test list, forcing tests, minimal-code-to-pass guidance, edge-case catalogue — for a feature under test. Use when the user says "help me do TDD", "write tests first for this", "what tests should I write", "improve test coverage", or "red green refactor this function". Do not use once code exists and a bug needs finding — use systematic-bug-debugger instead.
Automatically triage test failures, detect cascading root causes, and get prioritized fix suggestions across 10+ languages.
Analyzes your site's layout and UI, interviews you about preferences, then generates AND Playwright-verifies a spotlight onboarding tour — accessible, i18n-ready, colorblind-safe, MIT.
Prevent flaky Windows automation by enforcing robust UI identity, conditional waits, and safety guards.
Produces a hypothesis-driven debugging plan — reproduction steps, symptom-to-layer mapping, ranked hypotheses, minimal failing case — for a reported bug. Use when the user says "debug this", "find the bug", "why is this failing", "reproduce this intermittent bug", or "root cause analysis for this stack trace". Do not use before code exists, when tests come first — use tdd-loop-master instead.
Teaches AI coding agents to build and run automated regression tests for SKILL.md files. When you update a skill that your team depends on, you need to know it still works — not just that it "looks ri
Auto-generate API contract tests from OpenAPI/GraphQL. Detect drift, breaking changes. Mock server + multi-language client gen.
Generate a real test suite for any function, module, or file — meaningful edge cases, error paths, boundary conditions, and proper mocks, not happy-path stubs. Detects your project's framework and conventions, plans the cases deliberately before writing, and hands back runnable tests plus a summary of what's covered. Built to write the tests that actually catch bugs.
Professional performance test planning and k6 script automation aligned with ISTQB standards.
Pre-launch accessibility audit. WCAG 2.2 AA/AAA, ADA/EAA, 70+ checks, axe-core. VPAT/ACR report for procurement.
Turn an error, stack trace, and logs into a structured root-cause diagnosis — reconstructed failure, ranked hypotheses with evidence, the most likely cause, and the cheapest next diagnostic or fix. The disciplined pass a senior engineer runs, instead of scattershot guess-and-check.
Convert a plain-English user flow plus a route/component map into a runnable Playwright, Cypress, or Detox test file wit
Stop guessing and start proving: Force your AI agent to provide verifiable execution logs for every 'done' claim.
Architect and scaffold ISTQB-aligned Gatling performance tests, workload models, and strategic test plans.
Analyze code changes to map dependency blast radius, identify breaking contract changes, and score deployment risk.
Architect ISTQB-aligned performance test plans and production-ready Locust automation suites.