[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-dotnet-test-gap-analysis":3,"mdc--vpi3zz-key":34,"related-repo-dotnet-test-gap-analysis":3394,"related-org-dotnet-test-gap-analysis":3500},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":22,"repoUrl":23,"updatedAt":24,"license":25,"forks":26,"topics":27,"repo":29,"sourceUrl":32,"mdContent":33},"test-gap-analysis","perform pseudo-mutation analysis for test gaps","Performs pseudo-mutation analysis on production code in any language to find gaps in existing tests. Use when the user asks to find weak or shallow tests, discover untested edge cases, or check whether tests would catch a bug — e.g. \"would my tests catch it if someone changed the code\", \"would a subtle logic or boundary change slip past the current tests\", \"are my tests strong enough to catch a subtle bug\". Evaluates test effectiveness through mutation-style reasoning: analyzes mutation points (boundaries, boolean flips, null returns, exception removal, arithmetic changes) and checks whether tests would detect each. Polyglot: .NET, Python, TS\u002FJS, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, C++. DO NOT USE FOR: writing new tests (use code-testing-agent, or writing-mstest-tests for MSTest), detecting anti-patterns (use test-anti-patterns), measuring assertion diversity (use assertion-quality), or running actual mutation testing tools (Stryker, mutmut, PIT, cargo-mutants).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},"dotnet",".NET (Microsoft)","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fdotnet.png",[12,16,19],{"name":13,"slug":14,"type":15},"QA","qa","tag",{"name":17,"slug":18,"type":15},"Code Analysis","code-analysis",{"name":20,"slug":21,"type":15},"Testing","testing",4576,"https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fskills","2026-08-01T05:42:23.171686","MIT",332,[28],"agent-skills",{"repoUrl":23,"stars":22,"forks":26,"topics":30,"description":31},[28],"Repository for skills to assist AI coding agents with .NET and C#","https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fskills\u002Ftree\u002FHEAD\u002Fplugins\u002Fdotnet-test\u002Fskills\u002Ftest-gap-analysis","---\nname: test-gap-analysis\ndescription: \"Performs pseudo-mutation analysis on production code in any language to find gaps in existing tests. Use when the user asks to find weak or shallow tests, discover untested edge cases, or check whether tests would catch a bug — e.g. \\\"would my tests catch it if someone changed the code\\\", \\\"would a subtle logic or boundary change slip past the current tests\\\", \\\"are my tests strong enough to catch a subtle bug\\\". Evaluates test effectiveness through mutation-style reasoning: analyzes mutation points (boundaries, boolean flips, null returns, exception removal, arithmetic changes) and checks whether tests would detect each. Polyglot: .NET, Python, TS\u002FJS, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, C++. DO NOT USE FOR: writing new tests (use code-testing-agent, or writing-mstest-tests for MSTest), detecting anti-patterns (use test-anti-patterns), measuring assertion diversity (use assertion-quality), or running actual mutation testing tools (Stryker, mutmut, PIT, cargo-mutants).\"\nlicense: MIT\n---\n\n# Test Gap Analysis via Pseudo-Mutation\n\nAnalyze production code in any supported language by reasoning about hypothetical mutations, then confirming them against the real test suite. This reveals blind spots where tests pass but would continue to pass even if the code were broken.\n\n> **Language-specific guidance**: Call the `test-analysis-extensions` skill to discover available extension files, then read the file matching the target codebase (e.g., `extensions\u002Fdotnet.md`, `extensions\u002Fpython.md`, `extensions\u002Ftypescript.md`). The extension file helps you find test files, recognize framework-specific assertion APIs, and identify language-specific null\u002FNone\u002Fnil patterns and error-handling idioms that map to the mutation catalog below.\n\n## Why Pseudo-Mutation Matters\n\nCode coverage tells you what code ran during tests. It does **not** tell you whether tests would fail if that code were wrong. A method can have 100% line coverage but zero tests that would catch a sign flip, an off-by-one error, or a removed null check.\n\nPseudo-mutation analysis asks: _\"If I changed this line, would any test fail?\"_ When the answer is \"no,\" you've found a test gap.\n\n| Coverage Metric | What It Measures | What It Misses |\n|----------------|-----------------|----------------|\n| Line coverage | Which lines executed | Whether assertions verify those lines' behavior |\n| Branch coverage | Which branches taken | Whether both branches produce different asserted outcomes |\n| **Mutation score** | Whether tests detect code changes | Nothing — this is the gold standard |\n\nThis skill uses **static pseudo-mutation** to find mutation candidates at the speed of code review, then **confirms each reported survivor by actually applying it and re-running the covering tests** (Step 4b). Reasoning finds the candidates; execution decides the verdict.\n\n## When to Use\n\n- User asks \"would my tests catch a bug in this code?\"\n- User wants to find weak or shallow tests\n- User wants to evaluate test effectiveness beyond coverage\n- User asks for mutation testing or mutation analysis\n- User asks \"where are my tests blind?\"\n- User wants to prioritize which tests to strengthen\n- The `code-testing-generator` agent (or any test-generation workflow) calls this skill as a pre-completion self-review step on freshly generated tests, before declaring the run finished\n\n## When Not to Use\n\n- User wants to write new tests from scratch (use `code-testing-agent` for any language, or `writing-mstest-tests` for MSTest specifically)\n- User wants to detect test anti-patterns like flakiness or poor naming (use `test-anti-patterns`)\n- User wants to measure assertion variety (use `assertion-quality`)\n- User wants to run an actual mutation testing framework (Stryker for .NET\u002FJS\u002FTS, mutmut for Python, PIT for Java, go-mutesting for Go, cargo-mutants for Rust, mutant for Ruby) — help them directly with the tool\n- User only wants code coverage numbers (out of scope)\n\n## Inputs\n\n| Input | Required | Description |\n|-------|----------|-------------|\n| Production code | Yes | The source files to analyze for mutation points |\n| Test code | Yes | The test files that cover the production code |\n| Focus area | No | A specific mutation category or code region to focus on |\n\n## Workflow\n\n### Step 1: Detect language and load extension\n\nIdentify the target codebase's language and test framework. Call the `test-analysis-extensions` skill and read the matching extension file. The mutation catalog below uses language-neutral concepts; the extension file tells you how each concept maps in the language you are analyzing (e.g., `null` vs `None` vs `nil` vs `undefined`, `throw` vs `raise` vs `panic!` vs `return err`).\n\n### Step 2: Gather production and test code\n\nRead both the production code and its corresponding test files. If the user points to a directory, identify production\u002Ftest pairs by convention — defaults differ by language: `.cs` ↔ `*Tests.cs`\u002F`*.Tests.cs` (.NET), `foo.py` ↔ `test_foo.py`\u002F`foo_test.py` (Python), `foo.ts` ↔ `foo.test.ts`\u002F`foo.spec.ts` (JS\u002FTS), `Foo.java` ↔ `FooTest.java`\u002F`FooTests.java` (Java), `foo.go` ↔ `foo_test.go` (Go), `foo.rb` ↔ `foo_spec.rb`\u002F`test_foo.rb` (Ruby), `lib.rs` ↔ inline `#[cfg(test)] mod tests` or `tests\u002Ffoo.rs` (Rust), `Foo.swift` ↔ `FooTests.swift` (Swift), `Foo.kt` ↔ `FooTest.kt`\u002F`FooSpec.kt` (Kotlin), `Foo.ps1` ↔ `Foo.Tests.ps1` (Pester), `foo.cpp` ↔ `foo_test.cpp`\u002F`test_foo.cpp` (C++).\n\nEstablish which production methods are exercised by which test methods — trace this through method calls in test code, setup, helper methods, and shared examples.\n\n### Step 3: Identify mutation points\n\nScan the production code and annotate every location where a mutation could reveal a test gap. Use the mutation catalog below.\n\n#### Boundary Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `\u003C` | `\u003C=` | Off-by-one at upper bound |\n| `>` | `>=` | Off-by-one at lower bound |\n| `\u003C=` | `\u003C` | Boundary inclusion |\n| `>=` | `>` | Boundary inclusion |\n| `== 0` | `== 1` or `\u003C= 0` | Zero-boundary handling |\n| `i \u003C length` | `i \u003C length - 1` or `i \u003C= length` | Loop boundary |\n| `index + 1` | `index` or `index + 2` | Index arithmetic |\n\n#### Boolean and Logic Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `&&` | `\\|\\|` | Condition independence |\n| `\\|\\|` | `&&` | Condition necessity |\n| `!condition` | `condition` | Negation correctness |\n| `if (x)` | `if (!x)` | Branch selection |\n| `true` (constant) | `false` | Hardcoded assumption |\n| `flag \\|\\| other` | `other` | Short-circuit first operand |\n\n#### Return Value Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `return result` | `return null` \u002F `return None` \u002F `return nil` \u002F `return undefined` | Null\u002FNone\u002Fnil handling downstream |\n| `return result` | `return default(T)` \u002F `return T()` \u002F `return \"\"` \u002F `return 0` | Default value handling |\n| `return true` | `return false` | Boolean return verification |\n| `return list` | `return new List\u003CT>()` \u002F `return []` \u002F `return Array.Empty\u003CT>()` \u002F `return make([]T, 0)` \u002F `return Vec::new()` \u002F `return @[]` | Empty collection handling |\n| `return count` | `return 0` or `return count + 1` | Numeric return verification |\n| `return string` | `return \"\"` or `return null`\u002F`None`\u002F`nil` | String return verification |\n| `return Ok(x)` | `return Err(...)` (Rust) | Result\u002Ferror variant |\n| `return value, nil` | `return zero, err` (Go) | Error tuple |\n\n#### Exception \u002F Error Removal Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `throw new ArgumentNullException(...)` (.NET) \u002F `raise ValueError(...)` (Python) \u002F `throw new Error(...)` (JS) \u002F `throw new IllegalArgumentException(...)` (Java) \u002F `panic!(...)` (Rust) \u002F `panic(...)` (Go) \u002F `raise ArgumentError` (Ruby) \u002F `throw RuntimeException(...)` (Kotlin) \u002F `throw FooError.bar` (Swift) \u002F `throw \"...\"` (Pester) \u002F `throw std::invalid_argument(...)` (C++) | _(remove entire throw\u002Fraise\u002Fpanic)_ | Guard clause verification |\n| `if (x == null) throw ...` \u002F `if x is None: raise ...` \u002F `if (!x) throw ...` \u002F `if x == nil { return err }` (Go) \u002F `assert!(x.is_some())` (Rust) | _(remove entire guard)_ | Null\u002FNone\u002Fnil guard testing |\n| `if (!IsValid()) throw ...` \u002F `if not is_valid(): raise ...` \u002F etc. | _(remove entire check)_ | Validation testing |\n| `return err` after error check (Go) | _(remove or swallow error)_ | Error propagation |\n| `?` operator (Rust) | `.unwrap()` or `.expect(...)` | Error short-circuit |\n\n#### Arithmetic Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `a + b` | `a - b` | Addition correctness |\n| `a - b` | `a + b` | Subtraction correctness |\n| `a * b` | `a \u002F b` | Multiplication correctness |\n| `a \u002F b` | `a * b` | Division correctness |\n| `a % b` | `a \u002F b` | Modulo correctness |\n| `x++` | `x--` | Increment direction |\n| `-value` | `value` | Sign flip |\n\n#### Null \u002F None \u002F Nil-Check Removal Mutations\n\n| Original | Mutation | What it tests |\n|----------|----------|---------------|\n| `if (x == null) return ...` \u002F `if x is None: return ...` \u002F `if (!x) return ...` \u002F `if x == nil { return ... }` \u002F `unless x; return; end` (Ruby) \u002F `if x.is_none() { return ... }` (Rust) | _(remove null\u002FNone\u002Fnil check)_ | Null path coverage |\n| `if (x != null) { ... }` \u002F `if x is not None: ...` \u002F `if x: ...` \u002F `if x != nil { ... }` \u002F `x?.let { ... }` (Kotlin) \u002F `if let Some(x) = ... { ... }` (Rust) | _(always enter block)_ | Null\u002FNone\u002Fnil guard necessity |\n| `x ?? defaultValue` (.NET\u002FJS\u002FSwift) \u002F `x or defaultValue` (Python) \u002F `x \\|\\| defaultValue` (JS) \u002F `x.unwrap_or(defaultValue)` (Rust) \u002F `x \\|\\| defaultValue` (Kotlin: `x ?: defaultValue`) | `x` (drop coalescing) | Null coalescing coverage |\n| `x?.Method()` (.NET\u002FSwift\u002FKotlin) \u002F `x && x.method()` (JS) \u002F `x and x.method()` (Python) | `x.Method()` | Null-conditional coverage |\n| `x!` (.NET\u002FTS\u002FSwift) \u002F `x!!` (Kotlin) \u002F `.unwrap()` (Rust) | `x` | Null-forgiving \u002F unwrap necessity |\n\n### Step 4: Evaluate each mutation against tests\n\nFor each identified mutation point, reason about whether existing tests would detect the change:\n\n1. **Find covering tests** — Which test methods exercise the mutated line? Follow call chains through helpers and setup methods.\n2. **Check assertion relevance** — Do those tests assert something that would change if the mutation were applied? A test that calls the method but only asserts an unrelated property would NOT catch the mutation.\n3. **Classify the mutation** as:\n\n| Verdict | Meaning | Action |\n|---------|---------|--------|\n| **Killed** | At least one test would fail if this mutation were applied | No action needed — tests are effective here |\n| **Survived** | No test would fail — the mutation would go undetected | This is a test gap — recommend a test improvement |\n| **No coverage** | No test exercises this code path at all | Worse than survived — the code is untested |\n| **Equivalent** | The mutation produces identical behavior (e.g., `x * 1` → `x \u002F 1`) | Skip — not a real mutation |\n\n### Step 4b: Verify every reported survivor by running the tests\n\nStatic reasoning alone produces false \"survived\" verdicts — the most common failure of this skill is telling a user their tests are weak when the tests actually catch the bug. **If the suite can be built and run, verify before you report.**\n\n1. **Establish a green baseline.** Run the suite (`dotnet test`, `pytest`, `npm test`, `go test .\u002F...`, `cargo test`, …). Record the pass count. If it does not build or run, fix only obvious wiring problems (missing project reference, wrong runner arguments) — never rewrite production behavior.\n2. **Apply each candidate survivor as a real edit**, one at a time, to the production file.\n3. **Re-run the narrowest covering test(s).** Still green ⇒ genuinely **Survived**. Now red ⇒ **Killed**; drop it from the findings.\n4. **Revert immediately** after each check, and confirm the suite is green again before finishing. Never leave a mutation in the working tree.\n5. **Report what you did**: state that survivors were empirically confirmed and give the observed kill count (e.g. \"8 of 9 injected mutations were caught\").\n\nWhen the suite genuinely cannot be executed (no toolchain, no network, compile errors you must not fix), fall back to reasoning — but label every finding **unverified (static reasoning)**, and downgrade its confidence rather than presenting it as a proven gap.\n\n### Step 5: Calibrate findings\n\nBefore reporting, apply these calibration rules:\n\n- **Don't flag trivial code.** Simple property getters (`return _name;`), auto-properties, and boilerplate don't need mutation analysis. Focus on logic, conditions, calculations, and error handling.\n- **Consider defensive depth.** If a null guard has a survived mutation but the caller also checks for null, note the redundancy but rate it lower priority.\n- **Equivalent mutations are not gaps.** If changing `>=` to `>` doesn't alter behavior because the `==` case is impossible given the domain, mark it Equivalent and skip.\n- **Private methods reached through public API are valid targets.** Trace through the call chain — a private method called from a tested public method may still have survived mutations if the test doesn't assert the specific behavior affected.\n- **Rate by risk, not count.** A single survived mutation in payment calculation logic is more important than five survived mutations in logging code.\n- **When most mutations are killed, lead with that.** A strong suite with one or two minor survivors is a good result: say \"the tests are strong\" first and present the survivors as minor improvements. Do not attach \"critical\" \u002F \"HIGH RISK\" framing to a suite that kills the substantive mutations.\n- **Never claim a gap you did not verify.** If Step 4b confirmed the mutation is caught, it is not a finding. Prefer under-claiming: a missed gap costs the user far less than a false alarm that sends them writing redundant tests.\n\n### Step 6: Report findings\n\nPresent the analysis in this structure:\n\n1. **Summary** — Overall mutation score and key findings:\n   ```\n   | Metric              | Value    |\n   |---------------------|----------|\n   | Mutation points      | 42       |\n   | Killed               | 28 (67%) |\n   | Survived             | 10 (24%) |\n   | No coverage          | 2 (5%)   |\n   | Equivalent (skipped) | 2 (5%)   |\n   ```\n\n2. **Survived Mutations (Test Gaps)** — For each survived mutation, report:\n   - **Location**: File, method, line\n   - **Mutation category**: Boundary \u002F Boolean \u002F Return value \u002F Exception \u002F Arithmetic \u002F Null-check\n   - **Original code**: The current code\n   - **Hypothetical mutation**: What would change\n   - **Why it survives**: Which tests cover this code and why their assertions miss it\n   - **Recommended fix**: A concrete test assertion or new test case that would kill this mutation\n\n   Group by priority: high-risk survived mutations first (business logic, calculations, security checks), lower-risk last (logging, formatting).\n\n3. **No-Coverage Zones** — Code paths that no test reaches at all. These are worse than survived mutations.\n\n4. **Killed Mutations (Strengths)** — Briefly note areas where tests are effective. Highlight well-tested methods and strong assertion patterns. Don't enumerate every killed mutation — summarize.\n\n5. **Recommendations** — Prioritized list:\n   - Which survived mutations to address first (by risk)\n   - Specific test methods to add or strengthen\n   - Patterns the team can adopt to prevent future gaps (e.g., always test boundary values, always assert exception types)\n\n## Validation\n\n- [ ] The suite was run and every reported survivor was empirically confirmed (or all findings are explicitly labelled unverified)\n- [ ] All applied mutations were reverted and the suite is green again\n- [ ] Every mutation point was classified (Killed \u002F Survived \u002F No coverage \u002F Equivalent)\n- [ ] Every survived mutation includes the original code, the hypothetical change, and why tests miss it\n- [ ] Every survived mutation includes a concrete recommended fix (a test assertion or test case)\n- [ ] Equivalent mutations are correctly identified and excluded from the score\n- [ ] Trivial code (simple getters, auto-properties) is excluded from analysis\n- [ ] Findings are prioritized by risk, not just listed in source order\n- [ ] Report includes strengths (killed mutations) alongside gaps\n- [ ] Mutation categories are correctly labeled\n\n## Common Pitfalls\n\n| Pitfall | Solution |\n|---------|----------|\n| Reporting survivors you never ran | Apply the mutation, re-run the covering tests, revert. An unverified \"survived\" claim that the tests actually kill is worse than no analysis |\n| Overstating severity on a strong suite | If the substantive mutations are killed, open with \"tests are strong\" and frame the remainder as minor improvements |\n| Publishing your reasoning as it changes | Settle the verdict first; never emit \"wait, no… this is killed… let me recalibrate\" in the report |\n| Leaving a mutation applied | Revert every edit and re-run the suite before reporting |\n| Analyzing trivial code | Skip auto-properties, simple getters, `@dataclass`\u002F`record`\u002F`data class` accessors, `#[derive]` impls — focus on logic |\n| Reporting equivalent mutations as gaps | If the mutation doesn't change behavior, it's not a gap — mark Equivalent |\n| Ignoring call chains | A private\u002Finternal\u002Funexported helper called from a tested public method is reachable — trace the chain |\n| Over-counting mutations in generated code | Skip auto-generated code (`*.g.cs`, `*.designer.cs`, `*_pb.go`, `*.pb.dart`), designer files, migration files, generated mocks\u002Fstubs |\n| Recommending a new test for every survived mutation | Multiple survived mutations in the same method often share a single missing test — recommend one test that kills several |\n| Ignoring production context | A survived mutation in `ToString()` \u002F `__repr__` \u002F `toString()` formatting is less important than one in `CalculateTotal()` — prioritize by business risk |\n| Claiming 100% kill rate is required | Some mutations in low-risk code are acceptable to leave — acknowledge this in the report |\n| Not considering integration with other skills | If gaps are found, mention that `code-testing-agent` (any language) or `writing-mstest-tests` (MSTest-specific) can help write the missing tests, and `test-anti-patterns` can audit existing test quality |\n| Forgetting Go's error idiom | Removing `if err != nil { return err }` is a valid mutation target only when the function actually does something else with `err` (e.g., wrap, log, branch). Bare passthroughs in idiomatic Go are not meaningful gaps. |\n| Forgetting Rust's `?` operator | `?` propagates `Err`\u002F`None` short-circuits. Mutating `expr?` → `expr.unwrap()` panics instead of returning — flag as Exception\u002FPanic mutation when tests should observe the propagated error. |\n",{"data":35,"body":36},{"name":4,"description":6,"license":25},{"type":37,"children":38},"root",[39,48,54,101,108,120,133,223,242,248,296,302,361,367,447,453,460,530,536,766,771,777,782,789,1014,1020,1200,1206,1542,1548,1828,1834,2035,2041,2335,2341,2346,2380,2506,2512,2522,2623,2635,2641,2646,2749,2755,2760,2912,2918,3017,3023],{"type":40,"tag":41,"props":42,"children":44},"element","h1",{"id":43},"test-gap-analysis-via-pseudo-mutation",[45],{"type":46,"value":47},"text","Test Gap Analysis via Pseudo-Mutation",{"type":40,"tag":49,"props":50,"children":51},"p",{},[52],{"type":46,"value":53},"Analyze production code in any supported language by reasoning about hypothetical mutations, then confirming them against the real test suite. This reveals blind spots where tests pass but would continue to pass even if the code were broken.",{"type":40,"tag":55,"props":56,"children":57},"blockquote",{},[58],{"type":40,"tag":49,"props":59,"children":60},{},[61,67,69,76,78,84,86,92,93,99],{"type":40,"tag":62,"props":63,"children":64},"strong",{},[65],{"type":46,"value":66},"Language-specific guidance",{"type":46,"value":68},": Call the ",{"type":40,"tag":70,"props":71,"children":73},"code",{"className":72},[],[74],{"type":46,"value":75},"test-analysis-extensions",{"type":46,"value":77}," skill to discover available extension files, then read the file matching the target codebase (e.g., ",{"type":40,"tag":70,"props":79,"children":81},{"className":80},[],[82],{"type":46,"value":83},"extensions\u002Fdotnet.md",{"type":46,"value":85},", ",{"type":40,"tag":70,"props":87,"children":89},{"className":88},[],[90],{"type":46,"value":91},"extensions\u002Fpython.md",{"type":46,"value":85},{"type":40,"tag":70,"props":94,"children":96},{"className":95},[],[97],{"type":46,"value":98},"extensions\u002Ftypescript.md",{"type":46,"value":100},"). The extension file helps you find test files, recognize framework-specific assertion APIs, and identify language-specific null\u002FNone\u002Fnil patterns and error-handling idioms that map to the mutation catalog below.",{"type":40,"tag":102,"props":103,"children":105},"h2",{"id":104},"why-pseudo-mutation-matters",[106],{"type":46,"value":107},"Why Pseudo-Mutation Matters",{"type":40,"tag":49,"props":109,"children":110},{},[111,113,118],{"type":46,"value":112},"Code coverage tells you what code ran during tests. It does ",{"type":40,"tag":62,"props":114,"children":115},{},[116],{"type":46,"value":117},"not",{"type":46,"value":119}," tell you whether tests would fail if that code were wrong. A method can have 100% line coverage but zero tests that would catch a sign flip, an off-by-one error, or a removed null check.",{"type":40,"tag":49,"props":121,"children":122},{},[123,125,131],{"type":46,"value":124},"Pseudo-mutation analysis asks: ",{"type":40,"tag":126,"props":127,"children":128},"em",{},[129],{"type":46,"value":130},"\"If I changed this line, would any test fail?\"",{"type":46,"value":132}," When the answer is \"no,\" you've found a test gap.",{"type":40,"tag":134,"props":135,"children":136},"table",{},[137,161],{"type":40,"tag":138,"props":139,"children":140},"thead",{},[141],{"type":40,"tag":142,"props":143,"children":144},"tr",{},[145,151,156],{"type":40,"tag":146,"props":147,"children":148},"th",{},[149],{"type":46,"value":150},"Coverage Metric",{"type":40,"tag":146,"props":152,"children":153},{},[154],{"type":46,"value":155},"What It Measures",{"type":40,"tag":146,"props":157,"children":158},{},[159],{"type":46,"value":160},"What It Misses",{"type":40,"tag":162,"props":163,"children":164},"tbody",{},[165,184,202],{"type":40,"tag":142,"props":166,"children":167},{},[168,174,179],{"type":40,"tag":169,"props":170,"children":171},"td",{},[172],{"type":46,"value":173},"Line coverage",{"type":40,"tag":169,"props":175,"children":176},{},[177],{"type":46,"value":178},"Which lines executed",{"type":40,"tag":169,"props":180,"children":181},{},[182],{"type":46,"value":183},"Whether assertions verify those lines' behavior",{"type":40,"tag":142,"props":185,"children":186},{},[187,192,197],{"type":40,"tag":169,"props":188,"children":189},{},[190],{"type":46,"value":191},"Branch coverage",{"type":40,"tag":169,"props":193,"children":194},{},[195],{"type":46,"value":196},"Which branches taken",{"type":40,"tag":169,"props":198,"children":199},{},[200],{"type":46,"value":201},"Whether both branches produce different asserted outcomes",{"type":40,"tag":142,"props":203,"children":204},{},[205,213,218],{"type":40,"tag":169,"props":206,"children":207},{},[208],{"type":40,"tag":62,"props":209,"children":210},{},[211],{"type":46,"value":212},"Mutation score",{"type":40,"tag":169,"props":214,"children":215},{},[216],{"type":46,"value":217},"Whether tests detect code changes",{"type":40,"tag":169,"props":219,"children":220},{},[221],{"type":46,"value":222},"Nothing — this is the gold standard",{"type":40,"tag":49,"props":224,"children":225},{},[226,228,233,235,240],{"type":46,"value":227},"This skill uses ",{"type":40,"tag":62,"props":229,"children":230},{},[231],{"type":46,"value":232},"static pseudo-mutation",{"type":46,"value":234}," to find mutation candidates at the speed of code review, then ",{"type":40,"tag":62,"props":236,"children":237},{},[238],{"type":46,"value":239},"confirms each reported survivor by actually applying it and re-running the covering tests",{"type":46,"value":241}," (Step 4b). Reasoning finds the candidates; execution decides the verdict.",{"type":40,"tag":102,"props":243,"children":245},{"id":244},"when-to-use",[246],{"type":46,"value":247},"When to Use",{"type":40,"tag":249,"props":250,"children":251},"ul",{},[252,258,263,268,273,278,283],{"type":40,"tag":253,"props":254,"children":255},"li",{},[256],{"type":46,"value":257},"User asks \"would my tests catch a bug in this code?\"",{"type":40,"tag":253,"props":259,"children":260},{},[261],{"type":46,"value":262},"User wants to find weak or shallow tests",{"type":40,"tag":253,"props":264,"children":265},{},[266],{"type":46,"value":267},"User wants to evaluate test effectiveness beyond coverage",{"type":40,"tag":253,"props":269,"children":270},{},[271],{"type":46,"value":272},"User asks for mutation testing or mutation analysis",{"type":40,"tag":253,"props":274,"children":275},{},[276],{"type":46,"value":277},"User asks \"where are my tests blind?\"",{"type":40,"tag":253,"props":279,"children":280},{},[281],{"type":46,"value":282},"User wants to prioritize which tests to strengthen",{"type":40,"tag":253,"props":284,"children":285},{},[286,288,294],{"type":46,"value":287},"The ",{"type":40,"tag":70,"props":289,"children":291},{"className":290},[],[292],{"type":46,"value":293},"code-testing-generator",{"type":46,"value":295}," agent (or any test-generation workflow) calls this skill as a pre-completion self-review step on freshly generated tests, before declaring the run finished",{"type":40,"tag":102,"props":297,"children":299},{"id":298},"when-not-to-use",[300],{"type":46,"value":301},"When Not to Use",{"type":40,"tag":249,"props":303,"children":304},{},[305,326,339,351,356],{"type":40,"tag":253,"props":306,"children":307},{},[308,310,316,318,324],{"type":46,"value":309},"User wants to write new tests from scratch (use ",{"type":40,"tag":70,"props":311,"children":313},{"className":312},[],[314],{"type":46,"value":315},"code-testing-agent",{"type":46,"value":317}," for any language, or ",{"type":40,"tag":70,"props":319,"children":321},{"className":320},[],[322],{"type":46,"value":323},"writing-mstest-tests",{"type":46,"value":325}," for MSTest specifically)",{"type":40,"tag":253,"props":327,"children":328},{},[329,331,337],{"type":46,"value":330},"User wants to detect test anti-patterns like flakiness or poor naming (use ",{"type":40,"tag":70,"props":332,"children":334},{"className":333},[],[335],{"type":46,"value":336},"test-anti-patterns",{"type":46,"value":338},")",{"type":40,"tag":253,"props":340,"children":341},{},[342,344,350],{"type":46,"value":343},"User wants to measure assertion variety (use ",{"type":40,"tag":70,"props":345,"children":347},{"className":346},[],[348],{"type":46,"value":349},"assertion-quality",{"type":46,"value":338},{"type":40,"tag":253,"props":352,"children":353},{},[354],{"type":46,"value":355},"User wants to run an actual mutation testing framework (Stryker for .NET\u002FJS\u002FTS, mutmut for Python, PIT for Java, go-mutesting for Go, cargo-mutants for Rust, mutant for Ruby) — help them directly with the tool",{"type":40,"tag":253,"props":357,"children":358},{},[359],{"type":46,"value":360},"User only wants code coverage numbers (out of scope)",{"type":40,"tag":102,"props":362,"children":364},{"id":363},"inputs",[365],{"type":46,"value":366},"Inputs",{"type":40,"tag":134,"props":368,"children":369},{},[370,391],{"type":40,"tag":138,"props":371,"children":372},{},[373],{"type":40,"tag":142,"props":374,"children":375},{},[376,381,386],{"type":40,"tag":146,"props":377,"children":378},{},[379],{"type":46,"value":380},"Input",{"type":40,"tag":146,"props":382,"children":383},{},[384],{"type":46,"value":385},"Required",{"type":40,"tag":146,"props":387,"children":388},{},[389],{"type":46,"value":390},"Description",{"type":40,"tag":162,"props":392,"children":393},{},[394,412,429],{"type":40,"tag":142,"props":395,"children":396},{},[397,402,407],{"type":40,"tag":169,"props":398,"children":399},{},[400],{"type":46,"value":401},"Production code",{"type":40,"tag":169,"props":403,"children":404},{},[405],{"type":46,"value":406},"Yes",{"type":40,"tag":169,"props":408,"children":409},{},[410],{"type":46,"value":411},"The source files to analyze for mutation points",{"type":40,"tag":142,"props":413,"children":414},{},[415,420,424],{"type":40,"tag":169,"props":416,"children":417},{},[418],{"type":46,"value":419},"Test code",{"type":40,"tag":169,"props":421,"children":422},{},[423],{"type":46,"value":406},{"type":40,"tag":169,"props":425,"children":426},{},[427],{"type":46,"value":428},"The test files that cover the production code",{"type":40,"tag":142,"props":430,"children":431},{},[432,437,442],{"type":40,"tag":169,"props":433,"children":434},{},[435],{"type":46,"value":436},"Focus area",{"type":40,"tag":169,"props":438,"children":439},{},[440],{"type":46,"value":441},"No",{"type":40,"tag":169,"props":443,"children":444},{},[445],{"type":46,"value":446},"A specific mutation category or code region to focus on",{"type":40,"tag":102,"props":448,"children":450},{"id":449},"workflow",[451],{"type":46,"value":452},"Workflow",{"type":40,"tag":454,"props":455,"children":457},"h3",{"id":456},"step-1-detect-language-and-load-extension",[458],{"type":46,"value":459},"Step 1: Detect language and load extension",{"type":40,"tag":49,"props":461,"children":462},{},[463,465,470,472,478,480,486,487,493,494,500,501,507,508,514,515,521,522,528],{"type":46,"value":464},"Identify the target codebase's language and test framework. Call the ",{"type":40,"tag":70,"props":466,"children":468},{"className":467},[],[469],{"type":46,"value":75},{"type":46,"value":471}," skill and read the matching extension file. The mutation catalog below uses language-neutral concepts; the extension file tells you how each concept maps in the language you are analyzing (e.g., ",{"type":40,"tag":70,"props":473,"children":475},{"className":474},[],[476],{"type":46,"value":477},"null",{"type":46,"value":479}," vs ",{"type":40,"tag":70,"props":481,"children":483},{"className":482},[],[484],{"type":46,"value":485},"None",{"type":46,"value":479},{"type":40,"tag":70,"props":488,"children":490},{"className":489},[],[491],{"type":46,"value":492},"nil",{"type":46,"value":479},{"type":40,"tag":70,"props":495,"children":497},{"className":496},[],[498],{"type":46,"value":499},"undefined",{"type":46,"value":85},{"type":40,"tag":70,"props":502,"children":504},{"className":503},[],[505],{"type":46,"value":506},"throw",{"type":46,"value":479},{"type":40,"tag":70,"props":509,"children":511},{"className":510},[],[512],{"type":46,"value":513},"raise",{"type":46,"value":479},{"type":40,"tag":70,"props":516,"children":518},{"className":517},[],[519],{"type":46,"value":520},"panic!",{"type":46,"value":479},{"type":40,"tag":70,"props":523,"children":525},{"className":524},[],[526],{"type":46,"value":527},"return err",{"type":46,"value":529},").",{"type":40,"tag":454,"props":531,"children":533},{"id":532},"step-2-gather-production-and-test-code",[534],{"type":46,"value":535},"Step 2: Gather production and test code",{"type":40,"tag":49,"props":537,"children":538},{},[539,541,547,549,555,557,563,565,571,572,578,579,585,587,593,594,600,601,607,609,615,616,622,623,629,631,637,638,644,646,652,653,659,660,666,668,674,676,682,684,690,692,698,699,705,707,713,714,720,721,727,729,735,736,742,744,750,751,757,758,764],{"type":46,"value":540},"Read both the production code and its corresponding test files. If the user points to a directory, identify production\u002Ftest pairs by convention — defaults differ by language: ",{"type":40,"tag":70,"props":542,"children":544},{"className":543},[],[545],{"type":46,"value":546},".cs",{"type":46,"value":548}," ↔ ",{"type":40,"tag":70,"props":550,"children":552},{"className":551},[],[553],{"type":46,"value":554},"*Tests.cs",{"type":46,"value":556},"\u002F",{"type":40,"tag":70,"props":558,"children":560},{"className":559},[],[561],{"type":46,"value":562},"*.Tests.cs",{"type":46,"value":564}," (.NET), ",{"type":40,"tag":70,"props":566,"children":568},{"className":567},[],[569],{"type":46,"value":570},"foo.py",{"type":46,"value":548},{"type":40,"tag":70,"props":573,"children":575},{"className":574},[],[576],{"type":46,"value":577},"test_foo.py",{"type":46,"value":556},{"type":40,"tag":70,"props":580,"children":582},{"className":581},[],[583],{"type":46,"value":584},"foo_test.py",{"type":46,"value":586}," (Python), ",{"type":40,"tag":70,"props":588,"children":590},{"className":589},[],[591],{"type":46,"value":592},"foo.ts",{"type":46,"value":548},{"type":40,"tag":70,"props":595,"children":597},{"className":596},[],[598],{"type":46,"value":599},"foo.test.ts",{"type":46,"value":556},{"type":40,"tag":70,"props":602,"children":604},{"className":603},[],[605],{"type":46,"value":606},"foo.spec.ts",{"type":46,"value":608}," (JS\u002FTS), ",{"type":40,"tag":70,"props":610,"children":612},{"className":611},[],[613],{"type":46,"value":614},"Foo.java",{"type":46,"value":548},{"type":40,"tag":70,"props":617,"children":619},{"className":618},[],[620],{"type":46,"value":621},"FooTest.java",{"type":46,"value":556},{"type":40,"tag":70,"props":624,"children":626},{"className":625},[],[627],{"type":46,"value":628},"FooTests.java",{"type":46,"value":630}," (Java), ",{"type":40,"tag":70,"props":632,"children":634},{"className":633},[],[635],{"type":46,"value":636},"foo.go",{"type":46,"value":548},{"type":40,"tag":70,"props":639,"children":641},{"className":640},[],[642],{"type":46,"value":643},"foo_test.go",{"type":46,"value":645}," (Go), ",{"type":40,"tag":70,"props":647,"children":649},{"className":648},[],[650],{"type":46,"value":651},"foo.rb",{"type":46,"value":548},{"type":40,"tag":70,"props":654,"children":656},{"className":655},[],[657],{"type":46,"value":658},"foo_spec.rb",{"type":46,"value":556},{"type":40,"tag":70,"props":661,"children":663},{"className":662},[],[664],{"type":46,"value":665},"test_foo.rb",{"type":46,"value":667}," (Ruby), ",{"type":40,"tag":70,"props":669,"children":671},{"className":670},[],[672],{"type":46,"value":673},"lib.rs",{"type":46,"value":675}," ↔ inline ",{"type":40,"tag":70,"props":677,"children":679},{"className":678},[],[680],{"type":46,"value":681},"#[cfg(test)] mod tests",{"type":46,"value":683}," or ",{"type":40,"tag":70,"props":685,"children":687},{"className":686},[],[688],{"type":46,"value":689},"tests\u002Ffoo.rs",{"type":46,"value":691}," (Rust), ",{"type":40,"tag":70,"props":693,"children":695},{"className":694},[],[696],{"type":46,"value":697},"Foo.swift",{"type":46,"value":548},{"type":40,"tag":70,"props":700,"children":702},{"className":701},[],[703],{"type":46,"value":704},"FooTests.swift",{"type":46,"value":706}," (Swift), ",{"type":40,"tag":70,"props":708,"children":710},{"className":709},[],[711],{"type":46,"value":712},"Foo.kt",{"type":46,"value":548},{"type":40,"tag":70,"props":715,"children":717},{"className":716},[],[718],{"type":46,"value":719},"FooTest.kt",{"type":46,"value":556},{"type":40,"tag":70,"props":722,"children":724},{"className":723},[],[725],{"type":46,"value":726},"FooSpec.kt",{"type":46,"value":728}," (Kotlin), ",{"type":40,"tag":70,"props":730,"children":732},{"className":731},[],[733],{"type":46,"value":734},"Foo.ps1",{"type":46,"value":548},{"type":40,"tag":70,"props":737,"children":739},{"className":738},[],[740],{"type":46,"value":741},"Foo.Tests.ps1",{"type":46,"value":743}," (Pester), ",{"type":40,"tag":70,"props":745,"children":747},{"className":746},[],[748],{"type":46,"value":749},"foo.cpp",{"type":46,"value":548},{"type":40,"tag":70,"props":752,"children":754},{"className":753},[],[755],{"type":46,"value":756},"foo_test.cpp",{"type":46,"value":556},{"type":40,"tag":70,"props":759,"children":761},{"className":760},[],[762],{"type":46,"value":763},"test_foo.cpp",{"type":46,"value":765}," (C++).",{"type":40,"tag":49,"props":767,"children":768},{},[769],{"type":46,"value":770},"Establish which production methods are exercised by which test methods — trace this through method calls in test code, setup, helper methods, and shared examples.",{"type":40,"tag":454,"props":772,"children":774},{"id":773},"step-3-identify-mutation-points",[775],{"type":46,"value":776},"Step 3: Identify mutation points",{"type":40,"tag":49,"props":778,"children":779},{},[780],{"type":46,"value":781},"Scan the production code and annotate every location where a mutation could reveal a test gap. Use the mutation catalog below.",{"type":40,"tag":783,"props":784,"children":786},"h4",{"id":785},"boundary-mutations",[787],{"type":46,"value":788},"Boundary Mutations",{"type":40,"tag":134,"props":790,"children":791},{},[792,813],{"type":40,"tag":138,"props":793,"children":794},{},[795],{"type":40,"tag":142,"props":796,"children":797},{},[798,803,808],{"type":40,"tag":146,"props":799,"children":800},{},[801],{"type":46,"value":802},"Original",{"type":40,"tag":146,"props":804,"children":805},{},[806],{"type":46,"value":807},"Mutation",{"type":40,"tag":146,"props":809,"children":810},{},[811],{"type":46,"value":812},"What it tests",{"type":40,"tag":162,"props":814,"children":815},{},[816,842,868,892,915,948,981],{"type":40,"tag":142,"props":817,"children":818},{},[819,828,837],{"type":40,"tag":169,"props":820,"children":821},{},[822],{"type":40,"tag":70,"props":823,"children":825},{"className":824},[],[826],{"type":46,"value":827},"\u003C",{"type":40,"tag":169,"props":829,"children":830},{},[831],{"type":40,"tag":70,"props":832,"children":834},{"className":833},[],[835],{"type":46,"value":836},"\u003C=",{"type":40,"tag":169,"props":838,"children":839},{},[840],{"type":46,"value":841},"Off-by-one at upper bound",{"type":40,"tag":142,"props":843,"children":844},{},[845,854,863],{"type":40,"tag":169,"props":846,"children":847},{},[848],{"type":40,"tag":70,"props":849,"children":851},{"className":850},[],[852],{"type":46,"value":853},">",{"type":40,"tag":169,"props":855,"children":856},{},[857],{"type":40,"tag":70,"props":858,"children":860},{"className":859},[],[861],{"type":46,"value":862},">=",{"type":40,"tag":169,"props":864,"children":865},{},[866],{"type":46,"value":867},"Off-by-one at lower bound",{"type":40,"tag":142,"props":869,"children":870},{},[871,879,887],{"type":40,"tag":169,"props":872,"children":873},{},[874],{"type":40,"tag":70,"props":875,"children":877},{"className":876},[],[878],{"type":46,"value":836},{"type":40,"tag":169,"props":880,"children":881},{},[882],{"type":40,"tag":70,"props":883,"children":885},{"className":884},[],[886],{"type":46,"value":827},{"type":40,"tag":169,"props":888,"children":889},{},[890],{"type":46,"value":891},"Boundary inclusion",{"type":40,"tag":142,"props":893,"children":894},{},[895,903,911],{"type":40,"tag":169,"props":896,"children":897},{},[898],{"type":40,"tag":70,"props":899,"children":901},{"className":900},[],[902],{"type":46,"value":862},{"type":40,"tag":169,"props":904,"children":905},{},[906],{"type":40,"tag":70,"props":907,"children":909},{"className":908},[],[910],{"type":46,"value":853},{"type":40,"tag":169,"props":912,"children":913},{},[914],{"type":46,"value":891},{"type":40,"tag":142,"props":916,"children":917},{},[918,927,943],{"type":40,"tag":169,"props":919,"children":920},{},[921],{"type":40,"tag":70,"props":922,"children":924},{"className":923},[],[925],{"type":46,"value":926},"== 0",{"type":40,"tag":169,"props":928,"children":929},{},[930,936,937],{"type":40,"tag":70,"props":931,"children":933},{"className":932},[],[934],{"type":46,"value":935},"== 1",{"type":46,"value":683},{"type":40,"tag":70,"props":938,"children":940},{"className":939},[],[941],{"type":46,"value":942},"\u003C= 0",{"type":40,"tag":169,"props":944,"children":945},{},[946],{"type":46,"value":947},"Zero-boundary handling",{"type":40,"tag":142,"props":949,"children":950},{},[951,960,976],{"type":40,"tag":169,"props":952,"children":953},{},[954],{"type":40,"tag":70,"props":955,"children":957},{"className":956},[],[958],{"type":46,"value":959},"i \u003C length",{"type":40,"tag":169,"props":961,"children":962},{},[963,969,970],{"type":40,"tag":70,"props":964,"children":966},{"className":965},[],[967],{"type":46,"value":968},"i \u003C length - 1",{"type":46,"value":683},{"type":40,"tag":70,"props":971,"children":973},{"className":972},[],[974],{"type":46,"value":975},"i \u003C= length",{"type":40,"tag":169,"props":977,"children":978},{},[979],{"type":46,"value":980},"Loop boundary",{"type":40,"tag":142,"props":982,"children":983},{},[984,993,1009],{"type":40,"tag":169,"props":985,"children":986},{},[987],{"type":40,"tag":70,"props":988,"children":990},{"className":989},[],[991],{"type":46,"value":992},"index + 1",{"type":40,"tag":169,"props":994,"children":995},{},[996,1002,1003],{"type":40,"tag":70,"props":997,"children":999},{"className":998},[],[1000],{"type":46,"value":1001},"index",{"type":46,"value":683},{"type":40,"tag":70,"props":1004,"children":1006},{"className":1005},[],[1007],{"type":46,"value":1008},"index + 2",{"type":40,"tag":169,"props":1010,"children":1011},{},[1012],{"type":46,"value":1013},"Index arithmetic",{"type":40,"tag":783,"props":1015,"children":1017},{"id":1016},"boolean-and-logic-mutations",[1018],{"type":46,"value":1019},"Boolean and Logic Mutations",{"type":40,"tag":134,"props":1021,"children":1022},{},[1023,1041],{"type":40,"tag":138,"props":1024,"children":1025},{},[1026],{"type":40,"tag":142,"props":1027,"children":1028},{},[1029,1033,1037],{"type":40,"tag":146,"props":1030,"children":1031},{},[1032],{"type":46,"value":802},{"type":40,"tag":146,"props":1034,"children":1035},{},[1036],{"type":46,"value":807},{"type":40,"tag":146,"props":1038,"children":1039},{},[1040],{"type":46,"value":812},{"type":40,"tag":162,"props":1042,"children":1043},{},[1044,1070,1094,1120,1146,1174],{"type":40,"tag":142,"props":1045,"children":1046},{},[1047,1056,1065],{"type":40,"tag":169,"props":1048,"children":1049},{},[1050],{"type":40,"tag":70,"props":1051,"children":1053},{"className":1052},[],[1054],{"type":46,"value":1055},"&&",{"type":40,"tag":169,"props":1057,"children":1058},{},[1059],{"type":40,"tag":70,"props":1060,"children":1062},{"className":1061},[],[1063],{"type":46,"value":1064},"||",{"type":40,"tag":169,"props":1066,"children":1067},{},[1068],{"type":46,"value":1069},"Condition independence",{"type":40,"tag":142,"props":1071,"children":1072},{},[1073,1081,1089],{"type":40,"tag":169,"props":1074,"children":1075},{},[1076],{"type":40,"tag":70,"props":1077,"children":1079},{"className":1078},[],[1080],{"type":46,"value":1064},{"type":40,"tag":169,"props":1082,"children":1083},{},[1084],{"type":40,"tag":70,"props":1085,"children":1087},{"className":1086},[],[1088],{"type":46,"value":1055},{"type":40,"tag":169,"props":1090,"children":1091},{},[1092],{"type":46,"value":1093},"Condition necessity",{"type":40,"tag":142,"props":1095,"children":1096},{},[1097,1106,1115],{"type":40,"tag":169,"props":1098,"children":1099},{},[1100],{"type":40,"tag":70,"props":1101,"children":1103},{"className":1102},[],[1104],{"type":46,"value":1105},"!condition",{"type":40,"tag":169,"props":1107,"children":1108},{},[1109],{"type":40,"tag":70,"props":1110,"children":1112},{"className":1111},[],[1113],{"type":46,"value":1114},"condition",{"type":40,"tag":169,"props":1116,"children":1117},{},[1118],{"type":46,"value":1119},"Negation correctness",{"type":40,"tag":142,"props":1121,"children":1122},{},[1123,1132,1141],{"type":40,"tag":169,"props":1124,"children":1125},{},[1126],{"type":40,"tag":70,"props":1127,"children":1129},{"className":1128},[],[1130],{"type":46,"value":1131},"if (x)",{"type":40,"tag":169,"props":1133,"children":1134},{},[1135],{"type":40,"tag":70,"props":1136,"children":1138},{"className":1137},[],[1139],{"type":46,"value":1140},"if (!x)",{"type":40,"tag":169,"props":1142,"children":1143},{},[1144],{"type":46,"value":1145},"Branch selection",{"type":40,"tag":142,"props":1147,"children":1148},{},[1149,1160,1169],{"type":40,"tag":169,"props":1150,"children":1151},{},[1152,1158],{"type":40,"tag":70,"props":1153,"children":1155},{"className":1154},[],[1156],{"type":46,"value":1157},"true",{"type":46,"value":1159}," (constant)",{"type":40,"tag":169,"props":1161,"children":1162},{},[1163],{"type":40,"tag":70,"props":1164,"children":1166},{"className":1165},[],[1167],{"type":46,"value":1168},"false",{"type":40,"tag":169,"props":1170,"children":1171},{},[1172],{"type":46,"value":1173},"Hardcoded assumption",{"type":40,"tag":142,"props":1175,"children":1176},{},[1177,1186,1195],{"type":40,"tag":169,"props":1178,"children":1179},{},[1180],{"type":40,"tag":70,"props":1181,"children":1183},{"className":1182},[],[1184],{"type":46,"value":1185},"flag || other",{"type":40,"tag":169,"props":1187,"children":1188},{},[1189],{"type":40,"tag":70,"props":1190,"children":1192},{"className":1191},[],[1193],{"type":46,"value":1194},"other",{"type":40,"tag":169,"props":1196,"children":1197},{},[1198],{"type":46,"value":1199},"Short-circuit first operand",{"type":40,"tag":783,"props":1201,"children":1203},{"id":1202},"return-value-mutations",[1204],{"type":46,"value":1205},"Return Value Mutations",{"type":40,"tag":134,"props":1207,"children":1208},{},[1209,1227],{"type":40,"tag":138,"props":1210,"children":1211},{},[1212],{"type":40,"tag":142,"props":1213,"children":1214},{},[1215,1219,1223],{"type":40,"tag":146,"props":1216,"children":1217},{},[1218],{"type":46,"value":802},{"type":40,"tag":146,"props":1220,"children":1221},{},[1222],{"type":46,"value":807},{"type":40,"tag":146,"props":1224,"children":1225},{},[1226],{"type":46,"value":812},{"type":40,"tag":162,"props":1228,"children":1229},{},[1230,1278,1324,1350,1411,1443,1486,1514],{"type":40,"tag":142,"props":1231,"children":1232},{},[1233,1242,1273],{"type":40,"tag":169,"props":1234,"children":1235},{},[1236],{"type":40,"tag":70,"props":1237,"children":1239},{"className":1238},[],[1240],{"type":46,"value":1241},"return result",{"type":40,"tag":169,"props":1243,"children":1244},{},[1245,1251,1253,1259,1260,1266,1267],{"type":40,"tag":70,"props":1246,"children":1248},{"className":1247},[],[1249],{"type":46,"value":1250},"return null",{"type":46,"value":1252}," \u002F ",{"type":40,"tag":70,"props":1254,"children":1256},{"className":1255},[],[1257],{"type":46,"value":1258},"return None",{"type":46,"value":1252},{"type":40,"tag":70,"props":1261,"children":1263},{"className":1262},[],[1264],{"type":46,"value":1265},"return nil",{"type":46,"value":1252},{"type":40,"tag":70,"props":1268,"children":1270},{"className":1269},[],[1271],{"type":46,"value":1272},"return undefined",{"type":40,"tag":169,"props":1274,"children":1275},{},[1276],{"type":46,"value":1277},"Null\u002FNone\u002Fnil handling downstream",{"type":40,"tag":142,"props":1279,"children":1280},{},[1281,1289,1319],{"type":40,"tag":169,"props":1282,"children":1283},{},[1284],{"type":40,"tag":70,"props":1285,"children":1287},{"className":1286},[],[1288],{"type":46,"value":1241},{"type":40,"tag":169,"props":1290,"children":1291},{},[1292,1298,1299,1305,1306,1312,1313],{"type":40,"tag":70,"props":1293,"children":1295},{"className":1294},[],[1296],{"type":46,"value":1297},"return default(T)",{"type":46,"value":1252},{"type":40,"tag":70,"props":1300,"children":1302},{"className":1301},[],[1303],{"type":46,"value":1304},"return T()",{"type":46,"value":1252},{"type":40,"tag":70,"props":1307,"children":1309},{"className":1308},[],[1310],{"type":46,"value":1311},"return \"\"",{"type":46,"value":1252},{"type":40,"tag":70,"props":1314,"children":1316},{"className":1315},[],[1317],{"type":46,"value":1318},"return 0",{"type":40,"tag":169,"props":1320,"children":1321},{},[1322],{"type":46,"value":1323},"Default value handling",{"type":40,"tag":142,"props":1325,"children":1326},{},[1327,1336,1345],{"type":40,"tag":169,"props":1328,"children":1329},{},[1330],{"type":40,"tag":70,"props":1331,"children":1333},{"className":1332},[],[1334],{"type":46,"value":1335},"return true",{"type":40,"tag":169,"props":1337,"children":1338},{},[1339],{"type":40,"tag":70,"props":1340,"children":1342},{"className":1341},[],[1343],{"type":46,"value":1344},"return false",{"type":40,"tag":169,"props":1346,"children":1347},{},[1348],{"type":46,"value":1349},"Boolean return verification",{"type":40,"tag":142,"props":1351,"children":1352},{},[1353,1362,1406],{"type":40,"tag":169,"props":1354,"children":1355},{},[1356],{"type":40,"tag":70,"props":1357,"children":1359},{"className":1358},[],[1360],{"type":46,"value":1361},"return list",{"type":40,"tag":169,"props":1363,"children":1364},{},[1365,1371,1372,1378,1379,1385,1386,1392,1393,1399,1400],{"type":40,"tag":70,"props":1366,"children":1368},{"className":1367},[],[1369],{"type":46,"value":1370},"return new List\u003CT>()",{"type":46,"value":1252},{"type":40,"tag":70,"props":1373,"children":1375},{"className":1374},[],[1376],{"type":46,"value":1377},"return []",{"type":46,"value":1252},{"type":40,"tag":70,"props":1380,"children":1382},{"className":1381},[],[1383],{"type":46,"value":1384},"return Array.Empty\u003CT>()",{"type":46,"value":1252},{"type":40,"tag":70,"props":1387,"children":1389},{"className":1388},[],[1390],{"type":46,"value":1391},"return make([]T, 0)",{"type":46,"value":1252},{"type":40,"tag":70,"props":1394,"children":1396},{"className":1395},[],[1397],{"type":46,"value":1398},"return Vec::new()",{"type":46,"value":1252},{"type":40,"tag":70,"props":1401,"children":1403},{"className":1402},[],[1404],{"type":46,"value":1405},"return @[]",{"type":40,"tag":169,"props":1407,"children":1408},{},[1409],{"type":46,"value":1410},"Empty collection handling",{"type":40,"tag":142,"props":1412,"children":1413},{},[1414,1423,1438],{"type":40,"tag":169,"props":1415,"children":1416},{},[1417],{"type":40,"tag":70,"props":1418,"children":1420},{"className":1419},[],[1421],{"type":46,"value":1422},"return count",{"type":40,"tag":169,"props":1424,"children":1425},{},[1426,1431,1432],{"type":40,"tag":70,"props":1427,"children":1429},{"className":1428},[],[1430],{"type":46,"value":1318},{"type":46,"value":683},{"type":40,"tag":70,"props":1433,"children":1435},{"className":1434},[],[1436],{"type":46,"value":1437},"return count + 1",{"type":40,"tag":169,"props":1439,"children":1440},{},[1441],{"type":46,"value":1442},"Numeric return verification",{"type":40,"tag":142,"props":1444,"children":1445},{},[1446,1455,1481],{"type":40,"tag":169,"props":1447,"children":1448},{},[1449],{"type":40,"tag":70,"props":1450,"children":1452},{"className":1451},[],[1453],{"type":46,"value":1454},"return string",{"type":40,"tag":169,"props":1456,"children":1457},{},[1458,1463,1464,1469,1470,1475,1476],{"type":40,"tag":70,"props":1459,"children":1461},{"className":1460},[],[1462],{"type":46,"value":1311},{"type":46,"value":683},{"type":40,"tag":70,"props":1465,"children":1467},{"className":1466},[],[1468],{"type":46,"value":1250},{"type":46,"value":556},{"type":40,"tag":70,"props":1471,"children":1473},{"className":1472},[],[1474],{"type":46,"value":485},{"type":46,"value":556},{"type":40,"tag":70,"props":1477,"children":1479},{"className":1478},[],[1480],{"type":46,"value":492},{"type":40,"tag":169,"props":1482,"children":1483},{},[1484],{"type":46,"value":1485},"String return verification",{"type":40,"tag":142,"props":1487,"children":1488},{},[1489,1498,1509],{"type":40,"tag":169,"props":1490,"children":1491},{},[1492],{"type":40,"tag":70,"props":1493,"children":1495},{"className":1494},[],[1496],{"type":46,"value":1497},"return Ok(x)",{"type":40,"tag":169,"props":1499,"children":1500},{},[1501,1507],{"type":40,"tag":70,"props":1502,"children":1504},{"className":1503},[],[1505],{"type":46,"value":1506},"return Err(...)",{"type":46,"value":1508}," (Rust)",{"type":40,"tag":169,"props":1510,"children":1511},{},[1512],{"type":46,"value":1513},"Result\u002Ferror variant",{"type":40,"tag":142,"props":1515,"children":1516},{},[1517,1526,1537],{"type":40,"tag":169,"props":1518,"children":1519},{},[1520],{"type":40,"tag":70,"props":1521,"children":1523},{"className":1522},[],[1524],{"type":46,"value":1525},"return value, nil",{"type":40,"tag":169,"props":1527,"children":1528},{},[1529,1535],{"type":40,"tag":70,"props":1530,"children":1532},{"className":1531},[],[1533],{"type":46,"value":1534},"return zero, err",{"type":46,"value":1536}," (Go)",{"type":40,"tag":169,"props":1538,"children":1539},{},[1540],{"type":46,"value":1541},"Error tuple",{"type":40,"tag":783,"props":1543,"children":1545},{"id":1544},"exception-error-removal-mutations",[1546],{"type":46,"value":1547},"Exception \u002F Error Removal Mutations",{"type":40,"tag":134,"props":1549,"children":1550},{},[1551,1569],{"type":40,"tag":138,"props":1552,"children":1553},{},[1554],{"type":40,"tag":142,"props":1555,"children":1556},{},[1557,1561,1565],{"type":40,"tag":146,"props":1558,"children":1559},{},[1560],{"type":46,"value":802},{"type":40,"tag":146,"props":1562,"children":1563},{},[1564],{"type":46,"value":807},{"type":40,"tag":146,"props":1566,"children":1567},{},[1568],{"type":46,"value":812},{"type":40,"tag":162,"props":1570,"children":1571},{},[1572,1679,1733,1767,1793],{"type":40,"tag":142,"props":1573,"children":1574},{},[1575,1666,1674],{"type":40,"tag":169,"props":1576,"children":1577},{},[1578,1584,1586,1592,1594,1600,1602,1608,1610,1616,1618,1624,1626,1632,1634,1640,1642,1648,1650,1656,1658,1664],{"type":40,"tag":70,"props":1579,"children":1581},{"className":1580},[],[1582],{"type":46,"value":1583},"throw new ArgumentNullException(...)",{"type":46,"value":1585}," (.NET) \u002F ",{"type":40,"tag":70,"props":1587,"children":1589},{"className":1588},[],[1590],{"type":46,"value":1591},"raise ValueError(...)",{"type":46,"value":1593}," (Python) \u002F ",{"type":40,"tag":70,"props":1595,"children":1597},{"className":1596},[],[1598],{"type":46,"value":1599},"throw new Error(...)",{"type":46,"value":1601}," (JS) \u002F ",{"type":40,"tag":70,"props":1603,"children":1605},{"className":1604},[],[1606],{"type":46,"value":1607},"throw new IllegalArgumentException(...)",{"type":46,"value":1609}," (Java) \u002F ",{"type":40,"tag":70,"props":1611,"children":1613},{"className":1612},[],[1614],{"type":46,"value":1615},"panic!(...)",{"type":46,"value":1617}," (Rust) \u002F ",{"type":40,"tag":70,"props":1619,"children":1621},{"className":1620},[],[1622],{"type":46,"value":1623},"panic(...)",{"type":46,"value":1625}," (Go) \u002F ",{"type":40,"tag":70,"props":1627,"children":1629},{"className":1628},[],[1630],{"type":46,"value":1631},"raise ArgumentError",{"type":46,"value":1633}," (Ruby) \u002F ",{"type":40,"tag":70,"props":1635,"children":1637},{"className":1636},[],[1638],{"type":46,"value":1639},"throw RuntimeException(...)",{"type":46,"value":1641}," (Kotlin) \u002F ",{"type":40,"tag":70,"props":1643,"children":1645},{"className":1644},[],[1646],{"type":46,"value":1647},"throw FooError.bar",{"type":46,"value":1649}," (Swift) \u002F ",{"type":40,"tag":70,"props":1651,"children":1653},{"className":1652},[],[1654],{"type":46,"value":1655},"throw \"...\"",{"type":46,"value":1657}," (Pester) \u002F ",{"type":40,"tag":70,"props":1659,"children":1661},{"className":1660},[],[1662],{"type":46,"value":1663},"throw std::invalid_argument(...)",{"type":46,"value":1665}," (C++)",{"type":40,"tag":169,"props":1667,"children":1668},{},[1669],{"type":40,"tag":126,"props":1670,"children":1671},{},[1672],{"type":46,"value":1673},"(remove entire throw\u002Fraise\u002Fpanic)",{"type":40,"tag":169,"props":1675,"children":1676},{},[1677],{"type":46,"value":1678},"Guard clause verification",{"type":40,"tag":142,"props":1680,"children":1681},{},[1682,1720,1728],{"type":40,"tag":169,"props":1683,"children":1684},{},[1685,1691,1692,1698,1699,1705,1706,1712,1713,1719],{"type":40,"tag":70,"props":1686,"children":1688},{"className":1687},[],[1689],{"type":46,"value":1690},"if (x == null) throw ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":1693,"children":1695},{"className":1694},[],[1696],{"type":46,"value":1697},"if x is None: raise ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":1700,"children":1702},{"className":1701},[],[1703],{"type":46,"value":1704},"if (!x) throw ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":1707,"children":1709},{"className":1708},[],[1710],{"type":46,"value":1711},"if x == nil { return err }",{"type":46,"value":1625},{"type":40,"tag":70,"props":1714,"children":1716},{"className":1715},[],[1717],{"type":46,"value":1718},"assert!(x.is_some())",{"type":46,"value":1508},{"type":40,"tag":169,"props":1721,"children":1722},{},[1723],{"type":40,"tag":126,"props":1724,"children":1725},{},[1726],{"type":46,"value":1727},"(remove entire guard)",{"type":40,"tag":169,"props":1729,"children":1730},{},[1731],{"type":46,"value":1732},"Null\u002FNone\u002Fnil guard testing",{"type":40,"tag":142,"props":1734,"children":1735},{},[1736,1754,1762],{"type":40,"tag":169,"props":1737,"children":1738},{},[1739,1745,1746,1752],{"type":40,"tag":70,"props":1740,"children":1742},{"className":1741},[],[1743],{"type":46,"value":1744},"if (!IsValid()) throw ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":1747,"children":1749},{"className":1748},[],[1750],{"type":46,"value":1751},"if not is_valid(): raise ...",{"type":46,"value":1753}," \u002F etc.",{"type":40,"tag":169,"props":1755,"children":1756},{},[1757],{"type":40,"tag":126,"props":1758,"children":1759},{},[1760],{"type":46,"value":1761},"(remove entire check)",{"type":40,"tag":169,"props":1763,"children":1764},{},[1765],{"type":46,"value":1766},"Validation testing",{"type":40,"tag":142,"props":1768,"children":1769},{},[1770,1780,1788],{"type":40,"tag":169,"props":1771,"children":1772},{},[1773,1778],{"type":40,"tag":70,"props":1774,"children":1776},{"className":1775},[],[1777],{"type":46,"value":527},{"type":46,"value":1779}," after error check (Go)",{"type":40,"tag":169,"props":1781,"children":1782},{},[1783],{"type":40,"tag":126,"props":1784,"children":1785},{},[1786],{"type":46,"value":1787},"(remove or swallow error)",{"type":40,"tag":169,"props":1789,"children":1790},{},[1791],{"type":46,"value":1792},"Error propagation",{"type":40,"tag":142,"props":1794,"children":1795},{},[1796,1807,1823],{"type":40,"tag":169,"props":1797,"children":1798},{},[1799,1805],{"type":40,"tag":70,"props":1800,"children":1802},{"className":1801},[],[1803],{"type":46,"value":1804},"?",{"type":46,"value":1806}," operator (Rust)",{"type":40,"tag":169,"props":1808,"children":1809},{},[1810,1816,1817],{"type":40,"tag":70,"props":1811,"children":1813},{"className":1812},[],[1814],{"type":46,"value":1815},".unwrap()",{"type":46,"value":683},{"type":40,"tag":70,"props":1818,"children":1820},{"className":1819},[],[1821],{"type":46,"value":1822},".expect(...)",{"type":40,"tag":169,"props":1824,"children":1825},{},[1826],{"type":46,"value":1827},"Error short-circuit",{"type":40,"tag":783,"props":1829,"children":1831},{"id":1830},"arithmetic-mutations",[1832],{"type":46,"value":1833},"Arithmetic Mutations",{"type":40,"tag":134,"props":1835,"children":1836},{},[1837,1855],{"type":40,"tag":138,"props":1838,"children":1839},{},[1840],{"type":40,"tag":142,"props":1841,"children":1842},{},[1843,1847,1851],{"type":40,"tag":146,"props":1844,"children":1845},{},[1846],{"type":46,"value":802},{"type":40,"tag":146,"props":1848,"children":1849},{},[1850],{"type":46,"value":807},{"type":40,"tag":146,"props":1852,"children":1853},{},[1854],{"type":46,"value":812},{"type":40,"tag":162,"props":1856,"children":1857},{},[1858,1884,1908,1934,1958,1983,2009],{"type":40,"tag":142,"props":1859,"children":1860},{},[1861,1870,1879],{"type":40,"tag":169,"props":1862,"children":1863},{},[1864],{"type":40,"tag":70,"props":1865,"children":1867},{"className":1866},[],[1868],{"type":46,"value":1869},"a + b",{"type":40,"tag":169,"props":1871,"children":1872},{},[1873],{"type":40,"tag":70,"props":1874,"children":1876},{"className":1875},[],[1877],{"type":46,"value":1878},"a - b",{"type":40,"tag":169,"props":1880,"children":1881},{},[1882],{"type":46,"value":1883},"Addition correctness",{"type":40,"tag":142,"props":1885,"children":1886},{},[1887,1895,1903],{"type":40,"tag":169,"props":1888,"children":1889},{},[1890],{"type":40,"tag":70,"props":1891,"children":1893},{"className":1892},[],[1894],{"type":46,"value":1878},{"type":40,"tag":169,"props":1896,"children":1897},{},[1898],{"type":40,"tag":70,"props":1899,"children":1901},{"className":1900},[],[1902],{"type":46,"value":1869},{"type":40,"tag":169,"props":1904,"children":1905},{},[1906],{"type":46,"value":1907},"Subtraction correctness",{"type":40,"tag":142,"props":1909,"children":1910},{},[1911,1920,1929],{"type":40,"tag":169,"props":1912,"children":1913},{},[1914],{"type":40,"tag":70,"props":1915,"children":1917},{"className":1916},[],[1918],{"type":46,"value":1919},"a * b",{"type":40,"tag":169,"props":1921,"children":1922},{},[1923],{"type":40,"tag":70,"props":1924,"children":1926},{"className":1925},[],[1927],{"type":46,"value":1928},"a \u002F b",{"type":40,"tag":169,"props":1930,"children":1931},{},[1932],{"type":46,"value":1933},"Multiplication correctness",{"type":40,"tag":142,"props":1935,"children":1936},{},[1937,1945,1953],{"type":40,"tag":169,"props":1938,"children":1939},{},[1940],{"type":40,"tag":70,"props":1941,"children":1943},{"className":1942},[],[1944],{"type":46,"value":1928},{"type":40,"tag":169,"props":1946,"children":1947},{},[1948],{"type":40,"tag":70,"props":1949,"children":1951},{"className":1950},[],[1952],{"type":46,"value":1919},{"type":40,"tag":169,"props":1954,"children":1955},{},[1956],{"type":46,"value":1957},"Division correctness",{"type":40,"tag":142,"props":1959,"children":1960},{},[1961,1970,1978],{"type":40,"tag":169,"props":1962,"children":1963},{},[1964],{"type":40,"tag":70,"props":1965,"children":1967},{"className":1966},[],[1968],{"type":46,"value":1969},"a % b",{"type":40,"tag":169,"props":1971,"children":1972},{},[1973],{"type":40,"tag":70,"props":1974,"children":1976},{"className":1975},[],[1977],{"type":46,"value":1928},{"type":40,"tag":169,"props":1979,"children":1980},{},[1981],{"type":46,"value":1982},"Modulo correctness",{"type":40,"tag":142,"props":1984,"children":1985},{},[1986,1995,2004],{"type":40,"tag":169,"props":1987,"children":1988},{},[1989],{"type":40,"tag":70,"props":1990,"children":1992},{"className":1991},[],[1993],{"type":46,"value":1994},"x++",{"type":40,"tag":169,"props":1996,"children":1997},{},[1998],{"type":40,"tag":70,"props":1999,"children":2001},{"className":2000},[],[2002],{"type":46,"value":2003},"x--",{"type":40,"tag":169,"props":2005,"children":2006},{},[2007],{"type":46,"value":2008},"Increment direction",{"type":40,"tag":142,"props":2010,"children":2011},{},[2012,2021,2030],{"type":40,"tag":169,"props":2013,"children":2014},{},[2015],{"type":40,"tag":70,"props":2016,"children":2018},{"className":2017},[],[2019],{"type":46,"value":2020},"-value",{"type":40,"tag":169,"props":2022,"children":2023},{},[2024],{"type":40,"tag":70,"props":2025,"children":2027},{"className":2026},[],[2028],{"type":46,"value":2029},"value",{"type":40,"tag":169,"props":2031,"children":2032},{},[2033],{"type":46,"value":2034},"Sign flip",{"type":40,"tag":783,"props":2036,"children":2038},{"id":2037},"null-none-nil-check-removal-mutations",[2039],{"type":46,"value":2040},"Null \u002F None \u002F Nil-Check Removal Mutations",{"type":40,"tag":134,"props":2042,"children":2043},{},[2044,2062],{"type":40,"tag":138,"props":2045,"children":2046},{},[2047],{"type":40,"tag":142,"props":2048,"children":2049},{},[2050,2054,2058],{"type":40,"tag":146,"props":2051,"children":2052},{},[2053],{"type":46,"value":802},{"type":40,"tag":146,"props":2055,"children":2056},{},[2057],{"type":46,"value":807},{"type":40,"tag":146,"props":2059,"children":2060},{},[2061],{"type":46,"value":812},{"type":40,"tag":162,"props":2063,"children":2064},{},[2065,2126,2187,2252,2295],{"type":40,"tag":142,"props":2066,"children":2067},{},[2068,2113,2121],{"type":40,"tag":169,"props":2069,"children":2070},{},[2071,2077,2078,2084,2085,2091,2092,2098,2099,2105,2106,2112],{"type":40,"tag":70,"props":2072,"children":2074},{"className":2073},[],[2075],{"type":46,"value":2076},"if (x == null) return ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":2079,"children":2081},{"className":2080},[],[2082],{"type":46,"value":2083},"if x is None: return ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":2086,"children":2088},{"className":2087},[],[2089],{"type":46,"value":2090},"if (!x) return ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":2093,"children":2095},{"className":2094},[],[2096],{"type":46,"value":2097},"if x == nil { return ... }",{"type":46,"value":1252},{"type":40,"tag":70,"props":2100,"children":2102},{"className":2101},[],[2103],{"type":46,"value":2104},"unless x; return; end",{"type":46,"value":1633},{"type":40,"tag":70,"props":2107,"children":2109},{"className":2108},[],[2110],{"type":46,"value":2111},"if x.is_none() { return ... }",{"type":46,"value":1508},{"type":40,"tag":169,"props":2114,"children":2115},{},[2116],{"type":40,"tag":126,"props":2117,"children":2118},{},[2119],{"type":46,"value":2120},"(remove null\u002FNone\u002Fnil check)",{"type":40,"tag":169,"props":2122,"children":2123},{},[2124],{"type":46,"value":2125},"Null path coverage",{"type":40,"tag":142,"props":2127,"children":2128},{},[2129,2174,2182],{"type":40,"tag":169,"props":2130,"children":2131},{},[2132,2138,2139,2145,2146,2152,2153,2159,2160,2166,2167,2173],{"type":40,"tag":70,"props":2133,"children":2135},{"className":2134},[],[2136],{"type":46,"value":2137},"if (x != null) { ... }",{"type":46,"value":1252},{"type":40,"tag":70,"props":2140,"children":2142},{"className":2141},[],[2143],{"type":46,"value":2144},"if x is not None: ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":2147,"children":2149},{"className":2148},[],[2150],{"type":46,"value":2151},"if x: ...",{"type":46,"value":1252},{"type":40,"tag":70,"props":2154,"children":2156},{"className":2155},[],[2157],{"type":46,"value":2158},"if x != nil { ... }",{"type":46,"value":1252},{"type":40,"tag":70,"props":2161,"children":2163},{"className":2162},[],[2164],{"type":46,"value":2165},"x?.let { ... }",{"type":46,"value":1641},{"type":40,"tag":70,"props":2168,"children":2170},{"className":2169},[],[2171],{"type":46,"value":2172},"if let Some(x) = ... { ... }",{"type":46,"value":1508},{"type":40,"tag":169,"props":2175,"children":2176},{},[2177],{"type":40,"tag":126,"props":2178,"children":2179},{},[2180],{"type":46,"value":2181},"(always enter block)",{"type":40,"tag":169,"props":2183,"children":2184},{},[2185],{"type":46,"value":2186},"Null\u002FNone\u002Fnil guard necessity",{"type":40,"tag":142,"props":2188,"children":2189},{},[2190,2236,2247],{"type":40,"tag":169,"props":2191,"children":2192},{},[2193,2199,2201,2207,2208,2214,2215,2221,2222,2227,2229,2235],{"type":40,"tag":70,"props":2194,"children":2196},{"className":2195},[],[2197],{"type":46,"value":2198},"x ?? defaultValue",{"type":46,"value":2200}," (.NET\u002FJS\u002FSwift) \u002F ",{"type":40,"tag":70,"props":2202,"children":2204},{"className":2203},[],[2205],{"type":46,"value":2206},"x or defaultValue",{"type":46,"value":1593},{"type":40,"tag":70,"props":2209,"children":2211},{"className":2210},[],[2212],{"type":46,"value":2213},"x || defaultValue",{"type":46,"value":1601},{"type":40,"tag":70,"props":2216,"children":2218},{"className":2217},[],[2219],{"type":46,"value":2220},"x.unwrap_or(defaultValue)",{"type":46,"value":1617},{"type":40,"tag":70,"props":2223,"children":2225},{"className":2224},[],[2226],{"type":46,"value":2213},{"type":46,"value":2228}," (Kotlin: ",{"type":40,"tag":70,"props":2230,"children":2232},{"className":2231},[],[2233],{"type":46,"value":2234},"x ?: defaultValue",{"type":46,"value":338},{"type":40,"tag":169,"props":2237,"children":2238},{},[2239,2245],{"type":40,"tag":70,"props":2240,"children":2242},{"className":2241},[],[2243],{"type":46,"value":2244},"x",{"type":46,"value":2246}," (drop coalescing)",{"type":40,"tag":169,"props":2248,"children":2249},{},[2250],{"type":46,"value":2251},"Null coalescing coverage",{"type":40,"tag":142,"props":2253,"children":2254},{},[2255,2281,2290],{"type":40,"tag":169,"props":2256,"children":2257},{},[2258,2264,2266,2272,2273,2279],{"type":40,"tag":70,"props":2259,"children":2261},{"className":2260},[],[2262],{"type":46,"value":2263},"x?.Method()",{"type":46,"value":2265}," (.NET\u002FSwift\u002FKotlin) \u002F ",{"type":40,"tag":70,"props":2267,"children":2269},{"className":2268},[],[2270],{"type":46,"value":2271},"x && x.method()",{"type":46,"value":1601},{"type":40,"tag":70,"props":2274,"children":2276},{"className":2275},[],[2277],{"type":46,"value":2278},"x and x.method()",{"type":46,"value":2280}," (Python)",{"type":40,"tag":169,"props":2282,"children":2283},{},[2284],{"type":40,"tag":70,"props":2285,"children":2287},{"className":2286},[],[2288],{"type":46,"value":2289},"x.Method()",{"type":40,"tag":169,"props":2291,"children":2292},{},[2293],{"type":46,"value":2294},"Null-conditional coverage",{"type":40,"tag":142,"props":2296,"children":2297},{},[2298,2322,2330],{"type":40,"tag":169,"props":2299,"children":2300},{},[2301,2307,2309,2315,2316,2321],{"type":40,"tag":70,"props":2302,"children":2304},{"className":2303},[],[2305],{"type":46,"value":2306},"x!",{"type":46,"value":2308}," (.NET\u002FTS\u002FSwift) \u002F ",{"type":40,"tag":70,"props":2310,"children":2312},{"className":2311},[],[2313],{"type":46,"value":2314},"x!!",{"type":46,"value":1641},{"type":40,"tag":70,"props":2317,"children":2319},{"className":2318},[],[2320],{"type":46,"value":1815},{"type":46,"value":1508},{"type":40,"tag":169,"props":2323,"children":2324},{},[2325],{"type":40,"tag":70,"props":2326,"children":2328},{"className":2327},[],[2329],{"type":46,"value":2244},{"type":40,"tag":169,"props":2331,"children":2332},{},[2333],{"type":46,"value":2334},"Null-forgiving \u002F unwrap necessity",{"type":40,"tag":454,"props":2336,"children":2338},{"id":2337},"step-4-evaluate-each-mutation-against-tests",[2339],{"type":46,"value":2340},"Step 4: Evaluate each mutation against tests",{"type":40,"tag":49,"props":2342,"children":2343},{},[2344],{"type":46,"value":2345},"For each identified mutation point, reason about whether existing tests would detect the change:",{"type":40,"tag":2347,"props":2348,"children":2349},"ol",{},[2350,2360,2370],{"type":40,"tag":253,"props":2351,"children":2352},{},[2353,2358],{"type":40,"tag":62,"props":2354,"children":2355},{},[2356],{"type":46,"value":2357},"Find covering tests",{"type":46,"value":2359}," — Which test methods exercise the mutated line? Follow call chains through helpers and setup methods.",{"type":40,"tag":253,"props":2361,"children":2362},{},[2363,2368],{"type":40,"tag":62,"props":2364,"children":2365},{},[2366],{"type":46,"value":2367},"Check assertion relevance",{"type":46,"value":2369}," — Do those tests assert something that would change if the mutation were applied? A test that calls the method but only asserts an unrelated property would NOT catch the mutation.",{"type":40,"tag":253,"props":2371,"children":2372},{},[2373,2378],{"type":40,"tag":62,"props":2374,"children":2375},{},[2376],{"type":46,"value":2377},"Classify the mutation",{"type":46,"value":2379}," as:",{"type":40,"tag":134,"props":2381,"children":2382},{},[2383,2404],{"type":40,"tag":138,"props":2384,"children":2385},{},[2386],{"type":40,"tag":142,"props":2387,"children":2388},{},[2389,2394,2399],{"type":40,"tag":146,"props":2390,"children":2391},{},[2392],{"type":46,"value":2393},"Verdict",{"type":40,"tag":146,"props":2395,"children":2396},{},[2397],{"type":46,"value":2398},"Meaning",{"type":40,"tag":146,"props":2400,"children":2401},{},[2402],{"type":46,"value":2403},"Action",{"type":40,"tag":162,"props":2405,"children":2406},{},[2407,2428,2449,2470],{"type":40,"tag":142,"props":2408,"children":2409},{},[2410,2418,2423],{"type":40,"tag":169,"props":2411,"children":2412},{},[2413],{"type":40,"tag":62,"props":2414,"children":2415},{},[2416],{"type":46,"value":2417},"Killed",{"type":40,"tag":169,"props":2419,"children":2420},{},[2421],{"type":46,"value":2422},"At least one test would fail if this mutation were applied",{"type":40,"tag":169,"props":2424,"children":2425},{},[2426],{"type":46,"value":2427},"No action needed — tests are effective here",{"type":40,"tag":142,"props":2429,"children":2430},{},[2431,2439,2444],{"type":40,"tag":169,"props":2432,"children":2433},{},[2434],{"type":40,"tag":62,"props":2435,"children":2436},{},[2437],{"type":46,"value":2438},"Survived",{"type":40,"tag":169,"props":2440,"children":2441},{},[2442],{"type":46,"value":2443},"No test would fail — the mutation would go undetected",{"type":40,"tag":169,"props":2445,"children":2446},{},[2447],{"type":46,"value":2448},"This is a test gap — recommend a test improvement",{"type":40,"tag":142,"props":2450,"children":2451},{},[2452,2460,2465],{"type":40,"tag":169,"props":2453,"children":2454},{},[2455],{"type":40,"tag":62,"props":2456,"children":2457},{},[2458],{"type":46,"value":2459},"No coverage",{"type":40,"tag":169,"props":2461,"children":2462},{},[2463],{"type":46,"value":2464},"No test exercises this code path at all",{"type":40,"tag":169,"props":2466,"children":2467},{},[2468],{"type":46,"value":2469},"Worse than survived — the code is untested",{"type":40,"tag":142,"props":2471,"children":2472},{},[2473,2481,2501],{"type":40,"tag":169,"props":2474,"children":2475},{},[2476],{"type":40,"tag":62,"props":2477,"children":2478},{},[2479],{"type":46,"value":2480},"Equivalent",{"type":40,"tag":169,"props":2482,"children":2483},{},[2484,2486,2492,2494,2500],{"type":46,"value":2485},"The mutation produces identical behavior (e.g., ",{"type":40,"tag":70,"props":2487,"children":2489},{"className":2488},[],[2490],{"type":46,"value":2491},"x * 1",{"type":46,"value":2493}," → ",{"type":40,"tag":70,"props":2495,"children":2497},{"className":2496},[],[2498],{"type":46,"value":2499},"x \u002F 1",{"type":46,"value":338},{"type":40,"tag":169,"props":2502,"children":2503},{},[2504],{"type":46,"value":2505},"Skip — not a real mutation",{"type":40,"tag":454,"props":2507,"children":2509},{"id":2508},"step-4b-verify-every-reported-survivor-by-running-the-tests",[2510],{"type":46,"value":2511},"Step 4b: Verify every reported survivor by running the tests",{"type":40,"tag":49,"props":2513,"children":2514},{},[2515,2517],{"type":46,"value":2516},"Static reasoning alone produces false \"survived\" verdicts — the most common failure of this skill is telling a user their tests are weak when the tests actually catch the bug. ",{"type":40,"tag":62,"props":2518,"children":2519},{},[2520],{"type":46,"value":2521},"If the suite can be built and run, verify before you report.",{"type":40,"tag":2347,"props":2523,"children":2524},{},[2525,2571,2581,2603,2613],{"type":40,"tag":253,"props":2526,"children":2527},{},[2528,2533,2535,2541,2542,2548,2549,2555,2556,2562,2563,2569],{"type":40,"tag":62,"props":2529,"children":2530},{},[2531],{"type":46,"value":2532},"Establish a green baseline.",{"type":46,"value":2534}," Run the suite (",{"type":40,"tag":70,"props":2536,"children":2538},{"className":2537},[],[2539],{"type":46,"value":2540},"dotnet test",{"type":46,"value":85},{"type":40,"tag":70,"props":2543,"children":2545},{"className":2544},[],[2546],{"type":46,"value":2547},"pytest",{"type":46,"value":85},{"type":40,"tag":70,"props":2550,"children":2552},{"className":2551},[],[2553],{"type":46,"value":2554},"npm test",{"type":46,"value":85},{"type":40,"tag":70,"props":2557,"children":2559},{"className":2558},[],[2560],{"type":46,"value":2561},"go test .\u002F...",{"type":46,"value":85},{"type":40,"tag":70,"props":2564,"children":2566},{"className":2565},[],[2567],{"type":46,"value":2568},"cargo test",{"type":46,"value":2570},", …). Record the pass count. If it does not build or run, fix only obvious wiring problems (missing project reference, wrong runner arguments) — never rewrite production behavior.",{"type":40,"tag":253,"props":2572,"children":2573},{},[2574,2579],{"type":40,"tag":62,"props":2575,"children":2576},{},[2577],{"type":46,"value":2578},"Apply each candidate survivor as a real edit",{"type":46,"value":2580},", one at a time, to the production file.",{"type":40,"tag":253,"props":2582,"children":2583},{},[2584,2589,2591,2595,2597,2601],{"type":40,"tag":62,"props":2585,"children":2586},{},[2587],{"type":46,"value":2588},"Re-run the narrowest covering test(s).",{"type":46,"value":2590}," Still green ⇒ genuinely ",{"type":40,"tag":62,"props":2592,"children":2593},{},[2594],{"type":46,"value":2438},{"type":46,"value":2596},". Now red ⇒ ",{"type":40,"tag":62,"props":2598,"children":2599},{},[2600],{"type":46,"value":2417},{"type":46,"value":2602},"; drop it from the findings.",{"type":40,"tag":253,"props":2604,"children":2605},{},[2606,2611],{"type":40,"tag":62,"props":2607,"children":2608},{},[2609],{"type":46,"value":2610},"Revert immediately",{"type":46,"value":2612}," after each check, and confirm the suite is green again before finishing. Never leave a mutation in the working tree.",{"type":40,"tag":253,"props":2614,"children":2615},{},[2616,2621],{"type":40,"tag":62,"props":2617,"children":2618},{},[2619],{"type":46,"value":2620},"Report what you did",{"type":46,"value":2622},": state that survivors were empirically confirmed and give the observed kill count (e.g. \"8 of 9 injected mutations were caught\").",{"type":40,"tag":49,"props":2624,"children":2625},{},[2626,2628,2633],{"type":46,"value":2627},"When the suite genuinely cannot be executed (no toolchain, no network, compile errors you must not fix), fall back to reasoning — but label every finding ",{"type":40,"tag":62,"props":2629,"children":2630},{},[2631],{"type":46,"value":2632},"unverified (static reasoning)",{"type":46,"value":2634},", and downgrade its confidence rather than presenting it as a proven gap.",{"type":40,"tag":454,"props":2636,"children":2638},{"id":2637},"step-5-calibrate-findings",[2639],{"type":46,"value":2640},"Step 5: Calibrate findings",{"type":40,"tag":49,"props":2642,"children":2643},{},[2644],{"type":46,"value":2645},"Before reporting, apply these calibration rules:",{"type":40,"tag":249,"props":2647,"children":2648},{},[2649,2667,2677,2709,2719,2729,2739],{"type":40,"tag":253,"props":2650,"children":2651},{},[2652,2657,2659,2665],{"type":40,"tag":62,"props":2653,"children":2654},{},[2655],{"type":46,"value":2656},"Don't flag trivial code.",{"type":46,"value":2658}," Simple property getters (",{"type":40,"tag":70,"props":2660,"children":2662},{"className":2661},[],[2663],{"type":46,"value":2664},"return _name;",{"type":46,"value":2666},"), auto-properties, and boilerplate don't need mutation analysis. Focus on logic, conditions, calculations, and error handling.",{"type":40,"tag":253,"props":2668,"children":2669},{},[2670,2675],{"type":40,"tag":62,"props":2671,"children":2672},{},[2673],{"type":46,"value":2674},"Consider defensive depth.",{"type":46,"value":2676}," If a null guard has a survived mutation but the caller also checks for null, note the redundancy but rate it lower priority.",{"type":40,"tag":253,"props":2678,"children":2679},{},[2680,2685,2687,2692,2694,2699,2701,2707],{"type":40,"tag":62,"props":2681,"children":2682},{},[2683],{"type":46,"value":2684},"Equivalent mutations are not gaps.",{"type":46,"value":2686}," If changing ",{"type":40,"tag":70,"props":2688,"children":2690},{"className":2689},[],[2691],{"type":46,"value":862},{"type":46,"value":2693}," to ",{"type":40,"tag":70,"props":2695,"children":2697},{"className":2696},[],[2698],{"type":46,"value":853},{"type":46,"value":2700}," doesn't alter behavior because the ",{"type":40,"tag":70,"props":2702,"children":2704},{"className":2703},[],[2705],{"type":46,"value":2706},"==",{"type":46,"value":2708}," case is impossible given the domain, mark it Equivalent and skip.",{"type":40,"tag":253,"props":2710,"children":2711},{},[2712,2717],{"type":40,"tag":62,"props":2713,"children":2714},{},[2715],{"type":46,"value":2716},"Private methods reached through public API are valid targets.",{"type":46,"value":2718}," Trace through the call chain — a private method called from a tested public method may still have survived mutations if the test doesn't assert the specific behavior affected.",{"type":40,"tag":253,"props":2720,"children":2721},{},[2722,2727],{"type":40,"tag":62,"props":2723,"children":2724},{},[2725],{"type":46,"value":2726},"Rate by risk, not count.",{"type":46,"value":2728}," A single survived mutation in payment calculation logic is more important than five survived mutations in logging code.",{"type":40,"tag":253,"props":2730,"children":2731},{},[2732,2737],{"type":40,"tag":62,"props":2733,"children":2734},{},[2735],{"type":46,"value":2736},"When most mutations are killed, lead with that.",{"type":46,"value":2738}," A strong suite with one or two minor survivors is a good result: say \"the tests are strong\" first and present the survivors as minor improvements. Do not attach \"critical\" \u002F \"HIGH RISK\" framing to a suite that kills the substantive mutations.",{"type":40,"tag":253,"props":2740,"children":2741},{},[2742,2747],{"type":40,"tag":62,"props":2743,"children":2744},{},[2745],{"type":46,"value":2746},"Never claim a gap you did not verify.",{"type":46,"value":2748}," If Step 4b confirmed the mutation is caught, it is not a finding. Prefer under-claiming: a missed gap costs the user far less than a false alarm that sends them writing redundant tests.",{"type":40,"tag":454,"props":2750,"children":2752},{"id":2751},"step-6-report-findings",[2753],{"type":46,"value":2754},"Step 6: Report findings",{"type":40,"tag":49,"props":2756,"children":2757},{},[2758],{"type":46,"value":2759},"Present the analysis in this structure:",{"type":40,"tag":2347,"props":2761,"children":2762},{},[2763,2785,2864,2874,2884],{"type":40,"tag":253,"props":2764,"children":2765},{},[2766,2771,2773],{"type":40,"tag":62,"props":2767,"children":2768},{},[2769],{"type":46,"value":2770},"Summary",{"type":46,"value":2772}," — Overall mutation score and key findings:",{"type":40,"tag":2774,"props":2775,"children":2779},"pre",{"className":2776,"code":2778,"language":46},[2777],"language-text","| Metric              | Value    |\n|---------------------|----------|\n| Mutation points      | 42       |\n| Killed               | 28 (67%) |\n| Survived             | 10 (24%) |\n| No coverage          | 2 (5%)   |\n| Equivalent (skipped) | 2 (5%)   |\n",[2780],{"type":40,"tag":70,"props":2781,"children":2783},{"__ignoreMap":2782},"",[2784],{"type":46,"value":2778},{"type":40,"tag":253,"props":2786,"children":2787},{},[2788,2793,2795,2858,2862],{"type":40,"tag":62,"props":2789,"children":2790},{},[2791],{"type":46,"value":2792},"Survived Mutations (Test Gaps)",{"type":46,"value":2794}," — For each survived mutation, report:",{"type":40,"tag":249,"props":2796,"children":2797},{},[2798,2808,2818,2828,2838,2848],{"type":40,"tag":253,"props":2799,"children":2800},{},[2801,2806],{"type":40,"tag":62,"props":2802,"children":2803},{},[2804],{"type":46,"value":2805},"Location",{"type":46,"value":2807},": File, method, line",{"type":40,"tag":253,"props":2809,"children":2810},{},[2811,2816],{"type":40,"tag":62,"props":2812,"children":2813},{},[2814],{"type":46,"value":2815},"Mutation category",{"type":46,"value":2817},": Boundary \u002F Boolean \u002F Return value \u002F Exception \u002F Arithmetic \u002F Null-check",{"type":40,"tag":253,"props":2819,"children":2820},{},[2821,2826],{"type":40,"tag":62,"props":2822,"children":2823},{},[2824],{"type":46,"value":2825},"Original code",{"type":46,"value":2827},": The current code",{"type":40,"tag":253,"props":2829,"children":2830},{},[2831,2836],{"type":40,"tag":62,"props":2832,"children":2833},{},[2834],{"type":46,"value":2835},"Hypothetical mutation",{"type":46,"value":2837},": What would change",{"type":40,"tag":253,"props":2839,"children":2840},{},[2841,2846],{"type":40,"tag":62,"props":2842,"children":2843},{},[2844],{"type":46,"value":2845},"Why it survives",{"type":46,"value":2847},": Which tests cover this code and why their assertions miss it",{"type":40,"tag":253,"props":2849,"children":2850},{},[2851,2856],{"type":40,"tag":62,"props":2852,"children":2853},{},[2854],{"type":46,"value":2855},"Recommended fix",{"type":46,"value":2857},": A concrete test assertion or new test case that would kill this mutation",{"type":40,"tag":2859,"props":2860,"children":2861},"br",{},[],{"type":46,"value":2863},"Group by priority: high-risk survived mutations first (business logic, calculations, security checks), lower-risk last (logging, formatting).",{"type":40,"tag":253,"props":2865,"children":2866},{},[2867,2872],{"type":40,"tag":62,"props":2868,"children":2869},{},[2870],{"type":46,"value":2871},"No-Coverage Zones",{"type":46,"value":2873}," — Code paths that no test reaches at all. These are worse than survived mutations.",{"type":40,"tag":253,"props":2875,"children":2876},{},[2877,2882],{"type":40,"tag":62,"props":2878,"children":2879},{},[2880],{"type":46,"value":2881},"Killed Mutations (Strengths)",{"type":46,"value":2883}," — Briefly note areas where tests are effective. Highlight well-tested methods and strong assertion patterns. Don't enumerate every killed mutation — summarize.",{"type":40,"tag":253,"props":2885,"children":2886},{},[2887,2892,2894],{"type":40,"tag":62,"props":2888,"children":2889},{},[2890],{"type":46,"value":2891},"Recommendations",{"type":46,"value":2893}," — Prioritized list:",{"type":40,"tag":249,"props":2895,"children":2896},{},[2897,2902,2907],{"type":40,"tag":253,"props":2898,"children":2899},{},[2900],{"type":46,"value":2901},"Which survived mutations to address first (by risk)",{"type":40,"tag":253,"props":2903,"children":2904},{},[2905],{"type":46,"value":2906},"Specific test methods to add or strengthen",{"type":40,"tag":253,"props":2908,"children":2909},{},[2910],{"type":46,"value":2911},"Patterns the team can adopt to prevent future gaps (e.g., always test boundary values, always assert exception types)",{"type":40,"tag":102,"props":2913,"children":2915},{"id":2914},"validation",[2916],{"type":46,"value":2917},"Validation",{"type":40,"tag":249,"props":2919,"children":2922},{"className":2920},[2921],"contains-task-list",[2923,2936,2945,2954,2963,2972,2981,2990,2999,3008],{"type":40,"tag":253,"props":2924,"children":2927},{"className":2925},[2926],"task-list-item",[2928,2934],{"type":40,"tag":2929,"props":2930,"children":2933},"input",{"disabled":2931,"type":2932},true,"checkbox",[],{"type":46,"value":2935}," The suite was run and every reported survivor was empirically confirmed (or all findings are explicitly labelled unverified)",{"type":40,"tag":253,"props":2937,"children":2939},{"className":2938},[2926],[2940,2943],{"type":40,"tag":2929,"props":2941,"children":2942},{"disabled":2931,"type":2932},[],{"type":46,"value":2944}," All applied mutations were reverted and the suite is green again",{"type":40,"tag":253,"props":2946,"children":2948},{"className":2947},[2926],[2949,2952],{"type":40,"tag":2929,"props":2950,"children":2951},{"disabled":2931,"type":2932},[],{"type":46,"value":2953}," Every mutation point was classified (Killed \u002F Survived \u002F No coverage \u002F Equivalent)",{"type":40,"tag":253,"props":2955,"children":2957},{"className":2956},[2926],[2958,2961],{"type":40,"tag":2929,"props":2959,"children":2960},{"disabled":2931,"type":2932},[],{"type":46,"value":2962}," Every survived mutation includes the original code, the hypothetical change, and why tests miss it",{"type":40,"tag":253,"props":2964,"children":2966},{"className":2965},[2926],[2967,2970],{"type":40,"tag":2929,"props":2968,"children":2969},{"disabled":2931,"type":2932},[],{"type":46,"value":2971}," Every survived mutation includes a concrete recommended fix (a test assertion or test case)",{"type":40,"tag":253,"props":2973,"children":2975},{"className":2974},[2926],[2976,2979],{"type":40,"tag":2929,"props":2977,"children":2978},{"disabled":2931,"type":2932},[],{"type":46,"value":2980}," Equivalent mutations are correctly identified and excluded from the score",{"type":40,"tag":253,"props":2982,"children":2984},{"className":2983},[2926],[2985,2988],{"type":40,"tag":2929,"props":2986,"children":2987},{"disabled":2931,"type":2932},[],{"type":46,"value":2989}," Trivial code (simple getters, auto-properties) is excluded from analysis",{"type":40,"tag":253,"props":2991,"children":2993},{"className":2992},[2926],[2994,2997],{"type":40,"tag":2929,"props":2995,"children":2996},{"disabled":2931,"type":2932},[],{"type":46,"value":2998}," Findings are prioritized by risk, not just listed in source order",{"type":40,"tag":253,"props":3000,"children":3002},{"className":3001},[2926],[3003,3006],{"type":40,"tag":2929,"props":3004,"children":3005},{"disabled":2931,"type":2932},[],{"type":46,"value":3007}," Report includes strengths (killed mutations) alongside gaps",{"type":40,"tag":253,"props":3009,"children":3011},{"className":3010},[2926],[3012,3015],{"type":40,"tag":2929,"props":3013,"children":3014},{"disabled":2931,"type":2932},[],{"type":46,"value":3016}," Mutation categories are correctly labeled",{"type":40,"tag":102,"props":3018,"children":3020},{"id":3019},"common-pitfalls",[3021],{"type":46,"value":3022},"Common Pitfalls",{"type":40,"tag":134,"props":3024,"children":3025},{},[3026,3042],{"type":40,"tag":138,"props":3027,"children":3028},{},[3029],{"type":40,"tag":142,"props":3030,"children":3031},{},[3032,3037],{"type":40,"tag":146,"props":3033,"children":3034},{},[3035],{"type":46,"value":3036},"Pitfall",{"type":40,"tag":146,"props":3038,"children":3039},{},[3040],{"type":46,"value":3041},"Solution",{"type":40,"tag":162,"props":3043,"children":3044},{},[3045,3058,3071,3084,3097,3140,3153,3166,3208,3221,3264,3277,3311,3340],{"type":40,"tag":142,"props":3046,"children":3047},{},[3048,3053],{"type":40,"tag":169,"props":3049,"children":3050},{},[3051],{"type":46,"value":3052},"Reporting survivors you never ran",{"type":40,"tag":169,"props":3054,"children":3055},{},[3056],{"type":46,"value":3057},"Apply the mutation, re-run the covering tests, revert. An unverified \"survived\" claim that the tests actually kill is worse than no analysis",{"type":40,"tag":142,"props":3059,"children":3060},{},[3061,3066],{"type":40,"tag":169,"props":3062,"children":3063},{},[3064],{"type":46,"value":3065},"Overstating severity on a strong suite",{"type":40,"tag":169,"props":3067,"children":3068},{},[3069],{"type":46,"value":3070},"If the substantive mutations are killed, open with \"tests are strong\" and frame the remainder as minor improvements",{"type":40,"tag":142,"props":3072,"children":3073},{},[3074,3079],{"type":40,"tag":169,"props":3075,"children":3076},{},[3077],{"type":46,"value":3078},"Publishing your reasoning as it changes",{"type":40,"tag":169,"props":3080,"children":3081},{},[3082],{"type":46,"value":3083},"Settle the verdict first; never emit \"wait, no… this is killed… let me recalibrate\" in the report",{"type":40,"tag":142,"props":3085,"children":3086},{},[3087,3092],{"type":40,"tag":169,"props":3088,"children":3089},{},[3090],{"type":46,"value":3091},"Leaving a mutation applied",{"type":40,"tag":169,"props":3093,"children":3094},{},[3095],{"type":46,"value":3096},"Revert every edit and re-run the suite before reporting",{"type":40,"tag":142,"props":3098,"children":3099},{},[3100,3105],{"type":40,"tag":169,"props":3101,"children":3102},{},[3103],{"type":46,"value":3104},"Analyzing trivial code",{"type":40,"tag":169,"props":3106,"children":3107},{},[3108,3110,3116,3117,3123,3124,3130,3132,3138],{"type":46,"value":3109},"Skip auto-properties, simple getters, ",{"type":40,"tag":70,"props":3111,"children":3113},{"className":3112},[],[3114],{"type":46,"value":3115},"@dataclass",{"type":46,"value":556},{"type":40,"tag":70,"props":3118,"children":3120},{"className":3119},[],[3121],{"type":46,"value":3122},"record",{"type":46,"value":556},{"type":40,"tag":70,"props":3125,"children":3127},{"className":3126},[],[3128],{"type":46,"value":3129},"data class",{"type":46,"value":3131}," accessors, ",{"type":40,"tag":70,"props":3133,"children":3135},{"className":3134},[],[3136],{"type":46,"value":3137},"#[derive]",{"type":46,"value":3139}," impls — focus on logic",{"type":40,"tag":142,"props":3141,"children":3142},{},[3143,3148],{"type":40,"tag":169,"props":3144,"children":3145},{},[3146],{"type":46,"value":3147},"Reporting equivalent mutations as gaps",{"type":40,"tag":169,"props":3149,"children":3150},{},[3151],{"type":46,"value":3152},"If the mutation doesn't change behavior, it's not a gap — mark Equivalent",{"type":40,"tag":142,"props":3154,"children":3155},{},[3156,3161],{"type":40,"tag":169,"props":3157,"children":3158},{},[3159],{"type":46,"value":3160},"Ignoring call chains",{"type":40,"tag":169,"props":3162,"children":3163},{},[3164],{"type":46,"value":3165},"A private\u002Finternal\u002Funexported helper called from a tested public method is reachable — trace the chain",{"type":40,"tag":142,"props":3167,"children":3168},{},[3169,3174],{"type":40,"tag":169,"props":3170,"children":3171},{},[3172],{"type":46,"value":3173},"Over-counting mutations in generated code",{"type":40,"tag":169,"props":3175,"children":3176},{},[3177,3179,3185,3186,3192,3193,3199,3200,3206],{"type":46,"value":3178},"Skip auto-generated code (",{"type":40,"tag":70,"props":3180,"children":3182},{"className":3181},[],[3183],{"type":46,"value":3184},"*.g.cs",{"type":46,"value":85},{"type":40,"tag":70,"props":3187,"children":3189},{"className":3188},[],[3190],{"type":46,"value":3191},"*.designer.cs",{"type":46,"value":85},{"type":40,"tag":70,"props":3194,"children":3196},{"className":3195},[],[3197],{"type":46,"value":3198},"*_pb.go",{"type":46,"value":85},{"type":40,"tag":70,"props":3201,"children":3203},{"className":3202},[],[3204],{"type":46,"value":3205},"*.pb.dart",{"type":46,"value":3207},"), designer files, migration files, generated mocks\u002Fstubs",{"type":40,"tag":142,"props":3209,"children":3210},{},[3211,3216],{"type":40,"tag":169,"props":3212,"children":3213},{},[3214],{"type":46,"value":3215},"Recommending a new test for every survived mutation",{"type":40,"tag":169,"props":3217,"children":3218},{},[3219],{"type":46,"value":3220},"Multiple survived mutations in the same method often share a single missing test — recommend one test that kills several",{"type":40,"tag":142,"props":3222,"children":3223},{},[3224,3229],{"type":40,"tag":169,"props":3225,"children":3226},{},[3227],{"type":46,"value":3228},"Ignoring production context",{"type":40,"tag":169,"props":3230,"children":3231},{},[3232,3234,3240,3241,3247,3248,3254,3256,3262],{"type":46,"value":3233},"A survived mutation in ",{"type":40,"tag":70,"props":3235,"children":3237},{"className":3236},[],[3238],{"type":46,"value":3239},"ToString()",{"type":46,"value":1252},{"type":40,"tag":70,"props":3242,"children":3244},{"className":3243},[],[3245],{"type":46,"value":3246},"__repr__",{"type":46,"value":1252},{"type":40,"tag":70,"props":3249,"children":3251},{"className":3250},[],[3252],{"type":46,"value":3253},"toString()",{"type":46,"value":3255}," formatting is less important than one in ",{"type":40,"tag":70,"props":3257,"children":3259},{"className":3258},[],[3260],{"type":46,"value":3261},"CalculateTotal()",{"type":46,"value":3263}," — prioritize by business risk",{"type":40,"tag":142,"props":3265,"children":3266},{},[3267,3272],{"type":40,"tag":169,"props":3268,"children":3269},{},[3270],{"type":46,"value":3271},"Claiming 100% kill rate is required",{"type":40,"tag":169,"props":3273,"children":3274},{},[3275],{"type":46,"value":3276},"Some mutations in low-risk code are acceptable to leave — acknowledge this in the report",{"type":40,"tag":142,"props":3278,"children":3279},{},[3280,3285],{"type":40,"tag":169,"props":3281,"children":3282},{},[3283],{"type":46,"value":3284},"Not considering integration with other skills",{"type":40,"tag":169,"props":3286,"children":3287},{},[3288,3290,3295,3297,3302,3304,3309],{"type":46,"value":3289},"If gaps are found, mention that ",{"type":40,"tag":70,"props":3291,"children":3293},{"className":3292},[],[3294],{"type":46,"value":315},{"type":46,"value":3296}," (any language) or ",{"type":40,"tag":70,"props":3298,"children":3300},{"className":3299},[],[3301],{"type":46,"value":323},{"type":46,"value":3303}," (MSTest-specific) can help write the missing tests, and ",{"type":40,"tag":70,"props":3305,"children":3307},{"className":3306},[],[3308],{"type":46,"value":336},{"type":46,"value":3310}," can audit existing test quality",{"type":40,"tag":142,"props":3312,"children":3313},{},[3314,3319],{"type":40,"tag":169,"props":3315,"children":3316},{},[3317],{"type":46,"value":3318},"Forgetting Go's error idiom",{"type":40,"tag":169,"props":3320,"children":3321},{},[3322,3324,3330,3332,3338],{"type":46,"value":3323},"Removing ",{"type":40,"tag":70,"props":3325,"children":3327},{"className":3326},[],[3328],{"type":46,"value":3329},"if err != nil { return err }",{"type":46,"value":3331}," is a valid mutation target only when the function actually does something else with ",{"type":40,"tag":70,"props":3333,"children":3335},{"className":3334},[],[3336],{"type":46,"value":3337},"err",{"type":46,"value":3339}," (e.g., wrap, log, branch). Bare passthroughs in idiomatic Go are not meaningful gaps.",{"type":40,"tag":142,"props":3341,"children":3342},{},[3343,3355],{"type":40,"tag":169,"props":3344,"children":3345},{},[3346,3348,3353],{"type":46,"value":3347},"Forgetting Rust's ",{"type":40,"tag":70,"props":3349,"children":3351},{"className":3350},[],[3352],{"type":46,"value":1804},{"type":46,"value":3354}," operator",{"type":40,"tag":169,"props":3356,"children":3357},{},[3358,3363,3365,3371,3372,3377,3379,3385,3386,3392],{"type":40,"tag":70,"props":3359,"children":3361},{"className":3360},[],[3362],{"type":46,"value":1804},{"type":46,"value":3364}," propagates ",{"type":40,"tag":70,"props":3366,"children":3368},{"className":3367},[],[3369],{"type":46,"value":3370},"Err",{"type":46,"value":556},{"type":40,"tag":70,"props":3373,"children":3375},{"className":3374},[],[3376],{"type":46,"value":485},{"type":46,"value":3378}," short-circuits. Mutating ",{"type":40,"tag":70,"props":3380,"children":3382},{"className":3381},[],[3383],{"type":46,"value":3384},"expr?",{"type":46,"value":2493},{"type":40,"tag":70,"props":3387,"children":3389},{"className":3388},[],[3390],{"type":46,"value":3391},"expr.unwrap()",{"type":46,"value":3393}," panics instead of returning — flag as Exception\u002FPanic mutation when tests should observe the propagated error.",{"items":3395,"total":3499},[3396,3413,3428,3446,3455,3475,3485],{"slug":3397,"name":3397,"fn":3398,"description":3399,"org":3400,"tags":3401,"stars":22,"repoUrl":23,"updatedAt":3412},"analyzing-dotnet-performance","analyze .NET code for performance anti-patterns","Scans .NET code for ~50 performance anti-patterns across async, memory, strings, collections, LINQ, regex, serialization, and I\u002FO with tiered severity classification. Use when analyzing .NET code for optimization opportunities, reviewing hot paths, or auditing allocation-heavy patterns.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3402,3405,3406,3409],{"name":3403,"slug":3404,"type":15},".NET","net",{"name":17,"slug":18,"type":15},{"name":3407,"slug":3408,"type":15},"Debugging","debugging",{"name":3410,"slug":3411,"type":15},"Performance","performance","2026-07-12T08:23:25.400375",{"slug":3414,"name":3414,"fn":3415,"description":3416,"org":3417,"tags":3418,"stars":22,"repoUrl":23,"updatedAt":3427},"android-tombstone-symbolication","symbolicate .NET runtime frames in Android tombstones","Symbolicate the .NET runtime frames in an Android tombstone file. Extracts BuildIds and PC offsets from the native backtrace, downloads debug symbols from the Microsoft symbol server, and runs llvm-symbolizer to produce function names with source file and line numbers. USE FOR triaging a .NET MAUI or Mono Android app crash from a tombstone, resolving native backtrace frames in libmonosgen-2.0.so or libcoreclr.so to .NET runtime source code, or investigating SIGABRT, SIGSEGV, or other native signals originating from the .NET runtime on Android. DO NOT USE FOR pure Java\u002FKotlin crashes, managed .NET exceptions that are already captured in logcat, or iOS crash logs. INVOKES Symbolicate-Tombstone.ps1 script, llvm-symbolizer, Microsoft symbol server.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3419,3420,3423,3424],{"name":3403,"slug":3404,"type":15},{"name":3421,"slug":3422,"type":15},"Android","android",{"name":3407,"slug":3408,"type":15},{"name":3425,"slug":3426,"type":15},"Microsoft","microsoft","2026-07-12T08:23:21.595572",{"slug":3429,"name":3429,"fn":3430,"description":3431,"org":3432,"tags":3433,"stars":22,"repoUrl":23,"updatedAt":3445},"apple-crash-symbolication","symbolicate .NET runtime frames in crash logs","Symbolicate .NET runtime frames in Apple platform .ips crash logs (iOS, tvOS, Mac Catalyst, macOS). Extracts UUIDs and addresses from the native backtrace, locates dSYM debug symbols, and runs atos to produce function names with source file and line numbers. Automatically downloads .dwarf symbols from the Microsoft symbol server using Mach-O UUIDs. USE FOR triaging a .NET MAUI or Mono app crash from an .ips file on any Apple platform, resolving native backtrace frames in libcoreclr or libmonosgen-2.0 to .NET runtime source code, retrieving .ips crash logs from a connected iOS device or iPhone, or investigating EXC_CRASH, EXC_BAD_ACCESS, SIGABRT, or SIGSEGV originating from the .NET runtime. DO NOT USE FOR pure Swift\u002FObjective-C crashes with no .NET components, or Android tombstone files. INVOKES Symbolicate-Crash.ps1 script, atos, dwarfdump, idevicecrashreport.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3434,3435,3436,3439,3442],{"name":3403,"slug":3404,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3437,"slug":3438,"type":15},"iOS","ios",{"name":3440,"slug":3441,"type":15},"macOS","macos",{"name":3443,"slug":3444,"type":15},"Observability","observability","2026-07-12T08:23:20.369986",{"slug":349,"name":349,"fn":3447,"description":3448,"org":3449,"tags":3450,"stars":22,"repoUrl":23,"updatedAt":3454},"evaluate assertion quality in test suites","Analyzes the variety and depth of assertions across test suites in any language. Use when the user asks to evaluate assertion quality, find shallow tests, identify assertion-free tests (no assertions or only trivial ones like Assert.IsNotNull \u002F toBeTruthy()), flag self-referential or tautological assertions, measure assertion diversity, or audit whether tests verify different facets of behavior. Polyglot: .NET, Python, TS\u002FJS, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, C++. DO NOT USE FOR: writing new tests (use code-testing-agent \u002F writing-mstest-tests), mutation reasoning about whether tests would catch a bug (use test-gap-analysis), or a general severity-ranked anti-pattern audit (use test-anti-patterns), fixing or rewriting assertions, or writing, fixing, or modernizing MSTest tests, assertions, or attributes (use writing-mstest-tests).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3451,3452,3453],{"name":17,"slug":18,"type":15},{"name":13,"slug":14,"type":15},{"name":20,"slug":21,"type":15},"2026-07-12T08:23:51.277743",{"slug":3456,"name":3456,"fn":3457,"description":3458,"org":3459,"tags":3460,"stars":22,"repoUrl":23,"updatedAt":3474},"author-component","create and review Blazor components","Create or review Blazor components (.razor files) with correct architecture. USE FOR: writing new Blazor components that do NOT involve JavaScript interop, implementing parameters and EventCallback, RenderFragment slots, component lifecycle (OnInitializedAsync, OnParametersSet), async patterns, IAsyncDisposable, CancellationToken, CSS isolation, code-behind. DO NOT USE FOR: creating new projects (use create-blazor-project), JavaScript interop or calling browser APIs from Blazor (use use-js-interop), forms and validation (use collect-user-input), prerendering issues (use support-prerendering), HTTP data fetching patterns (use fetch-and-send-data), coordinating state between unrelated components (use coordinate-components).\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3461,3462,3465,3468,3471],{"name":3403,"slug":3404,"type":15},{"name":3463,"slug":3464,"type":15},"Blazor","blazor",{"name":3466,"slug":3467,"type":15},"C#","csharp",{"name":3469,"slug":3470,"type":15},"UI Components","ui-components",{"name":3472,"slug":3473,"type":15},"Web Development","web-development","2026-07-15T06:03:29.216359",{"slug":3476,"name":3476,"fn":3477,"description":3478,"org":3479,"tags":3480,"stars":22,"repoUrl":23,"updatedAt":3484},"binlog-failure-analysis","analyze MSBuild binary logs","Analyze MSBuild binary logs to diagnose build failures. USE FOR: build errors that are unclear from console output, diagnosing cascading failures across multi-project builds, tracing MSBuild target execution order, and generally any MSBuild build issues. Requires an existing .binlog file. DO NOT USE FOR: generating binlogs (use binlog-generation), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3481,3482,3483],{"name":17,"slug":18,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3425,"slug":3426,"type":15},"2026-07-12T08:21:34.637923",{"slug":3486,"name":3486,"fn":3487,"description":3488,"org":3489,"tags":3490,"stars":22,"repoUrl":23,"updatedAt":3498},"binlog-generation","generate MSBuild binary logs for diagnostics","Generate MSBuild binary logs (binlogs) for build diagnostics and analysis. USE FOR: adding \u002Fbl:{} to any dotnet build, test, pack, publish, or restore command to capture a full build execution trace, prerequisite for binlog-failure-analysis and build-perf-diagnostics skills, enabling post-build investigation of errors or performance. Requires MSBuild 17.8+ \u002F .NET 8 SDK+ for {} placeholder; PowerShell needs -bl:{{}}. DO NOT USE FOR: non-MSBuild build systems (npm, Maven, CMake), analyzing an existing binlog (use binlog-failure-analysis instead).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3491,3494,3495],{"name":3492,"slug":3493,"type":15},"Build","build",{"name":3407,"slug":3408,"type":15},{"name":3496,"slug":3497,"type":15},"Engineering","engineering","2026-07-19T05:38:19.340791",96,{"items":3501,"total":3606},[3502,3514,3521,3528,3536,3542,3550,3556,3562,3572,3585,3596],{"slug":3503,"name":3503,"fn":3504,"description":3505,"org":3506,"tags":3507,"stars":3511,"repoUrl":3512,"updatedAt":3513},"multithreaded-task-migration","migrate MSBuild tasks to multithreaded mode","Guide for migrating MSBuild tasks to multithreaded mode support, including compatibility red-team review. Use this when converting tasks to thread-safe versions, implementing IMultiThreadableTask, adding TaskEnvironment support, or auditing migrations for behavioral compatibility.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3508,3509,3510],{"name":3403,"slug":3404,"type":15},{"name":3496,"slug":3497,"type":15},{"name":3410,"slug":3411,"type":15},5535,"https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fmsbuild","2026-07-22T05:37:33.965588",{"slug":3397,"name":3397,"fn":3398,"description":3399,"org":3515,"tags":3516,"stars":22,"repoUrl":23,"updatedAt":3412},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3517,3518,3519,3520],{"name":3403,"slug":3404,"type":15},{"name":17,"slug":18,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3410,"slug":3411,"type":15},{"slug":3414,"name":3414,"fn":3415,"description":3416,"org":3522,"tags":3523,"stars":22,"repoUrl":23,"updatedAt":3427},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3524,3525,3526,3527],{"name":3403,"slug":3404,"type":15},{"name":3421,"slug":3422,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3425,"slug":3426,"type":15},{"slug":3429,"name":3429,"fn":3430,"description":3431,"org":3529,"tags":3530,"stars":22,"repoUrl":23,"updatedAt":3445},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3531,3532,3533,3534,3535],{"name":3403,"slug":3404,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3437,"slug":3438,"type":15},{"name":3440,"slug":3441,"type":15},{"name":3443,"slug":3444,"type":15},{"slug":349,"name":349,"fn":3447,"description":3448,"org":3537,"tags":3538,"stars":22,"repoUrl":23,"updatedAt":3454},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3539,3540,3541],{"name":17,"slug":18,"type":15},{"name":13,"slug":14,"type":15},{"name":20,"slug":21,"type":15},{"slug":3456,"name":3456,"fn":3457,"description":3458,"org":3543,"tags":3544,"stars":22,"repoUrl":23,"updatedAt":3474},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3545,3546,3547,3548,3549],{"name":3403,"slug":3404,"type":15},{"name":3463,"slug":3464,"type":15},{"name":3466,"slug":3467,"type":15},{"name":3469,"slug":3470,"type":15},{"name":3472,"slug":3473,"type":15},{"slug":3476,"name":3476,"fn":3477,"description":3478,"org":3551,"tags":3552,"stars":22,"repoUrl":23,"updatedAt":3484},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3553,3554,3555],{"name":17,"slug":18,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3425,"slug":3426,"type":15},{"slug":3486,"name":3486,"fn":3487,"description":3488,"org":3557,"tags":3558,"stars":22,"repoUrl":23,"updatedAt":3498},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3559,3560,3561],{"name":3492,"slug":3493,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3496,"slug":3497,"type":15},{"slug":3563,"name":3563,"fn":3564,"description":3565,"org":3566,"tags":3567,"stars":22,"repoUrl":23,"updatedAt":3571},"build-parallelism","optimize MSBuild build parallelism","Diagnose and fix under-parallelized MSBuild builds. USE WHEN a multi-project solution build is slower than expected, doesn't speed up when you add cores, pegs a single core while others idle, or you want to know why `-m` isn't helping. Note: `\u002Fmaxcpucount` default is 1 (sequential) — always pass `-m` for parallel builds. Covers finding the critical path (longest serial ProjectReference chain), graph build (`\u002Fgraph`), BuildInParallel, and solution filters (`.slnf`). DO NOT USE FOR: single-project builds, incremental issues (use incremental-build), compilation slowness inside one project (use build-perf-diagnostics), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3568,3569,3570],{"name":3403,"slug":3404,"type":15},{"name":3496,"slug":3497,"type":15},{"name":3410,"slug":3411,"type":15},"2026-07-19T05:38:18.364937",{"slug":3573,"name":3573,"fn":3574,"description":3575,"org":3576,"tags":3577,"stars":22,"repoUrl":23,"updatedAt":3584},"build-perf-baseline","establish and optimize build performance baselines","Establish build performance baselines and apply systematic optimization techniques. USE FOR: diagnosing slow builds, establishing before\u002Fafter measurements (cold, warm, no-op scenarios), applying optimization strategies like MSBuild Server, static graph builds, artifacts output, and dependency graph trimming. Start here before diving into build-perf-diagnostics, incremental-build, or build-parallelism. DO NOT USE FOR: non-MSBuild build systems, detailed bottleneck analysis (use build-perf-diagnostics after baselining).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3578,3579,3582,3583],{"name":3496,"slug":3497,"type":15},{"name":3580,"slug":3581,"type":15},"Monitoring","monitoring",{"name":3410,"slug":3411,"type":15},{"name":20,"slug":21,"type":15},"2026-07-12T08:21:35.865649",{"slug":3586,"name":3586,"fn":3587,"description":3588,"org":3589,"tags":3590,"stars":22,"repoUrl":23,"updatedAt":3595},"build-perf-diagnostics","diagnose MSBuild build performance bottlenecks","Diagnose MSBuild build performance bottlenecks using binary log analysis. USE FOR: identifying why builds are slow by analyzing binlog performance summaries, detecting ResolveAssemblyReference (RAR) taking >5s, Roslyn analyzers consuming >30% of Csc time, single targets dominating >50% of build time, node utilization below 80%, excessive Copy tasks, NuGet restore running every build. Covers timeline analysis, Target\u002FTask Performance Summary interpretation, and 7 common bottleneck categories. Use after build-perf-baseline has established measurements. DO NOT USE FOR: establishing initial baselines (use build-perf-baseline first), fixing incremental build issues (use incremental-build), parallelism tuning (use build-parallelism), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3591,3592,3593,3594],{"name":3403,"slug":3404,"type":15},{"name":3407,"slug":3408,"type":15},{"name":3496,"slug":3497,"type":15},{"name":3410,"slug":3411,"type":15},"2026-07-12T08:21:40.961722",{"slug":3597,"name":3597,"fn":3598,"description":3599,"org":3600,"tags":3601,"stars":22,"repoUrl":23,"updatedAt":3605},"check-bin-obj-clash","detect MSBuild output path conflicts","Detects MSBuild projects with conflicting OutputPath or IntermediateOutputPath. USE FOR: builds failing with 'Cannot create a file when that file already exists', 'The process cannot access the file because it is being used by another process', intermittent build failures that succeed on retry, or missing\u002Foverwritten outputs in multi-project or multi-targeting builds where bin\u002Fobj (or project.assets.json) collide. Common causes: shared OutputPath, missing AppendTargetFrameworkToOutputPath, extra global properties (e.g. PublishReadyToRun), or SetTargetFramework on a ProjectReference to a single-targeting project. DO NOT USE FOR: file access errors unrelated to MSBuild (OS-level locking), single-project single-TFM builds, non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3602,3603,3604],{"name":3407,"slug":3408,"type":15},{"name":3496,"slug":3497,"type":15},{"name":13,"slug":14,"type":15},"2026-07-19T05:38:14.336279",144]