Testing & QA

Validate built features through a conversational acceptance test

Set up an Android test strategy with unit, UI, screenshot and end-to-end harnesses

Render a component in every state that can reach it and stress test it

Fuzz a local PostgreSQL build to find crashes, then reduce them to minimal reproducers

Find the root cause of any bug or test failure before proposing a fix

Write a failing test first, then the code that makes it pass, for every change

Run the verification command and confirm its output before claiming work is done

Decide whether source and live evidence confirm a new regression or an exclusion

Run AFL++ multi-core fuzzing campaigns on C and C++ with persistent mode and triage

Fuzz Python packages and C extensions with Atheris and libFuzzer harnesses

Set up cargo-fuzz harnesses for Rust projects and reproduce crash artifacts

Measure what a fuzzing campaign reaches with llvm-cov and turn gaps into harness work

Build fuzzing dictionaries of keywords and magic bytes for libFuzzer and AFL++

Patch checksums and magic-value checks that block a fuzzer from making progress

Triage surviving mutants with call graphs to find test gaps and fuzzing targets

Write fuzzing harnesses for C, C++ and Rust that map bytes onto real APIs

Discover possible regressions from a pinned change and its callers before reproducing

Build custom fuzzers with LibAFL's modular observers, mutators and schedulers

Set up libFuzzer coverage-guided fuzzing for C and C++ code built with Clang

Set up mutation testing with mewt or muton and analyze surviving mutants

Enroll an open source project in Google's OSS-Fuzz and reproduce its crash reports

Pin before and after sources and gather PR or commit context for a regression

Write property-based tests with Hypothesis, fast-check, proptest and Echidna

Coordinate a regression campaign across PRs and commits and resume saved progress

Verify a supplied proof-of-concept against fresh before and after deployments

Assemble an evidence-linked regression report from saved campaign decisions

Independently reproduce a named runtime or compiler bug in a local repository

Deploy before and after systems and build a live proof-of-concept for a regression

Fuzz Ruby libraries and C extensions with the Ruzzy coverage-guided fuzzer

Rerun and judge a bug proof-of-concept package before patching it

Generate crypto test vectors that target mutants escaping current test coverage

Test and verify running Native SDK desktop apps with automation and screenshots

Debug Python execution failures by isolating failing functions and verifying output

Fix FileNotFoundError by locating and verifying the real path of a file

Surface real Python tracebacks in PDF generation by running unbuffered with stderr

Debug Python scripts by surfacing errors and checking the working directory

Debug failed Python runs by capturing full tracebacks and the working directory

Debug failed Python scripts by capturing exit codes and checking paths before file work

Diagnose unknown shell command errors with a systematic debugging workflow

Trace a failed GSD auto-mode run to its root cause and file a bug report

Build features test-first with red-green-refactor loops in vertical slices

Audit a website for performance, accessibility, SEO and common quality issues

Check a dev server page loads cleanly with console error and UI element checks

Validate Android app flows in an emulator with adb, screenshots and logcat

Debug Zoom integration issues step by step across SDKs and APIs

Isolate failing Zoom integration calls to find the root cause

Test and debug rendered frontend apps: console errors, interactions, responsive layout

Triage stuck or broken apps through logs, workflow status, browser checks and env

Triage macOS test failures across Xcode and SwiftPM, separating setup from regressions