More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    triage trip

    1

    >-Automates the triage of AI-introduced regressions by linking runtime errors with your local git history and AI prompt metadata to generate precise, minimal patch fixes.

    Free

    Security scanned
    triage trip

    triage trip

    Example session with this skill installed

    The build failed with "ReferenceError: user_id is not defined" in src/services/auth.ts after I let Cursor refactor the login flow. Find the break and fix it.

    • Read your context and instructions
    • Compiled the triage trip

    I have analyzed the git diff and Cursor prompt history. The regression was caused by a prompt at 14:22:10 which renamed the user_id property to userId in the Session interface but failed to update the reference in auth.ts.

    Triage Report

    CategoryDetails
    Root Causesrc/services/auth.ts line 42
    Attributed Prompt"Refactor session handling to use camelCase for all user properties"
    The Shiftuser_id (deprecated) → userId (current)
    ActionUpdate caller to match the new schema
    --- a/src/services/auth.ts
    +++ b/src/services/auth.ts
    @@ -39,7 +39,7 @@
     export const validateSession = (session: Session) => {
    -  if (!session.user_id) {
    +  if (!session.userId) {
         throw new Error("Invalid session");
       }
    

    Next steps

    1. Run git apply to fix the reference error.
    2. Verify the fix by running the build command.
    3. Review git diff to ensure no other callers were missed.

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

    About this skill

    Fixing regressions introduced by AI coding assistants is tedious. When Cursor or Copilot refactors a file, it often breaks API contracts, renames schema fields, or drops function parameters without updating callers. This skill automates the triage process by linking runtime errors directly to the breaking git diff and the specific AI prompt that caused it.

    What it does

    • Capture errors by parsing runtime stack traces or build failure logs provided by the user.
    • Analyze git context by inspecting staged changes, working tree diffs, and the last five commits.
    • Trace prompt provenance by querying local Cursor metadata to identify which specific prompt triggered the regression.
    • Diagnose shifts by identifying mismatches between old and new contracts, such as userId becoming user_id.
    • Generate patches in a minimal unified diff format to restore functionality without bloat.

    How it works

    1. Context gathering: The agent runs git diff and a local script to extract recent Cursor prompts from the SQLite database.
    2. Root cause analysis: It applies a diagnosis rubric to map the error to a specific line of code and a recent change.
    3. Patch emission: It generates a precise unified diff that aligns callers with the updated schema.
    4. Application: The agent presents a four-section report and waits for user confirmation before applying the fix via git apply.

    Frameworks & tools

    This skill requires a local git repository and Node.js (18+). It utilizes sqlite3 for prompt history retrieval and works with standard unified diff tools.

    Why this beats prompting it yourself

    Standard prompts often suggest generic fixes or defensive null checks that mask the real issue. This skill systematically correlates your local git history with AI metadata to find the exact "intent shift" that broke the build, ensuring the fix addresses the root cause rather than just the symptom.

    Use cases

    • Debugging a TypeError immediately after an AI-driven refactor.
    • Identifying which specific Cursor Composer prompt broke a TypeScript interface.
    • Resolving "variable not defined" errors caused by AI renaming local exports.
    • Generating a minimal patch to fix breaking schema changes in a monorepo.

    Known limitations

    Requires a git repository for diff analysis. Cursor prompt retrieval is best-effort and depends on local sqlite3 availability. Does not replace the need for running a full test suite after patching.

    Requires a git repository for diffs. Cursor prompt provenance is best-effort and requires local sqlite3. Native path does not use external APIs. Requires Node 18+ for prompt extraction.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 20 days ago

    • Free with an Agensi account

    Requires

    triage-trip
    Node.js
    Git

    Permissions

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

    What's inside

    Frequently Asked Questions

    The skill acts as a bridge between your local environment and your development history. It parses runtime stack traces, analyzes recent git diffs, and queries Cursor's local metadata to pinpoint exactly which prompt and code change caused a specific regression.

    While optimized for Cursor users to leverage prompt history, the core triage and patching functionality works with any AI-generated code as long as the project is in a git repository. Even without Cursor metadata, it can still map errors to recent git diffs to generate patches.

    You will receive the 'triage trip' agent skill file, a local Node.js helper script for metadata extraction, and comprehensive documentation for integration. The purchase includes all logic required to analyze, diagnose, and patch AI-introduced errors locally.

    The agent generates a detailed four-section report for your review before any changes are made. It will only apply the suggested unified diff via 'git apply' after you have inspected the diagnosis and explicitly confirmed the patch.

    You need a local git repository, Node.js (version 18 or higher), and sqlite3 installed on your system. These tools allow the skill to interact with your version control and extract the necessary metadata from your local development environment.

    Yes, by analyzing the 'intent shift' between your previous and current code states, the skill can detect when an AI has renamed schema fields or changed API contracts. It then generates a minimal patch to align your callers with the new structure.

    New in Testing & Debugging