# mutation-testing

Published articles for mutation-testing.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Checks for safer review of rapidly generated TypeScript and React frontend code

DevFeed: [Checks for safer review of rapidly generated TypeScript and React frontend code](<https://devfeed.tech/articles/10-anti-ai-slop-moves-for-frontend-projects-going-faster-than-humans-can-review-19790.md>)

Original publisher: [Read original article](<https://evilmartians.com/chronicles/ten-anti-ai-slop-moves-for-frontend-projects-going-faster-than-humans-can-review>)

Author: Travis Turner (richardturner@evilmartians.com)

Published: 2026-09-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Evil Martians](<https://devfeed.tech/sources/evil-martians.md>)

Topics: [Front end](<https://devfeed.tech/topics/frontend.md>), [React](<https://devfeed.tech/topics/react.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [OpenAPI Specification](<https://devfeed.tech/topics/openapi.md>), [API](<https://devfeed.tech/topics/api.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [agent-experience](<https://devfeed.tech/tags/agent-experience.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [code](<https://devfeed.tech/tags/code.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [dx](<https://devfeed.tech/tags/dx.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [openapi](<https://devfeed.tech/tags/openapi.md>), [react](<https://devfeed.tech/tags/react.md>), [testing](<https://devfeed.tech/tags/testing.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

This article presents ten checks for making rapidly generated TypeScript and React frontend code safer to trust and cheaper to review. It covers API contracts, generated types, boundary validation, mutation testing, dead-code detection, and mandatory checks.

### Source excerpt

Ten checks that catch what AI-written frontend code hides: contract codegen, boundary linting, mutation testing, and dead-code detectors.

## Human judgment doesn't leave the software factory. It relocates.

DevFeed: [Human judgment doesn't leave the software factory. It relocates.](<https://devfeed.tech/articles/human-judgment-doesn-t-leave-the-software-factory-it-relocates-18053.md>)

Original publisher: [Read original article](<https://addyo.substack.com/p/human-judgment-doesnt-leave-the-software>)

Author: Addy Osmani

Published: 2026-08-21T14:31:12Z

Content type: article

Language: en

Sources: [Elevate](<https://devfeed.tech/sources/elevate.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [pull-requests](<https://devfeed.tech/topics/pull-requests.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [github](<https://devfeed.tech/tags/github.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [quality](<https://devfeed.tech/tags/quality.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This field guide explains how to build a repeatable software factory while preserving human judgment and ownership. It recommends human involvement in product intent, system design, quality standards, code review, and merge decisions, supported by automated checks and deliberate experimentation. The article argues that a factory is most useful when work must be repeatable and event-driven across queues such as GitHub issues, Slack, Linear, or a backlog.

### Source excerpt

A field guide to building a software factory that still has an owner.

## Human judgment doesn't leave the software factory. It relocates.

DevFeed: [Human judgment doesn't leave the software factory. It relocates.](<https://devfeed.tech/articles/human-judgment-doesn-t-leave-the-software-factory-it-relocates-28497.md>)

Original publisher: [Read original article](<https://addyosmani.com/blog/human-judgment-doesnt-leave-the-software/>)

Author: Addy Osmani

Published: 2026-08-21T00:00:00Z

Content type: article

Language: en

Sources: [Addy Osmani](<https://devfeed.tech/sources/addy-osmani.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [coding](<https://devfeed.tech/topics/coding.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [batch](<https://devfeed.tech/tags/batch.md>), [build](<https://devfeed.tech/tags/build.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [github](<https://devfeed.tech/tags/github.md>), [linear](<https://devfeed.tech/tags/linear.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [quality](<https://devfeed.tech/tags/quality.md>), [scanners](<https://devfeed.tech/tags/scanners.md>), [slack](<https://devfeed.tech/tags/slack.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

A field guide to building a repeatable software factory while keeping humans responsible for product intent, system design, quality standards, code review, and final merge decisions. It recommends early and continuous quality checks, deliberate constraints, and event-driven automation when ordinary coding workflows are no longer sufficient.

### Source excerpt

A field guide to building a software factory that still has an owner.

## Agentic Code Quality

DevFeed: [Agentic Code Quality](<https://devfeed.tech/articles/agentic-code-quality-18044.md>)

Original publisher: [Read original article](<https://addyo.substack.com/p/agentic-code-quality>)

Author: Addy Osmani

Published: 2026-08-08T14:31:15Z

Content type: opinion

Language: en

Sources: [Elevate](<https://devfeed.tech/sources/elevate.md>)

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The article argues that code quality for agent-generated software depends on constraints enforced by the surrounding harness, environment, and operating system. It describes quality gates including unit, property, and acceptance tests, mutation testing, code-quality metrics, and checks on proposed changes, while noting risks from autonomy, ambiguity, brittle environments, nondeterministic builds, missing permissions, and weak tests.

### Source excerpt

Quality now depends on the constraints you set around your agents.

## Agentic Code Quality

DevFeed: [Agentic Code Quality](<https://devfeed.tech/articles/agentic-code-quality-28493.md>)

Original publisher: [Read original article](<https://addyosmani.com/blog/agentic-code-quality/>)

Author: Addy Osmani

Published: 2026-08-08T00:00:00Z

Content type: article

Language: en

Sources: [Addy Osmani](<https://devfeed.tech/sources/addy-osmani.md>)

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>)

Tags: [code-quality](<https://devfeed.tech/tags/code-quality.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The article argues that code quality for agent-generated software depends on quality gates and deterministic constraints enforced through the surrounding harness, environment, and operating system. It discusses unit, property, acceptance, and mutation testing, along with code-quality metrics and checks on the scope and safety of proposed changes.

### Source excerpt

Quality now depends on the constraints you set around your agents.

## Production ML-DSA Verification in 350 Lines of Python

DevFeed: [Production ML-DSA Verification in 350 Lines of Python](<https://devfeed.tech/articles/production-ml-dsa-verification-in-350-lines-of-python-20698.md>)

Original publisher: [Read original article](<https://words.filippo.io/mldsa-py/>)

Author: Filippo Valsorda

Published: 2026-07-26T11:45:08Z

Content type: article

Language: en

Sources: [Filippo Valsorda](<https://devfeed.tech/sources/filippo-valsorda.md>)

Topics: [Post-Quantum](<https://devfeed.tech/topics/post-quantum.md>), [Python](<https://devfeed.tech/topics/python.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>)

Tags: [cryptography](<https://devfeed.tech/tags/cryptography.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [python](<https://devfeed.tech/tags/python.md>), [testing](<https://devfeed.tech/tags/testing.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article presents a production pure-Python ML-DSA signature verifier that supports all parameter sets, Python 3.8 and later, and an API modeled after pyca/cryptography. It describes the implementation's performance, portability rationale, and testing with Wycheproof vectors, accumulated vectors, pytest, mutation testing, and branch coverage.

### Source excerpt

I am publishing a production, pure-Python ML-DSA verifier. It's just 350 lines, and pretty readable and robust.

## Rust-proof your code with our new Testing Handbook chapter

DevFeed: [Rust-proof your code with our new Testing Handbook chapter](<https://devfeed.tech/articles/rust-proof-your-code-with-our-new-testing-handbook-chapter-7658.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/07/13/rust-proof-your-code-with-our-new-testing-handbook-chapter/>)

Author: "Paweł Płatek"

Published: 2026-07-13T11:00:00Z

Content type: tutorial

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Security](<https://devfeed.tech/topics/security.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Test coverage](<https://devfeed.tech/topics/coverage.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust formal verification](<https://devfeed.tech/topics/rust-formal-verification.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [application-security](<https://devfeed.tech/tags/application-security.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [testing](<https://devfeed.tech/tags/testing.md>), [testing-handbook](<https://devfeed.tech/tags/testing-handbook.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

A new Testing Handbook chapter presents techniques for security testing Rust programs and systems. It covers Rust security limitations, dynamic and static analysis, undefined-behavior detection with Miri, property testing, coverage and mutation testing, Clippy, manual code review, memory zeroization, model checking with Kani, and dependency supply-chain vetting. The article also announces rust-review, a Claude Code plugin for automated Rust security reviews.

### Source excerpt

We've added a new chapter to our Testing Handbook: a comprehensive guide to security testing Rust programs. This chapter covers the tools and techniques we use at Trail of Bits to validate the security of Rust programs and systems. fn main() {(|f:&dyn Fn(u128)->Box< dyn Iterator<Item= char>+'static>|f(*[&( 0x7B736D70683F73u128<<64| 0x7A6A6D7C3F7A667D),&(0x7B736Du128 <<64|0x70683F7073737A77)][((std::hint:: black_box(0.0f64)/0.0).to_bits()>>63)as usize]) .for_each(|c|print!("{c}")))(Box::leak(Box::new(|n: u128|Box::new(std::iter::successors(Some(n),|&n|Some(n>>8) ).take_while(|&n|n>0).map(|n|((n as u8)^0x1F)as char))as _)))} What's in the chapter The chapter starts with a security overview of what Rust's guarantees do and don't cover, including underappreciated issues like unwind safety, nondeterminism, and arithmetic errors. This leads into an overview of dynamic analysis, which covers a range of boosters for unit tests, how to use Miri to detect undefined behavior, property testing with proptest, coverage measurement, and mutation testing. The static analysis section then covers Clippy in depth, including a list of our favorite lints. Beyond tooling, the chapter also covers what we've learned from auditing Rust codebases directly. Our gotchas and footguns checklist is a great reference for manual code reviews, and will help you find subtle issues like a & b == c having different operator precedence than in C. The memory zeroization section offers three solutions to the tricky problem of guaranteeing that secrets are erased from memory. Finally, the specialized testing sections cover tools like Kani (a model checker), and the supply chain section covers the full toolchain for vetting dependencies. Still oxidizing We've also released rust-review, a Claude Code plugin for automated Rust security reviews. Co-built with Aptos Labs, it targets over a dozen bug classes, from memory safety and concurrency hazards to FFI pitfalls and async cancellation issues. It's a fast wa

## Mutation testing comes to DAML

DevFeed: [Mutation testing comes to DAML](<https://devfeed.tech/articles/mutation-testing-comes-to-daml-7657.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/07/08/mutation-testing-comes-to-daml/>)

Author: "Kamil Chmielewski"

Published: 2026-07-08T11:00:00Z

Content type: article

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [Code](<https://devfeed.tech/topics/code.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [applications](<https://devfeed.tech/tags/applications.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [open](<https://devfeed.tech/tags/open.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [production](<https://devfeed.tech/tags/production.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tool-release](<https://devfeed.tech/tags/tool-release.md>)

### AI overview

Mewt, an open-source mutation-testing engine, now supports DAML, the language used for Canton Network applications. The article explains how mutation testing exposes gaps that ordinary coverage reports can miss by generating modified versions of code and checking which changes survive the existing test suite.

### Source excerpt

In April we released Mewt, our open-source mutation-testing engine that finds the gaps in your test suite. Today we're expanding it with support for DAML, the language Canton Network applications are written in. Mewt now reads DAML, generates several classes of mutants (including two built for DAML's authorization primitives), and runs them through your existing test suite to count how many mutants survive. If you want to try it, simply install Mewt from the repository, point a mewt.toml at your project and its test command, and use mewt run. For a team shipping DAML to production, that count is what a passing test run is actually worth: it puts a number on how much your suite checks, whereas a green run on its own does not. Why DAML's coverage reports lie Test coverage is the most reassuring lie in smart-contract development. Hitting 100% line coverage tells you the test runner walked the code; it does not tell you whether any test would fail if that code stopped doing what it is supposed to. We have been grading test harnesses by how many mutants they kill since at least 2019, and our primer on finding the bugs your tests don't catch shows how a green suite can still miss the bug that matters. DAML's built-in coverage measures execution at the template and choice level: which templates were created and which choices were exercised over the test run. It reports whether each choice was exercised, not what happened inside it. A test that exercises a choice once and asserts nothing about the result reports that choice as covered. The report prints the same green percentage whether the test verifies the outcome or discards it. How mutation testing works Instead of asking whether your tests reached the code, mutation testing grades your tests by sabotaging that code. The engine generates mutants, copies of the code that each carry one small deliberate change: a flipped comparison, a removed branch, a dropped party. It then runs your test suite against each one. A mutant

## Code Smell 320 - Vanity Coverage

DevFeed: [Code Smell 320 - Vanity Coverage](<https://devfeed.tech/articles/code-smell-320-vanity-coverage-18227.md>)

Original publisher: [Read original article](<https://maximilianocontieri.com/code-smell-320-vanity-coverage>)

Author: Maxi Contieri

Published: 2026-06-23T23:32:02Z

Content type: tutorial

Language: en

Sources: [Maximiliano Contieri - Software Design](<https://devfeed.tech/sources/maximiliano-contieri-software-design.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Test coverage](<https://devfeed.tech/topics/coverage.md>)

Tags: [coverage](<https://devfeed.tech/tags/coverage.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The article describes vanity coverage: tests that execute code without verifying meaningful behavior, which can create false confidence and allow defects to reach production. It recommends behavior-focused assertions and mutation testing to identify ineffective tests.

### Source excerpt

TL;DR: You write tests that touch every line but verify nothing, creating false confidence in a broken system. Problems 😔 False confidence Hidden production defects Misleading metrics Wasted tes

## Trailmark turns code into graphs

DevFeed: [Trailmark turns code into graphs](<https://devfeed.tech/articles/trailmark-turns-code-into-graphs-7647.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/04/23/trailmark-turns-code-into-graphs/>)

Author: "Scott Arciszewski"

Published: 2026-04-23T12:00:00Z

Content type: article

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Graphs](<https://devfeed.tech/topics/graphs.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Code](<https://devfeed.tech/topics/code.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [Tree-sitter](<https://devfeed.tech/topics/tree-sitter.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [python](<https://devfeed.tech/tags/python.md>), [research-practice](<https://devfeed.tech/tags/research-practice.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tool](<https://devfeed.tech/tags/tool.md>), [tool-release](<https://devfeed.tech/tags/tool-release.md>)

### AI overview

Trailmark is an open-source library that parses source code into queryable call graphs and exposes them through a Python API that Claude skills can call. The article explains how graph-level reasoning can help analyze codebases, triage surviving mutation-testing mutants by security relevance, and support Claude Code skills for tasks such as test vector generation and protocol diagramming.

### Source excerpt

We're open-sourcing Trailmark, a library that parses source code into a queryable call graph of functions, classes, call relationships, and semantic metadata, then exposes that graph through a Python API that Claude skills can call directly. Install it now: uv pip install trailmark "Defenders think in lists. Attackers think in graphs. As long as this is true, attackers win." John Lambert's widely cited observation about network security applies just as well to AI-assisted software analysis. When Claude reasons about a codebase, it reasons about lists: findings from static analyzers, surviving mutants from mutation testing, and line-by-line coverage reports. But the question that actually matters is a graph question: can untrusted input reach this code, and what breaks if it's wrong? We built Trailmark to answer that question. It gives Claude a graph to think with instead of a list. We're also releasing eight Claude Code skills we've built on top of it, designed for mutation triage, test vector generation, protocol diagramming, and more. When lists fall short Mutation testing is a great example of a method that benefits from graph-level reasoning. It's one of the best ways to measure test quality. It makes small changes to your source code (e.g., swapping a < for <=, replacing + with -) and checks whether your tests catch the difference. Mutants that survive reveal gaps in your test suite that code coverage metrics might miss. The downside is that a mutation testing run on a real codebase can produce hundreds of surviving mutants of varying significance. This is very much a list. Some surviving mutants are equivalent: the mutation doesn't change the program's behavior because of structural or mathematical constraints that the mutation testing tool can't see. Some are in dead code; some are in error message formatting; some are in the finite field arithmetic that underpins every cryptographic operation in your library. A flat list of surviving mutants doesn't tell you

## Mutation testing at Mercado Libre: From pilot to everyday guardrail

DevFeed: [Mutation testing at Mercado Libre: From pilot to everyday guardrail](<https://devfeed.tech/articles/mutation-testing-at-mercado-libre-from-pilot-to-everyday-guardrail-22555.md>)

Original publisher: [Read original article](<https://medium.com/mercadolibre-tech/mutation-testing-at-mercado-libre-from-pilot-to-everyday-guardrail-2ffe0a273f0e?source=rss----5011f85401f0---4>)

Author: Luram Archanjo

Published: 2026-01-14T12:19:03Z

Content type: article

Language: en

Sources: [Mercado Libre Tech](<https://devfeed.tech/sources/mercado-libre-tech.md>)

Topics: [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>)

Tags: [ci-cd-pipeline](<https://devfeed.tech/tags/ci-cd-pipeline.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [github](<https://devfeed.tech/tags/github.md>), [github-action](<https://devfeed.tech/tags/github-action.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [software-quality-testing](<https://devfeed.tech/tags/software-quality-testing.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Mercado Envíos integrated mutation testing into Mercado Libre's Fury pipelines using a multi-stack GitHub Action, delta-first execution focused on modified code, and gradual team-level gates. The article explains how this approach supplements coverage by identifying weak test assertions and aims to improve pull request quality and reduce regressions.

### Source excerpt

Beyond coverage: How we integrated mutation testing into Fury pipelines and turned it into an actionable quality indicator for teams At Mercado Envíos (ME), we saw that high test coverage didn't always prevent regressions -- pull requests (PRs) were green, but we still broke production. In this article, we share how we brought mutation testing into our pipelines on Fury, our internal developer platform (IDP). We used a single multi-stack GitHub Action, a delta-first approach, and gradual team-level gates. We walk through the design decisions, challenges, and lessons learned that helped us turn this technique into an everyday guardrail that improves test effectiveness and PR quality. Introduction: Green PR, still an incident Friday, end of the day. You've got a green PR, pipelines are passing, and coverage looks great. You merge with confidence. On Monday, production goes down because of an edge case no one asserted. Sounds familiar? Same here. Coverage tells us what runs, not whether tests fail where they should. You can have 95-100% line coverage and still let a subtle regression slip -- a slightly wrong if condition, an unexpected default value, a branch with no assertions. That's where mutation testing comes in. Instead of assuming tests are good just because they pass, you intentionally introduce small code changes (mutants) and check whether the test suite kills them. In mutation testing, "killing a mutant" means your test suite fails when run on the mutated code, proving it can detect the injected defect. If mutants survive, you get a concrete indicator of weak assertions exactly in the area you're changing. At Mercado Envíos (ME), we moved from a one-off experiment to making mutation testing part of teams' daily flow. We integrated it into our standard pipelines on Fury, Mercado Libre's internal developer platform. We did it without breaking delivery: a single, multi-stack GitHub Action; delta-first execution focused on modified code; and team-level gates with

## Using Mutation Testing to Evaluate Test Suite Effectiveness

DevFeed: [Using Mutation Testing to Evaluate Test Suite Effectiveness](<https://devfeed.tech/articles/test-your-test-23032.md>)

Original publisher: [Read original article](<https://www.javaadvent.com/2025/12/test-your-test.html>)

Author: Andres Sacco

Published: 2025-12-04T02:02:10Z

Content type: tutorial

Language: en

Sources: [Java Advent Calendar](<https://devfeed.tech/sources/java-advent-calendar.md>)

Topics: [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [code](<https://devfeed.tech/tags/code.md>), [code-coverage](<https://devfeed.tech/tags/code-coverage.md>), [effective](<https://devfeed.tech/tags/effective.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The article explains why high code coverage does not necessarily indicate effective tests. It introduces mutation testing, which evaluates a test suite by making small controlled changes to source code and checking whether the tests detect those changes.

### Source excerpt

Creating or modifying an application involves many aspects, such as following best practices and applying design patterns to solve everyday problems. After writing the code, developers usually add unit tests and rely on tools like Sonar to track metrics such as code coverage and highlight potentially untested areas. However, high test coverage does not guarantee [...] The post Test Your Test appeared first on JVM Advent.

## Meta's ACH Tool Uses LLMs for Mutation-Guided Test Generation and Compliance Testing

DevFeed: [Meta's ACH Tool Uses LLMs for Mutation-Guided Test Generation and Compliance Testing](<https://devfeed.tech/articles/llms-are-the-key-to-mutation-testing-and-better-compliance-30491.md>)

Original publisher: [Read original article](<https://engineering.fb.com/2025/09/30/security/llms-are-the-key-to-mutation-testing-and-better-compliance/>)

Author: Mark Harman

Published: 2025-09-30T16:00:08Z

Content type: article

Language: en

Sources: [Meta AI Research](<https://devfeed.tech/sources/meta-ai-research.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Meta](<https://devfeed.tech/topics/meta.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-research](<https://devfeed.tech/tags/ai-research.md>), [code](<https://devfeed.tech/tags/code.md>), [llms](<https://devfeed.tech/tags/llms.md>), [meta](<https://devfeed.tech/tags/meta.md>), [ml-applications](<https://devfeed.tech/tags/ml-applications.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [security-privacy](<https://devfeed.tech/tags/security-privacy.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Meta describes its Automated Compliance Hardening (ACH) tool, which uses large language models to generate relevant code mutants and tests designed to catch them. The article explains how this supports mutation testing and helps identify compliance-related bugs.

### Source excerpt

Following our keynote presentations at FSE 2025 and Eurostar 2025, we're delving further into the development of Meta's Automated Compliance Hardening (ACH) tool, an LLM-based tool for software testing that is automating aspects of compliance adherence at Meta, while accelerating developer and product velocity. By leveraging LLMs we've been able to overcome the barriers that [...] Read More... The post LLMs Are the Key to Mutation Testing and Better Compliance appeared first on Engineering at Meta.

## 6 Testing Mistakes You Should Avoid

DevFeed: [6 Testing Mistakes You Should Avoid](<https://devfeed.tech/articles/6-testing-mistakes-you-should-avoid-26198.md>)

Original publisher: [Read original article](<https://craftbettersoftware.com/p/6-testing-mistakes-you-should-avoid>)

Author: Daniel Moka

Published: 2025-04-05T05:00:42Z

Content type: tutorial

Language: en

Sources: [Craft Better Software](<https://devfeed.tech/sources/craft-better-software.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Development](<https://devfeed.tech/topics/development.md>), [clean-code](<https://devfeed.tech/topics/clean-code.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [code-testing](<https://devfeed.tech/tags/code-testing.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [shift-left](<https://devfeed.tech/tags/shift-left.md>), [solid-principles](<https://devfeed.tech/tags/solid-principles.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

A practical guide to avoiding common testing mistakes, including testing late, relying too heavily on code coverage, testing implementation details, and neglecting clean test code. It recommends shift-left testing, mutation testing, behavior-focused tests through public APIs, and treating tests as maintainable code.

### Source excerpt

Each with a simple fix you can apply today

## Five Essential Code Review Tips in the Age of AI

DevFeed: [Five Essential Code Review Tips in the Age of AI](<https://devfeed.tech/articles/code-review-like-a-pro-26202.md>)

Original publisher: [Read original article](<https://craftbettersoftware.com/p/code-review-like-a-pro>)

Author: Daniel Moka

Published: 2025-03-29T06:01:17Z

Content type: article

Language: en

Sources: [Craft Better Software](<https://devfeed.tech/sources/craft-better-software.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [culture](<https://devfeed.tech/tags/culture.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>)

### AI overview

This article presents five code review practices for teams working in the age of AI: give kind feedback, focus on the core purpose and risks of a change, make non-blocking nitpick suggestions, and use mutation testing to identify missing tests and assertions.

### Source excerpt

5 Essential Tips for Doing Code Reviews in the Age of AI

## How I use Mutation Testing to Drive Good Test Case Coverage

DevFeed: [How I use Mutation Testing to Drive Good Test Case Coverage](<https://devfeed.tech/articles/how-i-use-mutation-testing-to-drive-good-test-case-coverage-24832.md>)

Original publisher: [Read original article](<https://akjaw.com/using-mutation-testing-for-good-test-coverage/>)

Author: Aleksander Jaworski

Published: 2023-12-05T15:05:18Z

Content type: tutorial

Language: en

Sources: [AKJAW](<https://devfeed.tech/sources/akjaw.md>)

Topics: [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Test coverage](<https://devfeed.tech/topics/coverage.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [development](<https://devfeed.tech/tags/development.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The article explains how mutation testing evaluates test suites by changing production code logic. If tests still pass after a mutation, the test suite may be missing a case that detects the change.

### Source excerpt

Automated testing is important for efficient software development, catching bugs within minutes and saving valuable developer time. Mutation Testing validates test suites by altering production code logic. When tests pass despite code mutations, it signals missing test cases.

## Stop rerunning your tests

DevFeed: [Stop rerunning your tests](<https://devfeed.tech/articles/stop-rerunning-your-tests-24695.md>)

Original publisher: [Read original article](<https://blog.gradle.org/stop-rerunning-tests>)

Author: Stefan Oehme

Published: 2018-09-08T04:00:00Z

Content type: opinion

Language: en

Sources: [The Gradle Blog](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [features](<https://devfeed.tech/tags/features.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

This article explains why unnecessary test reruns waste development time and how Gradle's build cache and incremental build features can skip tests when their inputs have not changed. It recommends modeling non-deterministic inputs explicitly, including random seeds for randomized and mutation tests.

### Source excerpt

Tests are usually the longest running operation in your development process. Running them unnecessarily is the ultimate time waster. Gradle helps you avoid this cost with its build cache and incremental build features. It knows when any of your test inputs, like your code, your dependencies or system properties, have changed. If everything stays the same, Gradle will skip the test run, saving you a lot of time. So you can imagine my desperation when I see snippets like this on StackOverflow: tasks.withType(Test) { outputs.upToDateWhen { false } } Let's talk about what this means and why it is a bad idea. Communicating intent The above snippet just says "Never reuse this test's output". But why? Is it because there is some hidden input that Gradle doesn't know about? Or is it because the test produces random outputs? The reader can't tell. Deterministic tests don't need reruns "Insanity is doing the same thing over and over and expecting different results" - Not Albert Einstein The vast majority of your tests should be deterministic, i.e. given the same inputs they should produce the same result. If this is not the case, your project is in serious trouble. Stop reading this post and start fixing your code! Rerunning deterministic tests is a waste of your team's time. Non-deterministic tests There are a few reasons why you might want to rerun some tests in some cases even though none of the code changed. In these cases, you should model the additional input properly. Tell Gradle what exactly makes your tests non-deterministic. Randomized tests Some tests use randomization to improve the quality of your software. Random testing can be used to ensure that the production code can handle all kinds of inputs, not just the ones that the developer came up with. Mutation testing changes the production code in subtle way (e.g. introducing off-by-one errors) and checks whether your test suite catches these mistakes. Make this randomization explicit by making the random seed an