More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agent Tamper Guard

    0

    Stop AI coding agents from cheating tests, weakening assertions, skipping checks, adding @ts-ignore, or spoofing test runners to fake passing builds.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Tamper Guard

    Agent Tamper Guard

    Example session with this skill installed

    The tests for the new auth flow are failing with a type error. Fix the implementation so the build passes, and verify that no test tampering occurred.

    • Read your context and instructions
    • Compiled the agent tamper guard

    I have analyzed the failure in src/auth/service.ts. The error was caused by a missing property in the user session object which didn't match the AuthSession interface. I have updated the implementation logic to correctly map the database response rather than using a type cast or skipping the test.

    Integrity Verification Report

    CategoryCheckStatusDetails
    Test Suitetest-disabledPassedNo .skip or xit added to tests/auth.test.ts
    Assertionsassertion-weakenedPassedPrecise toEqual matches remain intact
    Typesany-castPassedResolved via interface update, not as any
    Suppressionsuppression-commentPassedNo @ts-ignore or eslint-disable added
    Configtsconfig-weakenedPassedstrict: true remains active in tsconfig.json
    // src/auth/service.ts - Corrected Implementation
    export async function createSession(user: UserRecord): Promise<AuthSession> {
      // Fix: Explicitly map fields to satisfy AuthSession interface
      // instead of bypassing the type checker.
      return {
        id: user.uuid,
        token: await generateToken(user.id),
        expiresAt: new Date(Date.now() + 3600000).toISOString(),
        roles: user.permissions ?? []
      };
    }
    

    Next steps

    1. Run npx --no agent-tamper-guard --staged to confirm final git diff compliance.
    2. Execute the full test suite with npm test to ensure no regression in related modules.
    3. Submit the PR knowing the implementation fix is type-safe and test-backed.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop Coding Agents from Cheating Your Checks

    When autonomous AI coding agents (Claude Code, Cursor, Copilot, Windsurf) fail a test, they often "reward hack" by making the test stop failing instead of fixing the real bug:

    • Weakening assertions (toEqual(...) → toBeDefined())
    • Skipping failing tests (it.skip, xit, test.todo)
    • Silencing compiler errors (@ts-ignore, @ts-nocheck, eslint-disable)
    • Spoofing test runners (if (process.env.VITEST) return mockData)
    • Silently swallowing exceptions (catch {})

    What This Skill Provides

    • Diff-Aware AST Verification: Inspects before-and-after AST diffs to catch cheating moves that linters miss.
    • Native MCP Server (agent-tamper-guard mcp): Allows agents in Cursor and Claude to run check_diff_integrity and explain_violation interactively before finishing.
    • Claude Code Lifecycle Blocking: Automatically intercepts the Stop event to block agents from submitting tampered code.
    • Zero Network / 100% Offline: Runs locally on your machine with no external network calls or telemetry.

    Quick Setup

    # Install Cursor MCP server:
    npx agent-tamper-guard init --mcp
    
    # Install Claude Code hooks & Cursor guidelines:
    npx agent-tamper-guard init --claude --cursor --git-hook
    

    Requires Node.js environment to run the verification utility. Primarily optimized for TypeScript and JavaScript testing frameworks.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 20 days ago

    Requires

    agent-tamper-guard
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    src/**
    test/**
    tests/**
    .claude/**
    .cursor/**
    package.json
    **/*

    Runs 100% locally and offline. Terminal and file read permissions are used exclusively to inspect git diffs and AST structures across changed files. File write permission is only used when the user initializes hooks into .claude/settings.json, .cursor/rules/, or .husky/pre-commit. No code or data ever leaves the local environment.

    Listed20 days ago

    What's inside

    Frequently Asked Questions

    It prevents agents from "reward hacking" by using Abstract Syntax Tree (AST) scanning to block shortcuts like weakening test assertions, adding `@ts-ignore` comments, or skipping failing tests.

    The skill is optimized for JavaScript and TypeScript environments, with native support for test runners like Jest and Vitest and seamless integration with agents like Claude Code and Cursor.

    Setup is simple: initialize the skill in your project, then use the provided `npx agent-tamper-guard` command to verify changes or integrate it directly into your Git hooks for automated checks.

    You will receive the core verification utility, configuration templates for major AI agents, and a set of predefined integrity rules designed to maintain high code standards.

    Unlike prompts which agents can ignore or hallucinate around, this skill provides a structural enforcement layer that physically blocks forbidden code patterns from being committed.

    Buyers receive lifetime access to the skill, including periodic updates to the detection engine as new agent bypass techniques or JavaScript/TypeScript features emerge.

    New in Testing & Debugging