Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agent Pre-Commit Diff Scrutinizer

    1

    Senior Tech Lead pre-commit gatekeeper. Audits AI git diffs against 6 non-negotiable invariants.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Pre-Commit Diff Scrutinizer

    Agent Pre-Commit Diff Scrutinizer

    Example session with this skill installed

    Audit this git diff before I commit

    diff --git a/src/auth/session.py b/src/auth/session.py
    --- a/src/auth/session.py
    +++ b/src/auth/session.py
    @@ -14,2 +14,3 @@

    -def verify_jwt(token: str) -> User:
    +def verify_jwt(token: str) -> Any: # type: ignore
    
    • skip expired check for hotfix

    • return get_user_mock()
      diff --git a/tests/test_session.py b/tests/test_session.py
      --- a/tests/test_session.py
      +++ b/tests/test_session.py
      @@ -30,5 +30,2 @@
      -def test_jwt_expiry_enforced():
    • with pytest.raises(TokenExpiredError):
    •    verify_jwt(EXPIRED_TOKEN)
      

    +@pytest.mark.skip(reason="temp fix")
    +def test_jwt_expiry_enforced(): pass

    • Read your context and instructions
    • Compiled the agent pre-commit diff

    AGENT PRE-COMMIT DIFF AUDIT REPORT

    Gate Status: [FAIL] (Pre-Commit Blocked)
    Files Evaluated: 2 | Blocking Violations: 4 | Warnings: 1

    1. Invariant Evaluation Checklist

    #InvariantStatusFindings
    1Lint & Type Suppressions[X] FAILEDUnjustified # type: ignore added at session.py:14
    2Test Preservation[X] FAILEDStripped assertions & @pytest.mark.skip added at test_session.py:30
    3Scope Boundary Defense[X] FAILEDMock return get_user_mock() bypasses production auth core
    4Security Invariants[!] WARNToken expiration enforcement removed

    2. Remediation Directives

    • Revert: Remove @pytest.mark.skip from tests/test_session.py.
    • Type Safety: Replace Any: # type: ignore with explicit union type User | GuestSession.
    • Pre-commit clearance: Run python scripts/diff_scrutinizer.py --strict to verify clean pass before pushing.

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

    About this skill

    Agent Pre-Commit Diff Scrutinizer: Deterministic AI Diff Guard (v2.2.0)

    When autonomous coding agents (Claude Code, Cursor, Windsurf, Cline) generate code rapidly, they frequently introduce subtle compensatory regressions:

    • Silently deleting or skipping unit tests to force failing CI builds green.
    • Introducing unsanctioned # type: ignore or eslint-disable suppressions without issue tracking rationale.
    • Silently removing defensive error handling or authentication checks.
    • Leaking API keys, tokens, or modifying critical CI/CD workflows out of task scope.

    This skill acts as an automated Senior Tech Lead pre-commit gatekeeper, enforcing 6 non-negotiable architectural and safety invariants before code reaches your repository.


    What This Skill Enforces (The 6 Invariants):

    1. Lint & Type Suppressions: Blocks uncoordinated @ts-ignore, eslint-disable, # noqa, or # type: ignore without explicit rationale.
    2. Test Preservation: Catches test deletions, skipped suites (@pytest.mark.skip, it.skip), and stripped assertions.
    3. Scope Boundary Defense: Rejects out-of-scope edits outside target directories.
    4. Credential & Secret Guard: Detects high-entropy keys, private tokens, and .env files before commit.
    5. Quality Gate Integrity: Blocks attempts to weaken test runners, thresholds, or linter configs.
    6. Lockfile & Dependency Safety: Flags unexpected additions to lockfiles without package manifest justification.

    Included Production Assets:

    • SKILL.md: Universal agent instructions adhering to open skill standards.
    • scripts/diff_scrutinizer.py: Zero-dependency, offline CLI engine (Python 3.8+ stdlib).
    • templates/pre_commit_hook.sh: Git pre-commit hook template.
    • templates/github_ci.yml: Reusable GitHub Actions workflow for PR gatekeeping.
    • references/diff_invariants.md: Comprehensive rule catalog with rationale and remediation.
    • references/agent_eval_matrix.md: Rubric for evaluating autonomous agent diff quality.

    Built by Conversionlogic (https://conversion-logic.github.io/)

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Heuristic analysis most effective for JS/TS/Python. Dependency checks limited to npm, pip, and poetry. Not a replacement for full CI or dedicated secret scanners like gitleaks.

    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 buying a skill.

    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 15 days ago

    Software
    PythonGit

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Listed15 days ago

    What's inside

    Frequently Asked Questions

    This skill addresses the 'hallucination' problem where AI agents may delete complex tests or bypass type checks to force a task to pass. It provides a deterministic, non-negotiable audit layer that prevents agents from quietly lowering your code quality or leaking secrets.

    The tool is agent-agnostic and works with any AI coding assistant (like Cursor, GitHub Copilot Workspace, or Devin) as long as you have access to the local Git repository. It functions as a pre-commit or pre-PR gate that scrutinizes the agent's output before it is finalized.

    Setup is minimal; you only need Python 3.8+ installed. You simply add the standalone script to your repository and call it via your existing git hooks or CI pipeline to start enforcing the six core invariants.

    You will receive the core Python audit engine, a pre-configured git hook template, and a documentation guide on remediating the specific violations the tool flags. No third-party libraries are required for the script to function.

    While the tool provides a high degree of security by catching hardcoded keys and tokens, it is designed as a fast pre-commit check rather than a comprehensive secrets management suite. We recommend using it alongside tools like Gitleaks for a full defense-in-depth strategy.

    The engine is optimized for Python, JavaScript, and TypeScript, where it can precisely identify specific lint suppressions and type ignores. It offers partial support for Go, Rust, Java, and Ruby, primarily focusing on secret detection and test preservation.

    New in Code Quality & Review