Tools

Applies accessibility rules (WCAG) to a rendered page, and names the element behind each violation.

builds Browser run

Compares an interface description with the one from the last release, and lists the changes that break callers.

builds API compatibility check

Checks what a release ships: checksums, signatures, the architecture of binaries, and the files in a package.

builds Structure check, Smoke and health probe

Whatever runs this project's benchmarks and keeps their results to compare against.

builds Performance measurement

A library that drives a real browser from a script: it clicks, types and waits, and records screenshots, video and traces.

builds Browser run, Screenshot and recording

Whatever builds this project, found in the project itself rather than assumed.

builds Build and type check

Checks the CI workflows themselves: actions not pinned to a commit, permissions wider than needed, untrusted input in commands.

builds Structure check, Security scanner

Whatever measures which lines and branches this project's tests run, with a report other tools can read.

builds Coverage and mutation

Builds the graph of imports between modules, checks it against the allowed directions, and measures its coupling.

builds Linter, Dependency graph

Lists the project's dependencies and checks each against vulnerability databases and the allowed licences.

builds Security scanner

Runs a suite of cases against a prompt, a model or an agent many times, and scores each case's assertions.

builds Eval set

Sits between a service and a dependency in tests, and makes that dependency slow, cut off or broken on demand.

builds Input and fault injection

Feeds a function a stream of mutated inputs guided by coverage, and keeps each input that crashes it.

builds Input and fault injection

The repository itself, read through git: the diff, the log, the state of the tree, branches and worktrees.

builds Repository state

Sends a request to a service and shows exactly what came back.

builds Smoke and health probe, Manual probe

Follows the links in the project's documents, and reports the ones that lead nowhere.

builds Structure check

Whatever lints and formats this project's code, found in the project itself rather than assumed.

builds Linter

Sends a scripted load to a running service, and reports latency percentiles and errors against thresholds.

builds Performance measurement

Checks database migrations for operations that lock tables, lose data or cannot be undone.

builds Linter

Makes small changes to the code, runs the tests against each, and reports the changes no test noticed.

builds Coverage and mutation

A file in the repository that loops append to: each escape, correction and verdict, with when and where it happened.

builds Loop outcomes

Loads a page and scores its performance, accessibility and best practices, with the audits that cost it points.

builds Performance measurement, Browser run

Samples where a program spends its time or memory, and shows the functions that cost the most.

builds Performance measurement, Manual probe

Generates inputs for a test from a description of them, and shrinks a failing input to the smallest one that still fails.

builds Input and fault injection

The interactive tools of the project's language: a REPL to call the code, a debugger to stop it and read its values.

builds Manual probe

Validates a YAML or JSON file against its JSON Schema, and names the field that breaks it.

builds Structure check

Generates requests from an API's schema, sends them to the running API, and checks every response against the schema.

builds API compatibility check, Input and fault injection

Replaces a language model in tests with recorded or scripted responses, so tests of an AI feature give the same result every time.

builds Test runner

Runs a terminal app in a terminal of fixed size that a script can type into and read back.

builds Terminal run, Screenshot and recording

Finds credentials in files, staged changes and the git history.

builds Security scanner

Measures the size of what users download (a bundle, a package, a binary) and fails when it passes its limit.

builds Performance measurement

Compares output with an approved reference stored in the repository, and shows the difference when they part.

builds Test runner

Reads the source for code patterns known to be unsafe, and reports each with its rule and place.

builds Security scanner

Rules written as code patterns over the syntax tree, for conventions no stock linter knows.

builds Linter, Security scanner

Whatever runs this project's tests, found in the project itself rather than assumed.

builds Test runner

Real dependencies (a database, a queue, a cloud API emulator) started in containers for one test run and removed after it.

builds Test runner

Checks the project's messages and translations: hard-coded strings, missing keys, placeholders that differ between locales.

builds Structure check, Linter

Checks the types of the code without running it, where the language has a checker separate from its build.

builds Build and type check

The database's own tools for backing up and restoring, used to prove that a backup can actually be restored.

builds Smoke and health probe

Injects failures into a running environment (processes killed, network delayed, resources exhausted) while checking that it stays healthy.

builds Input and fault injection

Where the project's checks run on every pull request and push, with each job's status and log.

builds CI results

Where the project's pull requests, reviews, checks and protected branches live, reached from the command line or its API.

builds Human review, CI results, Delivery flow metrics, Human answer

Stores the contracts consumers expect from a service and the provider's verification of each, so a deploy can ask whether it is safe.

builds Test runner

Probes a running copy of the app from outside, and reports the addresses that respond unsafely.

builds Security scanner

Where the project's production errors are grouped into issues, with stack traces, counts and the releases they appear in.

builds Error tracker

The ways users tell the team what works and what does not: an in-product feedback command, a form, the support desk, experiment results.

builds User feedback

The addresses a service answers on to say whether it is alive and ready, and the platform's probes that call them.

builds Smoke and health probe

An environment of its own for each agent run: its own checkout, dependencies, network rules and secrets.

builds Isolation probe

Where bugs, requests and their discussion are kept, with templates that make a report complete.

builds Human review, User feedback

Where the project's logs are kept and queried, found in its configuration rather than assumed.

builds Logs

Where the project's metrics are kept and queried, with its alert and SLO rules.

builds Metrics and SLOs

A direct call to a language model with a rubric prompt and a structured answer, outside any agent.

builds LLM judge, Eval set

A running copy of the change, deployed for each pull request at its own address, for the checks that need the app to run.

builds Browser run, Smoke and health probe, Security scanner, Performance measurement

Rolls a release out step by step, checks it against metrics at each step, and rolls it back on failure.

builds Smoke and health probe, Metrics and SLOs

Where the project's traces are collected and queried, fed by the instrumentation in its code.

builds Traces, Performance measurement

Gives the agent itself a browser to act in, through the page's accessibility tree, with the console and network in view.

builds Browser run, Manual probe, Screenshot and recording

A separate agent run that starts with none of the working session's context, has read-only tools, and returns a structured verdict.

builds LLM reviewer, LLM judge

Commands the coding agent runs before and after each tool call and when it is about to stop, which can record the call or refuse it.

builds Agent activity

The coding agent's controls to stop it in the middle of a step, and to roll its changes back to an earlier point.

builds Live supervision

Gives the agent diagnostics for the file it just edited, before any build.

builds Build and type check

The coding agent's rules for which actions run, which are refused, and which go to a person or a model first.

builds Human answer, LLM judge

A mode in which the coding agent may only read and plan, until a person approves the plan.

builds Human answer

The coding agent's way to put a question to a person, with a few options and a free answer, and wait for it.

builds Human answer

The record the coding agent keeps of each session: the prompts, the tool calls and their results.

builds Agent activity, Loop outcomes