skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
aaronontheweb/dotnet-skills605 installs

dotnet-slopwatch

Use Slopwatch to detect LLM reward hacking in .NET code changes. Run after every code modification to catch disabled tests, suppressed warnings, empty catch blocks, and other shortcuts that mask real problems.

How do I install this agent skill?

npx skills add https://github.com/aaronontheweb/dotnet-skills --skill dotnet-slopwatch
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    This skill provides documentation and instructions for using 'Slopwatch', a .NET tool designed to detect and prevent 'slop' (low-quality shortcuts) in LLM-generated code changes. It outlines installation steps, baseline setup, and integration with development environments through hooks.

  • Socketpass

    No alerts

  • Snykwarn

    Risk: MEDIUM · 1 issue

  • Runlayerwarn

    1/1 file flagged

  • ZeroLeakspass

    Score: 93/100 · 2 sections analyzed

What does this agent skill do?

Slopwatch: LLM Anti-Cheat for .NET

When to Use This Skill

Use this skill constantly. Every time an LLM (including Claude) makes changes to:

  • C# source files (.cs)
  • Project files (.csproj)
  • Props files (Directory.Build.props, Directory.Packages.props)
  • Test files

Run slopwatch to validate the changes don't introduce "slop."

What is Slop?

"Slop" refers to shortcuts LLMs take that make tests pass or builds succeed without actually solving the underlying problem. These are reward hacking behaviors - the LLM optimizes for apparent success rather than real fixes.

Common Slop Patterns

PatternExampleWhy It's Bad
Disabled tests[Fact(Skip="flaky")]Hides failures instead of fixing them
Warning suppression#pragma warning disable CS8618Silences compiler without fixing issue
Empty catch blockscatch (Exception) { }Swallows errors, hides bugs
Arbitrary delaysawait Task.Delay(1000);Masks race conditions, makes tests slow
Project-level suppression<NoWarn>CS1591</NoWarn>Disables warnings project-wide
CPM bypassVersion="1.0.0" inlineUndermines central package management

Never accept these patterns. If an LLM introduces slop, reject the change and require a proper fix.


Installation

As a Local Tool (Recommended)

Add to .config/dotnet-tools.json:

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "slopwatch.cmd": {
      "version": "0.4.2",
      "commands": ["slopwatch"],
      "rollForward": false
    }
  }
}

Then restore:

dotnet tool restore

As a Global Tool

dotnet tool install --global Slopwatch.Cmd

First-Time Setup: Establish a Baseline

Before using slopwatch on an existing project, create a baseline of current issues:

# Initialize baseline from existing code
slopwatch init

# This creates .slopwatch/baseline.json
git add .slopwatch/baseline.json
git commit -m "Add slopwatch baseline"

Why baseline? Legacy code may have existing issues. The baseline ensures slopwatch only catches new slop being introduced, not pre-existing technical debt.


Usage During LLM Sessions

After Every Code Change

Run slopwatch after any LLM-generated code modification:

# Analyze for new issues (uses baseline)
slopwatch analyze

# Use strict mode - fail on warnings too
slopwatch analyze --fail-on warning

When Slopwatch Flags an Issue

Do not ignore it. Instead:

  1. Understand why the LLM took the shortcut
  2. Request a proper fix - be specific about what's wrong
  3. Verify the fix doesn't introduce different slop
# Example: LLM disabled a test
❌ SW001 [Error]: Disabled test detected
   File: tests/MyApp.Tests/OrderTests.cs:45
   Pattern: [Fact(Skip="Test is flaky")]

# Correct response: Ask for actual fix
"This test was disabled instead of fixed. Please investigate why
it's flaky and fix the underlying timing/race condition issue."

Updating the Baseline (Rare)

Only update the baseline when slop is truly justified and documented:

# Add current detections to baseline (use sparingly!)
slopwatch analyze --update-baseline

Justification examples:

  • Third-party library forces a pattern (e.g., must suppress specific warning)
  • Intentional delay for rate limiting (not test flakiness)
  • Generated code that can't be modified

Document why in a code comment when updating baseline.


Claude Code Hook Integration

Add slopwatch as a hook to automatically validate every edit. Create or update .claude/settings.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "slopwatch analyze -d . --hook",
            "timeout": 60000
          }
        ]
      }
    ]
  }
}

The --hook flag:

  • Only analyzes git dirty files (fast, even on large repos)
  • Outputs errors to stderr in readable format
  • Blocks the edit on warnings/errors (exit code 2)
  • Claude sees the error and can fix it immediately

CI/CD Integration

Add slopwatch to your CI pipeline as a quality gate:

GitHub Actions

jobs:
  slopwatch:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'

      - name: Install Slopwatch
        run: dotnet tool install --global Slopwatch.Cmd

      - name: Run Slopwatch
        run: slopwatch analyze -d . --fail-on warning

Azure Pipelines

- task: DotNetCoreCLI@2
  displayName: 'Install Slopwatch'
  inputs:
    command: 'custom'
    custom: 'tool'
    arguments: 'install --global Slopwatch.Cmd'

- script: slopwatch analyze -d . --fail-on warning
  displayName: 'Slopwatch Analysis'

Detection Rules

RuleSeverityWhat It Catches
SW001ErrorDisabled tests (Skip=, Ignore, #if false)
SW002WarningWarning suppression (#pragma warning disable, SuppressMessage)
SW003ErrorEmpty catch blocks that swallow exceptions
SW004WarningArbitrary delays in tests (Task.Delay, Thread.Sleep)
SW005WarningProject file slop (NoWarn, TreatWarningsAsErrors=false)
SW006ErrorCPM bypass (VersionOverride, inline Version attributes)

Configuration

Create .slopwatch/config.json to suppress a rule for specific paths, with a justification:

{
  "suppressions": [
    {
      "ruleId": "SW002",
      "pattern": "**/Generated/**",
      "justification": "Generated code from tooling cannot be manually changed"
    }
  ],
  "globalSuppressions": []
}

Use -c or --config to point at a config file elsewhere, and --exclude to leave paths out of analysis entirely:

slopwatch analyze -d . --config path/to/config.json
slopwatch analyze -d . --exclude "**/Generated/**,**/obj/**,**/bin/**"

Suppressing a Single Finding in Code

Config suppressions cover whole paths. When one line or declaration is the exception, suppress it in the code instead. All in-code forms require a justification of at least 20 characters — a shorter one is silently ignored and the finding still reports.

Inline comment — covers the line it sits on and the next line:

// slopwatch-ignore: SW004 Testing rate limiter behavior requires actual time delays
await Task.Delay(1000);

A trailing comment on the same line works too. It must be a // comment; /* */ is not parsed.

Block comment — covers a range:

// slopwatch-ignore-start: SW002 Legacy interop requires suppressing obsolete API warnings
#pragma warning disable CS0618
public void CallObsoleteApi() { ... }
#pragma warning restore CS0618
// slopwatch-ignore-end

Attribute — covers the nearest enclosing declaration:

[SlopwatchSuppress(
    "SW021",
    "COM interop requires late-bound dispatch through IDispatch",
    "Interop")]
public void CallComObject(dynamic comObject) { ... }

XML comment — for .csproj, .props, .targets, on the line directly above the element:

<!-- slopwatch-ignore: SW005 This legacy project requires warnings disabled to build -->
<NoWarn>$(NoWarn);CS1591</NoWarn>

Placement Rules That Bite

These are the mistakes that make a suppression silently do nothing:

  • The comment must sit above the reported line, not the declaration. SW003 reports the catch keyword line, so a comment above the method signature does not suppress it. SW001 reports the Skip/Ignore attribute line, so the comment goes above the attribute.
  • A class-level attribute does not reach into its methods. Scope is the nearest enclosing declaration. Put the attribute on the method that contains the finding.
  • Stacking two comments does not suppress two rules on one line. Each comment covers only its own line and the next, so the outer one stops short. Use the attribute or a block instead.
  • An unterminated slopwatch-ignore-start suppresses nothing.
  • Rule IDs must be SW### — SW001, not sw1. Matching is case-insensitive, and extra whitespace is fine.

The Attribute Without the Package

The attribute is matched by name, not type identity, so a project can declare a local stub instead of referencing the Slopwatch package:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
internal sealed class SlopwatchSuppressAttribute(string ruleId, string reason) : Attribute
{
    public string RuleId { get; } = ruleId;
    public string Reason { get; } = reason;
}

This is common in test projects that don't otherwise depend on Slopwatch. The tradeoff: the real constructor validates the rule ID, justification length, category, and rejects generic justifications like "false positive". A stub validates nothing, so a typo'd rule ID or a lazy justification silently does nothing.

When you are the LLM being blocked: a suppression is not a fix. Reach for one only when the pattern is genuinely legitimate — platform-specific code, interop, generated code, or a test that must exercise real timing. Never add a suppression to make a failing check go away.

Strict Mode (Recommended for LLM Sessions)

For maximum protection during LLM coding sessions, fail on warnings as well as errors:

slopwatch analyze -d . --fail-on warning

The Philosophy: Zero Tolerance for New Slop

  1. Baseline captures legacy - Existing issues are acknowledged but isolated
  2. New slop is blocked - Any new shortcut fails the build/edit
  3. Exceptions require justification - If you must update baseline, document why
  4. LLMs are not special - The same rules apply to human and AI-generated code

The goal is to prevent the gradual accumulation of technical debt that occurs when LLMs optimize for "make the test pass" rather than "fix the actual problem."


Quick Reference

# First time setup
slopwatch init
git add .slopwatch/baseline.json

# After every LLM code change
slopwatch analyze

# Strict mode (recommended)
slopwatch analyze --fail-on warning

# With stats (performance debugging)
slopwatch analyze --stats

# Update baseline (rare, document why)
slopwatch analyze --update-baseline

# JSON output for tooling
slopwatch analyze --output json

When to Override (Almost Never)

The only valid reasons to update baseline or disable a rule:

ScenarioActionRequired
Third-party forces patternUpdate baselineCode comment explaining why
Generated code (not editable)Add to exclude listDocument in config
Intentional rate limiting delayUpdate baselineCode comment, not in test
Legacy code cleanupOne-time baseline updatePR description

Invalid reasons:

  • "The test is flaky" → Fix the flakiness
  • "The warning is annoying" → Fix the code
  • "It works on my machine" → Fix the race condition
  • "We'll fix it later" → Fix it now

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/aaronontheweb/dotnet-skills/dotnet-slopwatch">View dotnet-slopwatch on skillZs</a>