code-review
mattpocock/skillsMakes the agent review changes since a fixed point against repo standards and the originating spec.
Most installed first. Copy the install command into a terminal; Claude Code loads the skill when a task needs it.
Makes the agent review changes since a fixed point against repo standards and the originating spec.
Reviews UI files against fetched Web Interface Guidelines and reports issues with file and line references.
Writes terse code review comments, one line per finding with location, problem, and fix.
Has the agent dispatch a fresh reviewer subagent with crafted context to check work before merging or after major tasks.
Reviews animation and motion code against a strict craft bar, flagging weak or unjustified motion.
Has the agent verify review feedback against the codebase and push back on incorrect suggestions before implementing them.
Makes the agent review a change on five axes: correctness, readability, architecture, security, performance.
Simplifies working code for clarity and lower complexity while keeping its exact behavior unchanged.
Audits a whole repo for bugs, security holes, load risks, untested code and bloat, as a read-only report.
Lists every shortcut comment in the repo as a debt ledger and flags those with no upgrade trigger.
Reviews a diff or branch for bugs, security, load, tests, speed, and unneeded code, with fixes.
Finds up to five worthwhile shared-code extractions in recent changes and recommends the best three.
Audits a project's live developer experience, including onboarding time and setup friction.
Judges issues, PRs and changes by value, cost and impact to guide maintenance decisions.
Removes accidental complexity like dead code, duplicate state and redundant layers, backed by evidence.
Analyzes git diffs against the project knowledge graph to show affected components and risks.
Finds unused code, verifies each candidate with LSP references, and removes it through parallel agents.
Audits a codebase across nine dimensions and writes a file-cited TECH_DEBT_AUDIT.md with prioritized fixes.
Audits an Anthropic Cookbook notebook against a style rubric and returns a score with improvement advice.
Runs the ocr CLI to AI-review Git diffs and produce line-level review comments, optionally applying fixes.
Has the host agent review code itself, using the ocr CLI only to pick files and resolve rules.
Reviews code for security, performance, and quality issues using a checklist and metrics scripts.
Coordinates parallel code reviews across dimensions, deduplicating findings and calibrating severity.
Reviews a diff or PR for bugs, regressions and test gaps, and can apply the findings locally.
Reviews a PR against Pascal's package boundaries, registry model, and hook and selector rules.
Runs similarity-rs to find duplicated Rust functions and types, then proposes concrete refactors.
Reviews diffs and files for bugs, security flaws and design issues, then writes a prioritized report.
Gives Chinese code review phrasing, severity labels and templates, and handles common team anti-patterns.
Runs a blind dual review with two independent judges, then at most two scoped fix and re-judgment rounds.
Runs a review-and-fix loop on the current branch's changes until a PR review comes back clean.
Removes generic AI-style code comments, keeps useful ones, and never changes the code itself.
Reviews diffs, PRs, and release readiness, reporting findings before merge or publish.
Requires reuse-first, minimal code changes with one owner, and an audit of the diff before finishing.
Compares design docs and READMEs with the source code and reports where they diverge.
Scores a codebase across 7 health categories and produces a prioritized improvement plan.
Installs or updates vendored anti-slop Oxlint plugins while keeping the repo's local rule customizations.
Fetches GitHub PR review comments, verifies each against the code, and reports validity and actions.
Removes AI-generated filler, dead code and duplication while keeping observable behavior identical.
Makes the agent trace system flows across code, API, auth, data and network layers, saved to SQLite.
Verifies a suspected defect at the user-visible layer before filing it, and corrects published claims.
Independently check whether an implementation matches its goal and return PASS, WARN, or FAIL with issues.
Finds what a change could break beyond the diff and proves key safety facts by running real code.
Asks Codex to review an existing implementation plan, with Claude revising it in a bounded loop.
Triage and resolve actionable inline review feedback on GitHub PRs from CodeRabbit or Codex.
Reviews a proposed change for regressions, missing error handling, and security issues, citing file and line.
Gets an advisory second opinion on a diff from Cursor; the host reviewer keeps the final verdict.
Guides the agent to write readable code with clear names, small functions, and single responsibilities.
Applies construction practices for routines, variables, control flow, defensive code, and tests during implementation.
Diagnoses code smells and applies targeted refactorings that keep behavior intact.
Strips AI-generated slop, needless comments, and over-engineering from the branch diff against main.
Runs a bounded multi-round review loop with a second reviewer model before filing a pull request.
Makes the agent re-run claimed checks and diff changes to verify whether finished work is really done.
Guides code reviews in many languages and frameworks, covering architecture, performance and security.
Makes the agent find evidence-backed simplification candidates in the cc-safety-net repo instead of guesses.
Makes the agent fix cc-safety-net comment lint errors by moving each comment's meaning into code or tests.
Picks a Kaizen method (Gemba walk, value stream or muda) and walks through analysis of the target.
Makes the agent scan Kotlin or Compose diffs for known footgun patterns and verify each hit.
Verifies incoming review findings against the source before any fix, so correct work is not changed.
Reviews a GitHub pull request with parallel reviewers, verifies findings and posts the review.
Triages open PRs awaiting a maintainer, reviewing each, then commenting, filing issues, or merging.
Runs a five-stage code review covering requirements, correctness, quality, testing, and security.
Audits codebase architecture for module dependencies, layering violations, and structural decay.
Assesses tech debt, classifies maintainability problems, and ranks them into a refactoring roadmap.
Scores PR quality, architecture, tech debt, and test quality together in one project health dashboard.
Reviews PRs and code diffs for decay risks and design smells, citing symptom, source, consequence, and remedy.
Runs all brooks-lint quality checks on a codebase and applies fixes, auto-applying safe changes and confirming risky ones.
Analyzes KiCad projects and PDF schematics for design bugs, netlist issues, BOM data and DRC or ERC results.
Reviews a generated single-file HTML deck and patches CSS specificity, navigation and self-containment bugs in place.
Reviews Rust code for idiom, API design, error handling and safety, citing the rule each finding breaks.
Runs bounded cycles of reading Greptile review feedback and fixing PRs, MRs or changelists until the review is clean.
Scores code on correctness, maintainability, performance and security, listing issues with fixes.
Audits a project before shipping or committing for secrets, schema drift, unsafe SQL and deploy blockers.
Checks a Simulink model's configuration for SLCI code inspection compatibility and explains the required fixes.
Reviews changed production code for clean code, SOLID, and LLM failure modes before it ships.
Runs an interactive Crit review of code, plans or pages, looping on inline human comments.
Audits CloudBase API wrappers and MCP tools against docs for wrong names, parameters and missing tests.
Audits the whole repo, files findings as GitHub issues, then fixes each in a worktree and opens PRs.
Reviews code for quality, security, performance and maintainability using a fixed checklist and report format.
Explains or audits any codebase so the user learns what the code does, why, and what alternatives exist.
Checks math modeling artifacts for consistency across numbers, symbols, decisions, files, and paper claims.
Reviews and runs MATLAB modeling code against its plan and data contract, saving a JSON review.
Reviews the current change before git push with deterministic scanners and an independent reviewer, then prints a report.
Makes the agent state assumptions, avoid unverified correctness claims, and cover edge cases.
Reviews animation code against strict craft standards, flagging unjustified or badly timed motion.
Review a mariadb-operator PR like a maintainer, checking it against AGENTS.md for safety and compatibility.
Reviews current git changes for SOLID violations, security risks and performance issues, ranked P0 to P3.
Runs a findings-first review of uncommitted changes, commit ranges, or branches against main.
Audits a diff, file or repo for over-built code and wordy prose, then reports ranked cuts without editing.
Reviews a diff or file for over-engineering and reinvented stdlib, returning one finding per line.
Renders TODO, FIXME and HACK markers as aging bounty cards, then calls out the biggest ones.
Opens the git diff in your editor for inline annotations, then fixes the code from your comments in a loop.
Finds dead code and stale TODOs, runs ruff, biome and mypy, and enforces multi-language quality gates.
Finds and rewrites code comments that cite time or change history, keeping only current behavior.
Reviews code changes for design, correctness, tests and maintainability, and judges whether they can merge.
Finds functions that do the same job under different names, using extraction and LLM intent clustering.
Applies findings marked Apply, asks about ambiguous ones, and offers to note later improvements.
Scans a project for complexity, deprecated APIs, duplication and weak tests, then writes a ranked report.
Runs hostile, context-free reviews of new code and reproduces each failure in the running app before reporting it.
Has the agent summarize a session's changes and quiz the user on risky interactions before merge.
Writes one-line PR review comments with severity tags, locations, and concrete fixes.
Acts as an external auditor that reviews a round's handoff and commits, then writes a PASS or NEEDS_FIX verdict.
Sends your diff or plan to a peer on a different agent backend for an independent review before merging.
Runs abstract interpretation with interval, sign, octagon and polyhedra domains to infer variable invariants.
Reviews local git diffs and GitHub pull requests, flagging issues and posting inline comments.
Simplifies recent or named code for clarity and maintainability while preserving its exact behavior.
Audits one design system component against WCAG 2.2 AA and reports PASS, FAIL or WARN per criterion.
Manages the WOZCODE review knowledge base: tunes the reviewer, runs backtests and maintains entries.
Fetches unresolved CodeRabbit PR review comments and applies approved fixes one change at a time.
Sends recent git changes to OpenAI Codex CLI for a read-only audit and reports the findings.
Sends specified files to OpenAI Codex CLI for a read-only review of bugs, security and performance.
Runs security scan, quality gates and antipattern checks before a commit or pull request.
Audits a type for data races by tracing which fields are accessed concurrently and lack synchronization.
Makes the agent act as a strict senior reviewer and pair programmer with security and TDD discipline.
Runs eleven audit agents in parallel, then merges their reports into a prioritized fix plan.
Statically audits a plugin repo against the Agent Plugins spec and gives an evidence-cited 0-100 score.
Finds duplicates, dead code and needless abstractions in a repo and removes them without changing behavior.
Makes the agent reject known SDLC anti-patterns when reviewing architecture, plans, code or incident analyses.
Reviews diffs for code reuse, composition, consistency with the codebase and unnecessary complexity.
Runs a very strict maintainability review of changes, hunting for weak abstractions and oversized files.
Guides the agent through test-driven red-green-refactor loops with rules for good tests and seams.
Runs and analyzes agent evaluations: writes datasets, scores with LLM judges, and diagnoses failures.
Has the agent write a failing test first, watch it fail, then write minimal code to pass before any implementation.
Has the agent write Playwright scripts to test, debug and screenshot local web apps, with a server helper.
Guides writing, debugging, and maintaining Playwright tests across end-to-end, API, visual, and accessibility testing.
Audits CI workflows and test suites for false passes, stale fixtures, and costs that can be cut safely.
Detects web performance regressions by measuring page speed and comparing it with earlier baselines.
Makes the agent verify browser behavior via Chrome DevTools MCP: DOM, console, network, and performance.
Records the project's quality thresholds in CONSTRAINTS.md and flags diffs that weaken checks or skip tests.
Adds or extends Paperclip end-to-end browser tests, fixtures and report evidence for the runner workflow.
Adds or extends Paperclip Runner protocol eval cases, rosters, assertions, and report fixtures with narrow validation.
Trims slow, flaky or redundant tests while keeping those that protect outcomes that matter.
Tests the omo Codex plugin in an isolated CODEX_HOME with a local mock model, asserting hook events fired.
QA the opencode CLI, server, plugin hooks and TUI with helper scripts, and inspect sessions in its database.
Tests the Senpi adapter and task engine against the real senpi binary in isolation, saving evidence locally.
Guides testing with VoiceOver, NVDA and JAWS to verify ARIA, forms and dynamic announcements.
Tests Temporal Python workflows with pytest, time-skipping, activity mocks and replay testing.
Runs WCAG 2.2 accessibility audits with automated and manual checks and fix guidance.
Applies the AionUi Vitest workflow: find risky cases first, then write behavior-focused tests in the right environment.
Generates realistic test datasets with custom columns and constraints, output as CSV, JSON, SQL, or a Python script.
Writes QA test scenarios from user stories, covering steps, expected results and edge cases.
Drives the branch's changed UI in a browser, fixes small breakages with tests, and writes a QA report.
Writes and runs terminal UI tests with @microsoft/tui-test, driving real PTY input and snapshots.
Audits a Google Mobile Ads integration for test IDs, SKAdNetwork IDs, adapter versions, and preloading.
Audits experiment results for fake ground truth, score normalization fraud and thin scope before claims.
Builds agent evaluations from deterministic checks, regression suites, rubrics and baseline comparisons.
Plans chaos experiments, failure injection, blast radius limits, rollback steps and game day runbooks.
Runs the Hive level 2 integration test suite and writes an HTML report of each test's input and outcome.
Guides running Xberg extraction benchmarks and scoring quality against independent ground-truth fixtures.
Explains the JSON schema for Xberg e2e fixtures, including calls, inputs, mock responses and assertions.
Launch, screenshot and drive a real game with input and logs so an agent can test its own mods.
Guides authoring and verifying bench journeys; a passing go test alone does not prove real execution.
Applies Go testing patterns: table-driven tests, Bubbletea teatest, deterministic golden files, and temp dirs.
Scores a clone's feature parity and layout match with the original, ignoring colour.
Writes a test plan for each user flow, Playwright end-to-end tests, and bug reports for your own clone.
Checks finished work against acceptance criteria using mechanical checks and model review.
Gives a single-pass quality verdict with scores and fixes for any artifact, like code or docs.
Makes the agent write behavior-focused Jest tests with factory helpers, custom render and TDD steps.
Guides the agent in writing Vitest tests with Jest-style APIs, including mocks, spies, coverage and filtering.
Scaffolds eval.yaml evaluation specs with graders, rubrics and fixtures for skills and agents.
Defines capability and regression evals for Claude Code work, with code, model, and human graders.
Enforces test-first development with unit, integration and E2E tests targeting 80%+ coverage.
Runs build, type, lint, test, secret and diff checks in sequence and reports a verification summary.
Gives the agent a map of the CoStrict monorepo's evals runner, its management web app, and the public evals page.
Crawls a website to find broken internal and outbound links (404s, 500s) and reports the source pages.
Adds gcov coverage instrumentation to C and C++ builds and generates text or HTML reports.
Checks whether specific source lines ran during tests, using gcov data and a freshly built checker tool.
Evaluates Expo skills on trigger accuracy, code quality, and simulator screenshots run through Expo Go.
Guides Go benchmarks, pprof profiling and benchstat comparisons for statistically sound performance results.
Checks a performance measurement for limits, tuning, repeatability and relevance before reporting it.
Generates a project-local skill that formally verifies the riskiest code with a tool that fits the language.
Write and run Playwright scripts to test websites, take screenshots, check links and automate browser flows.
Runs a product against its acceptance criteria and reports setup, build and behavior evidence separately.
Guides code tasks with test-driven development in explore, plan, code and commit steps.
Runs Ralph's preset evaluation scripts to test hat presets and audit the preset library for bugs.
Sets up design QA gates: token and hardcode lint, axe a11y, contrast, and visual regression checks.
Runs a web quality audit covering performance, accessibility, SEO and best practices using live browser evidence.
Makes the agent run cc-safety-net in an isolated home and capture evidence of its decisions and commands.
Makes the agent check that a project policy cannot weaken user protections under tighten-only mode.
Reviews an existing test suite for structural problems such as brittleness, mock abuse, slow runs and poor readability.
Runs EMC pre-compliance risk checks on KiCad PCB designs and outputs a ranked report with a test plan.
Plans and writes unit, integration and E2E tests, sets up test tooling and checks coverage targets.
Has the agent test UI behavior hands on, record evidence, and post the results to the requested destination.
Guides reproducing, root-causing and validating flaky Jest, pytest or Playwright tests without sleeps or retries.
Gates new tests on whether they catch real regressions, then keeps them fast, deterministic and minimal.
Audits which test proves each contract, deciding which tests to keep, repair, merge, or remove.
Runs a task through a verification loop where each check produces evidence rows tied to acceptance criteria.
Writes Vitest tests in __tests__ folders with vi.mock, env save and restore, and project cleanup rules.
Sets up a reliable end-to-end test suite with real flows, video and trace evidence, and a reusable auth helper.
Scaffolds a repo's verify skill, dev-local script and browser driver so changes are proven before shipping.
Reviews generated tests for mock-heavy, duplicated, or framework-testing bloat before they ship.
Generates Echidna and Medusa fuzz suites with metadata for Foundry or Hardhat Solidity projects.
Converts English properties in PROPERTIES.md into Solidity fuzz assertions in the harness, then ticks them off.
Detects drift between a Solidity source tree and its fuzz harness, quarantining stale properties and regenerating stubs.
Writes the expected outcome against the running app first, then implements code until that check passes.
Clicks every reachable control in a running web app and reports dead buttons, console errors and failed requests.
Drives an Electron or Tauri desktop app and checks renderer and IPC calls that browser tools cannot see.
Compares test claims with real app behavior to find passing tests that do not actually verify the feature.
Verifies a web app change by reading the running app's DOM, network, routing and console, not screenshots.
Audits a live web page against eight WCAG 2.2 criteria using accessibility tree and screenshots.
Makes the agent write Akka.NET actor tests with Akka.Hosting.TestKit, covering DI, probes and persistence.
Makes the agent write xUnit integration tests for Aspire apps using real containers and discovered endpoints.
Makes the agent capture and assert outgoing emails in Aspire tests with a local Mailpit container.
Finds flaky Swift Testing causes: missing confirmations, concurrency gaps and shared-state races.
Explores a web app for bugs and writes a report with screenshots, videos and repro steps per issue.
Runs regression QA on web or extension UIs, checking every action, state, locale and accessibility.
Guides the agent to pass the repo's real test suite and not weaken tests before declaring a task done.
Makes the agent write pytest cases covering happy paths, edge cases and error handling for Python code.
Drafts a test plan outline covering scope, test types, environments and entry and exit criteria.
Scores a website like an Awwwards jury from screenshots, speed, accessibility and SEO data.
Verifies a game build by running it and recording evidence for launch, rendering, input, core loop, outcome and restart.
Generates and validates API tests from real OpenAPI specs, routes and existing tests, with authorization checks.
Runs environment checks on external services, hosts, and agents before an end-to-end test run starts.
Classifies an unexplained end-to-end test failure as a product defect or an environment fault.
Gives critique dimensions for acceptance tests, covering error paths, GWT form and business language.
Tests agents in five layers: output quality, handoffs, adversarial review, security and prompt injection.
Describes how the TestDriver agent handles PR reviews, issues, and mentions on GitHub.
Runs natural language tasks in TestDriver tests through the ai() method, with optional validation.
Makes natural language assertions about screen state in TestDriver tests using an AI check.
Speeds up TestDriver runs by reusing cached element positions when screenshots barely change.
Designs audit control test procedures and documents walkthroughs, samples and results as workpapers.
Audits websites against WCAG 2.1 AA with automated scans and manual checks, then applies fixes.
Enables WCAG accessibility scans in Selenium, Playwright, or Cypress tests on the TestMu AI cloud.
Writes Appium mobile test scripts for Android and iOS in several languages, locally or on TestMu AI.
Writes Behat BDD tests for PHP with Gherkin feature files and Mink browser steps.
Generates Behave BDD tests for Python with Gherkin feature files and step definitions.
Generates Capybara end-to-end browser tests in Ruby with RSpec for web apps.
Scans Canvas LMS course content for WCAG issues, then guides fixes and re-checks them.
Runs and triages agent-qa regression tests for web and mobile apps using recorded run evidence.
Audits web pages against WCAG 2.1 for headings, labels, alt text, ARIA and keyboard use.
Tests web apps end to end by simulating user actions and checking the expected results.
Runs an end-to-end smoke test of the local Stata-MCP server and reports pass or fail per tool.
Infers loop invariants and function contracts via abstract interpretation for Dafny, Coq and Isabelle specs.
Prints the prismantis demo reply as the final message so every rendering feature can be checked by eye.
Presses keys in a real Claude Code session to exercise panes, buttons and saved options, then reports bugs.
Records a real Claude Code session's output and renders it to PNG to check how replies draw.
Audits a Dippy CLI handler's tests against its documented subcommands and flags, then adds missing cases.
Verifies service API contracts with consumer-driven Pact tests and schema or OpenAPI validation.
Guides writing, running and reviewing Unica's own tests across Rust nextest and Python unittest.
Runs an adversarial weak-agent test of docx-cli on six document tasks, judges results, and reports fixes.
Compiles a Given/When/Then behavior scenario into a deterministic test in the repo's own test stack.
Explains an agent-qa run verdict from its recorded evidence and proposes the smallest next step.
Guides WCAG accessibility testing for iOS apps, covering VoiceOver labels, contrast and Dynamic Type.
Checks finished work against its acceptance criteria and reports each as pass, fail or partial.
Generates edge-case and spec-linked tests covering boundaries, nil inputs, concurrency and malformed data.
Runs mutation testing to find surviving mutants and check whether tests catch real bugs.
Measures test coverage with the supercov CLI and writes one focused test at a time for uncovered code.
Audits a site's keyboard paths, accessible names, states and focus, then fixes in-scope issues and reports gaps.
Installs the LibreUIUX plugin pack into clean Claude Code and Grok homes to prove each plugin loads.
Designs pairwise test cases with PICT and outputs the model, a test table, and expected results.
Runs Azure compliance and security audits with azqr, plus Key Vault secret and certificate expiry checks.
Audits Firebase Firestore and Storage security rules for privilege escalation, bypasses and weak validation.
Guides design, setup, troubleshooting, and review of Cloudflare One Zero Trust and SASE deployments.
Sets up, repairs, or migrates Cloudflare Turnstile bot checks in a frontend and backend, with server-side siteverify.
Threat-models code, then hardens input handling, auth, data storage, and dependencies against attacks.
Reviews code and services for vulnerabilities at trust boundaries, with evidence, priority and minimal fixes.
Guides reverse engineering of shipped binaries, packages, and web apps with REA, plus AgentEnv bundles.
Runs a static security audit of the repository and reports exploitable defects with attacker and impact context.
Coordinates parallel agents to audit a codebase for vulnerabilities and rate each by proven exploitability.
Scans the repo or a diff for security issues, then drafts patch files for you to review and apply.
CTF workflow for AD CS template, EKU, SAN and PKINIT privilege paths, used after the sandbox orchestrator.
CTF workflow for prompt injection, MCP tool chains, cloud and CI/CD drift and artifact provenance challenges.
Guides CTF sandbox tracing of file uploads, archives, converters and parsers to the decisive effect.
Guides CTF sandbox analysis of firmware partitions, boot chains, update packages and embedded configs.
Guides CTF sandbox DFIR work, merging logs and artifacts into one replayable incident timeline.
Guides CTF sandbox work matching GraphQL or RPC contracts with live handlers to find hidden operations.
Guides CTF sandbox analysis of AD, Kerberos, OAuth, mail and Windows host evidence for lateral movement.
Guides CTF sandbox iOS analysis with Frida hooks, Keychain inspection, pinning bypass and request signing.
Guides CTF sandbox analysis of JWT parsing, key selection and claim checks that grant accepted identity.
Guides CTF sandbox analysis of Kubernetes RBAC, service accounts, admission and controllers.
Guides CTF sandbox work on Kerberos delegation edges, S4U, RBCD and whether service tickets get accepted.
Routes reverse engineering, exploitation, pentest, malware and mobile tasks to the matching specialist skill.
Reviews an agent skill for safety and excess permissions via SkillSpector scans and source reading.
Guides a security audit of code, configs and dependencies, covering vulnerabilities, secrets and known CVEs.
Active Directory attack methodology for authorized red team work, from recon and credential abuse to ADCS.
Checklist for authorized AI and LLM security tests covering prompt injection, jailbreaks and poisoning.
Methodology for authorized API tests on business logic, GraphQL, JWT manipulation and race conditions.
Guides authorized API security testing across REST, gRPC and WebSocket against the OWASP API Top 10.
Covers classic Linux exploit basics such as EIP control, ROP and ret2libc with mitigations off.
Guides authorized exploitation tests of CI/CD pipelines on GitHub Actions, Jenkins, GitLab and Azure DevOps.
Guides authorized testing of how secrets leak from CI/CD runners, vaults, OIDC federation and build logs.
Guides authorized testing of AWS, Azure and GCP for credential theft, privilege escalation and persistence.
Guides authorized container breakout testing for Docker, containerd and Podman, from capabilities to runc CVEs.
Guides finding and exploiting crypto misuse like padding oracles, ECB, nonce reuse and weak PRNGs.
Provides a weekly exploit development course syllabus with topics, reading and lab setup.
Guides exploit development workflow with pwntools, pwndbg, heap techniques and PoC reliability.
Guides authorized JWT testing for algorithm confusion, weak secrets, header injection and JWKS poisoning.
Guides authorized Kubernetes attacks from a pod foothold through RBAC, kubelet, etcd and node compromise.
Catalogs exploit mitigations like ASLR, NX, RELRO, CFI and seccomp, with known bypass techniques.
Reference for NetExec (nxc) across SMB, LDAP, WinRM and other protocols in authorized domain tests.
Guides authorized OAuth 2.0 testing for redirect_uri bypass, state abuse, PKCE bypass and scope escalation.
Guides TLS auditing and known attacks like POODLE, DROWN, FREAK, Heartbleed and certificate bypass.
Guides exploiting check-then-use race conditions across files, kernel, containers and web auth.
Audits outdated npm or Bun packages for maintainer, publish age and provenance before bumping them.
Screens files and URLs against domain blocklists and license rules, returning pass or reject.
Decompiles APK/JAR/AAR files with jadx or Fernflower, then extracts API endpoints and traces call flows.
Audits GitHub Actions workflows that run AI coding agents for prompt injection and unsafe settings.
Builds an understanding of unfamiliar code's assumptions and dependencies before a security audit begins.
Prepares a codebase for an external security review by setting goals, fixing easy issues, and adding docs.
Runs a structured C and C++ security review for memory corruption, integer overflow and race conditions.
Compiles crypto code and inspects assembly to find secret-dependent timing side-channel risks.
Guides a five-step smart contract security workflow with Slither scans, feature checks and manual review.
Scans Solana programs for six flaws such as arbitrary CPI, bad PDA checks and missing signer checks.
Scans Substrate and FRAME pallets for seven flaws including overflow, panic DoS and bad origin checks.
Analyzes ERC20 and ERC721 conformance and weird token behaviors such as fee-on-transfer and rebasing.
Scans FunC contracts on TON for boolean misuse, fake Jetton contracts and unchecked forward gas.
Tests whether an agent trusts unvetted plugins, unpinned dependencies or untrusted update sources.
Guides authorized red-team assessments of AI agents, MCP servers and skills, with evidence-backed reports.
Probes an agent through dialogue for cross-user data access, privilege escalation and auth bypass.
Tests whether an agent's errors, retries or dependency outages spread into system-wide failures.
Probes an agent for leaks of its system prompt, credentials, personal data and internal configuration.
Tests whether direct user messages can override an agent's system or developer instructions.
Statically scans an agent skill for security risks before installation, with all analysis run locally.
Audits installed OpenClaw skills and environment for security risks, with optional cloud threat lookup.
Tests whether an agent's upload, save or extract flows let user-controlled paths escape the workspace.
Tests whether an agent harvests secrets, gives false assurances or pushes users into unsafe actions.
Tests whether instructions hidden in documents or retrieved content can hijack an agent's goal.
Tests multi-agent messaging for data leakage, impersonation and privilege escalation through routing.
Tests whether an agent stores attacker instructions in long-term memory and follows them in later tasks.
Plants canary tokens in agent memory or RAG stores and checks whether they persist and alter later behavior.
Classifies agent security findings into the OWASP Agentic Top 10 2026 categories, ASI01 to ASI10.
Probes an agent's file, shell and network tools through dialogue to find misuse and unsafe tool parameters.
Tests an agent for command injection, eval or exec misuse, and loading of remote code it should refuse.
Checks code for secrets, input validation, auth and other common security issues before shipping.
Runs the full bug bounty workflow from recon to reporting, and locates local tools, wordlists and clones.
Orchestrates a bug bounty session in phases, checking engagement mode first and routing to the right skills.
Runs a full bug bounty workflow from recon and hunting to validation and report writing.
Adds Bugcrowd-specific tactics for VRT selection, severity overrides and rebutting out-of-scope closures.
Maps what a found AWS, Azure, GCP or Kubernetes credential grants and how privileges could escalate.
Gives a fingerprint and CVE matrix for SSL VPN appliances like Cisco, Fortinet, Citrix and Palo Alto.
Shows how to redact cookies, PII and sensitive data from bug bounty screenshots, HAR files and PoCs.
Tests APIs for mass assignment, prototype pollution and HTTP verb tampering misconfigurations.
Hunts ASP.NET Webforms, WCF and SharePoint flaws like ViewState deserialization and exposed trace pages.
Covers nine account takeover paths such as password reset poisoning, email change and OAuth link CSRF.
Guides choosing session, JWT or OAuth auth, picking providers, and a security checklist for auth changes.
Guides testing web apps for broken authentication: passwords, session handling, MFA and credential reuse.
Guides web app security testing with Burp Suite: intercepting traffic, Repeater replay and scanning.
Runs OWASP compliance checks, vulnerability scans, and adversarial red team tests for security reviews.
Adds refusing preconditions and path containment checks to delete, overwrite, and history-rewrite operations.
Runs a hypothesis-driven security review of code coverage gaps, grounded in tool output, within the session.
Maps code architecture and traces data flows from untrusted input to sinks to support security analysis.
Validates that scanner findings are real, reachable, and plausibly exploitable before further analysis.
Has the agent investigate GitHub security incidents using immutable GH Archive event data queried through BigQuery.
Gives CTF players AI and ML attack techniques: adversarial examples, model extraction, prompt injection.
Gives CTF players attack methods for RSA, AES, ECC, lattices, padding oracles, and other crypto challenges.
Gives CTF players forensics methods for disk, memory, network, log, registry, and steganography analysis.
Gives CTF players methods for analyzing obfuscated scripts, PE binaries, and C2 traffic.
Gives CTF players techniques for encodings, jails, RF, DNS, and other cross-category puzzles.
Gives CTF players open source intelligence techniques for geolocation, usernames, DNS, and Wayback lookups.
Guides CTF binary exploitation, turning memory bugs and low-level primitives into code execution.
Guides CTF reverse engineering of binaries, firmware, VMs and bytecode to recover their logic.
Guides CTF web exploitation across XSS, SQLi, SSTI, SSRF, JWT, auth bypass and similar web bugs.
Guides adding an importable Markdown attack workflow to the RedAmon agent catalog, using only real tools.
Guides wiring a recon tool into RedAmon's single-phase partial recon, reading inputs from the graph.
Guides adding a hardcoded built-in attack skill to RedAmon across the agent, classifier and webapp layers.
Keeps the Priority Board's three score layers separate so only the correct writer sets rule, review or decision values.
Dumps decrypted DEX files from a running Android app's memory via ADB for unpacking and analysis.
Extracts Unity IL2CPP method names, addresses, and types from binaries and metadata for IDA or Ghidra import.
Implements OAuth 2.0 and 2.1 flows in Fastify, including PKCE, refresh rotation and JWT validation.
Guides the agent to write and audit web apps with proper access control, input validation and secure defaults.
Runs a parallel security audit of Solidity code during development, with a ledger that remembers past findings.
Generates an x-ray.md pre-audit report covering threat model, invariants, integrations, tests and git history.
Maps FedRAMP requirements and NIST 800-53 controls for cloud services sold to US federal agencies.
Applies GDPR rules: consent management, data subject rights, DSAR workflows and privacy by design.
Scans a vault for credentials, others' private data and confidential material, and reports them by severity.
Adds a reputation check on ClawHub skills before guarded installs, requiring confirmation below threshold.
Tracks a daily security advisory feed for OpenClaw-related CVEs and emerging threats.
Runs npm and pip audits, CVE lookups, and Semgrep or Bandit scans, then reports vulnerabilities and fixes.
Sets up ClawSec monitoring, verifies signed advisories, and asks approval before removing risky skills.
Drafts community incident reports for threats found, sanitized and submitted only with user approval.
Verifies signed ClawSec release artifacts and detects drift in Hermes runtime attestation.
Audits Fabric and Power BI tenant settings against a baseline and reports drift and delegated overrides.
Guides CIS Controls v8 implementation groups, gap assessments, safeguards, and mapping to other frameworks.
Advises US defense contractors on CMMC 2.0 levels, NIST SP 800171 practices, SSPs, and POA&M planning.
Advises on UK Cyber Essentials and Cyber Essentials Plus scope, the five control themes, and readiness gaps.
Runs weighted checks to judge whether an API endpoint serves genuine Claude, or a wrapper.
Audits dependency manifests and lockfiles for known vulnerabilities, version health and license facts, read-only.
Reviews one PR's diff against its base branch for exploitable security flaws, filtering out false positives.
Guides authorized recon: subdomain enumeration, DNS analysis, fingerprinting and OSINT correlation.
Audits dependencies and configs for known CVEs, scores risk with CVSS, and writes prioritized fix reports.
Helps build proof-of-concept exploits and payloads for targets under confirmed authorization.
Guides binary analysis, disassembly, decompilation, firmware and protocol reverse engineering.
Runs static and dynamic malware analysis, writes YARA rules, and classifies malware families safely.
Guides security architecture design with defense-in-depth, zero trust, threat modeling and control frameworks.
Reviews code and config for OWASP Top 10 and LLM or agent security flaws, and guides secure fixes.
Red-team guidance for agentic LLM apps: prompt injection, MCP tool poisoning, memory poisoning and tool abuse tests.
Security testing for AI/ML systems: prompt injection, RAG poisoning, MCP audits and model artifact scanning.
Interprets diffs between Windows builds, flagging changed syscalls, callbacks and telemetry for security research.
Applies deterministic security policies to shell, file and MCP actions via hooks, and scans configs.
Guides securing ROS2 robots with SROS2 DDS encryption, access control, network segmentation and hardening.
Packages a verified vulnerability into a responsible disclosure report and helps request a CVE, with an authorization gate.
Drives Burp Suite over MCP to triage proxy traffic, replay requests and hand off to vuln-class testing.
Gives the agent safety rules for running commands, fetching URLs, and handling credentials and packages.
Audits a Stata do-file read-only for security, portability and encoding risks, emitting a JSON report.
Inspects local Stata-MCP audit logs to show tool runs, security blocks and snapshot integrity.
Runs a parallel security audit of a codebase and returns a scored report with a prioritized fix list.
Lock down Symfony API Platform operations with security expressions, voters, and post-validation checks.
Walks the agent through abusing AD object ACL edges with bloodyAD and impacket, plus detection and fixes.
Explains AD hardening like disabled NTLM, AES-only KDCs, LDAPS and clock skew that break attacks silently.
Sets the phase order for an Active Directory pentest: setup, collection, exploitation and post-processing.
Lists the event IDs and noise each AD technique produces, so red and blue teams know what gets logged.
Guides AD CS ESC1 to ESC17 escalation with Certipy, covering find, request, auth, event IDs and fixes.
Audits your local agent stack for risky skills, MCP servers, hooks and credential permissions, read-only.
Audits git repos, agent skills and MCP servers for injection, credential theft, CVEs and risky patterns.
Guides changes to Gryph's AARM policy engine, receipt chain and context accumulator via its dev doc.
Scans a repository for security vulnerabilities with the supercov CLI and maps findings to CWE classes.
Validates bug bounty reports on authorized targets, assesses severity and drafts a submission-ready report.
Builds a SQLite analysis database from JAR, WAR or class files for Java static analysis.
Runs SQL queries on the analysis database to trace method calls and flag Java vulnerability patterns.
Audits an AI project repo against China's cyber, privacy and AI labeling rules, with file-line evidence.
Walks through an OpenClaw deployment security checklist covering network, containers, secrets and plugins.
Coordinates parallel subagents to test a web app for XSS, injection and CSRF flaws.
Runs an authorized, local-first security assessment of the user's app, validating findings and retesting fixes.
Applies the SAIL V2 framework to assess AI and agent risks, build roadmaps and prioritize controls.
Guides feedback-loop-first diagnosis of hard bugs and slow regressions, redacting secrets from output.
Diagnoses tracebacks and training failures conservatively, proposing minimal fixes that need approval first.
Makes the agent find the root cause of any bug or failure before proposing a fix.
Makes the agent gather evidence and rank hypotheses to diagnose failures before editing code.
Fixes bugs at the narrowest responsible layer, with a regression check and minimal unrelated changes.
Measures first, then fixes real bottlenecks in frontend, backend, queries, and databases.
Guides systematic root-cause debugging for failing tests, broken builds, and unexpected errors.
Guides debugging by testing competing hypotheses in parallel and settling the root cause with evidence.
Writes structured bug reports from descriptions, analyzes code for likely bugs, and verifies or closes fixes.
Re-prioritizes open bugs by severity and priority, assigns them to sprints, and reports systemic trends.
Finds the root cause of a bug with file-level evidence, then optionally applies a test-first fix.
Guides root-cause debugging of errors and bugs, forbidding blind retries and requiring a fixed report.
Makes the agent run ccusage in a cmux pane and read the captured output back to verify terminal rendering.
Profiles ccusage CLI performance, comparing branches and checking that optimizations actually helped.
Analyzes agent reasoning traces to find context decay, tool confusion and drift, then suggests fixes.
Parses errors and stack traces, correlates logs and applies hypothesis-driven steps to find root causes.
Guides live debugging of Hive queen sessions, colony forks and worker spawns in an isolated environment.
Guides crash triage with GDB, WinDbg and sanitizer output to judge exploitability and find root cause.
Audits issue backlogs by shared root cause and plans cluster-level fixes instead of one-off patches.
Triages incoming bug reports by root class and batches fixes that shrink the system instead of patching symptoms.
Finds the root cause of errors, crashes, and regressions before any fix is applied.
Reproduces an app bug, tests competing hypotheses, then fixes only the proven root cause.
Attaches Frida to a process, loads a hook script, and records send() events to confirm runtime behavior.
Instruments C and C++ builds to trace function calls per thread and convert logs for Perfetto.
Has the agent debug crashes with rr record-replay, using reverse stepping and crash trace extraction.
Has the agent diagnose fast-agent session and history files to find unexpected endings, tool loops and timing issues.
Makes the agent investigate blocked or failing implementations by finding root cause before any fix.
Traces a problem back through repeated why questions to its root cause, then proposes fixes.
Reproduces a failing journey in an existing project, makes a targeted fix, and reruns the checks.
Drafts a redacted bug report for chengfeng-videocut and files a GitHub issue only after user confirmation.
Makes the agent capture and filter Windows debug output with the Sysinternals DebugView CLI.
Turns a user-reported bug into a GitHub issue in the project's own terms, after checking for duplicates.
Writes Frida hook scripts with the modern API to trace calls, capture arguments and return values, and dump memory.
Gives IDAPython and IDALib code snippets for scripting IDA analysis, debugging, memory, and Hex-Rays tasks.
Recovers data structure layouts from memory access patterns across functions and their call chains.
Recovers function names by analyzing code patterns, strings, constants, and cross-references in binaries.
Emulates selected functions with Unicorn, hooking JNI, syscalls, and libc calls to trace or decode data.
Makes the agent reproduce a bug, isolate it, test one hypothesis at a time, and confirm the fix with the repro.
Finds where and why a tau2-bench task failed by mapping root causes to rounds and cited docs.
Makes the agent run a hypothesis-driven debugging protocol with evidence gathering when standard fixes fail.
Makes the agent run a discriminating experiment before writing fixes when a bug survives repeated attempts.
For a localized fault, the agent traces evidenced whys to a systemic root and proposes a countermeasure.
The agent locates selective defects by IS/IS-NOT contrast, or ranks options by must and want criteria.
When docs or tests contradict observed behavior, the agent checks live code or data first.
Guides evidence-first debugging: clarify behavior, reproduce, test hypotheses, and get approval before code changes.
Debugs by forming testable hypotheses and running targeted experiments to confirm or reject each one.
Splits a hard bug or incident into parallel investigation threads and merges findings into one report.
Finds a bug's true root cause through phased investigation and Five Whys before applying any fix.
Pinpoints where a bug starts using binary search, git bisect, targeted logging and minimal repro cases.
Guides fixing ClaudeBar bugs with a failing test first, root cause analysis, and rich domain design.
Runs falsification-first layered experiments to find root causes of network, streaming and protocol failures.
Applies error handling patterns, structured logging, retries, circuit breakers and graceful degradation.
Profiles and optimizes slow frontend, backend and database code, measuring before and after each change.
Finds unbounded or no-progress work in hot paths and ranks performance fixes by evidence and severity.
Reproduces a bug, finds its root cause, applies a minimal fix, and adds a regression test.
Traces failed SLCI code inspection results back to incompatible model settings or known limitations.
Reproduces a broken UI in the running app and reads the click, request, store and console to find the cause.
Reads notes a human left in the running app and fixes each flagged element at its source file and line.
Analyzes iOS and macOS crash logs such as .ips and MetricKit files, symbolicates them and points to fixes.
Ranks grouped production crashes and hangs from Sentry or App Store Connect, keeping noise visible.
Makes the agent find the root cause of bugs, test failures and CI issues before proposing any fix.
After a bug or failing test, traces the root cause and adds a spec invariant and test to prevent recurrence.
Debugs live issues across hooks, API, DB, websocket and UI by gathering evidence and proving the root cause before fixing.
Fetches TestFlight crashes, beta feedback and performance diagnostics with asc and summarizes them.
Checks that a reported run caused its real effect by tracing the code path and observing each hop.
Guides the agent through systematic, evidence-based bug diagnosis and root cause analysis.
Searches the MisakaNet index for fixes to errors and submits redacted failure reports when none match.
Runs a structured debugging workflow that gathers evidence first, then delegates the investigation to a debugger agent.
Finds proven fixes for software errors in GitHub issues, PRs and code, then applies a minimal local change.
Generates a Bug Fix Brief with root cause, repro steps, fix options and a checklist, saved under docs/bfb.
Drives a live debugger via the dap CLI to set breakpoints, step through code, and inspect variables.
Runs an evidence-based bug investigation and publishes the root-cause report to Confluence via Atlassian MCP.
Guides multi-layer reverse engineering of a product into behavioral specs with provenance citations.
Inventories local files, web info and running services as intelligence sources for a target product.
Guides static analysis of compiled binaries and bundles to recover behavior without executing them.
Answers questions about past agent runs from recordings, and replays or forks a run to reproduce failures.
Statically flags runtime errors like out-of-bounds access, null dereference and overflow in source code.
Uses abstract interpretation to summarize program behavior, value ranges and possible runtime errors.
Guides embedded debugging with probe-rs: checks probes, starts the MCP server, handles flashing and RTT.
Guides iOS crash log analysis, dSYM symbolication, and stack trace root-cause debugging.
Guides a test-first bug fix: reproduce with a failing test, minimal fix, then verify no regressions.
Fixes a whole bug class: reproduces the report, finds the same pattern in scope, and adds a guard.
Guides debugging in order: observe, find the cause, make the smallest fix, verify, then explain plainly.
Nothing matches. Try a shorter word.