Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Repository Investigation

    1

    Conducts a read-only audit of a repository to verify ticket claims and document current architecture before planning.

    $4.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Repository Investigation

    Repository Investigation

    Example session with this skill installed

    Investigate the repository for ticket PROJ-123: 'Add new error code for expired session in ErrorCode.java'. The ticket says it should go in the core error module.

    • Read your context and instructions
    • Compiled the repository investigation

    I have completed the repository investigation for ticket PROJ-123. I located the relevant error handling components and verified the existing patterns for session-related exceptions.

    repositoryContext

    {
      "inspectedFiles": [
        {
          "path": "backend/src/main/java/com/example/app/core/error/ErrorCode.java",
          "relevantBecause": "Primary file mentioned in the ticket for adding new error codes."
        },
        {
          "path": "backend/src/main/java/com/example/app/core/auth/SessionManager.java",
          "relevantBecause": "Checked for existing session expiration logic to ensure consistency."
        },
        {
          "path": "backend/src/test/java/com/example/app/core/error/ErrorCodeTest.java",
          "relevantBecause": "Read to understand how new error codes are currently validated."
        }
      ],
      "existingConventions": [
        "Error codes follow a prefixed naming convention: AUTH_*, DB_*, API_*.",
        "ErrorCode enum entries include an HTTP status mapping and a default message."
      ],
      "architectureBoundaries": [
        "The core error module is shared across all backend services.",
        "Changes here affect the global API response contract."
      ],
      "verifiedFacts": [
        "ErrorCode.java exists at the path specified and contains 45 existing codes.",
        "There is currently no SESSION_EXPIRED or similar code in the enum.",
        "SessionManager.java throws a generic AuthException when a session is null."
      ],
      "assumptions": [
        "The ticket implies the new code should follow the AUTH_ prefix, though not explicitly stated."
      ],
      "notInspected": [
        "Frontend error mapping components were not inspected as the ticket focuses on backend definitions."
      ],
      "unresolvedQuestions": [
        "Should we also update SessionManager to throw this specific new code, or just define the code for future use?",
        "Does this new code require a corresponding localization update in the messages bundle?"
      ]
    }
    

    Next steps

    1. Confirm if the AUTH_ prefix is appropriate for the new SESSION_EXPIRED code.
    2. Decide if SessionManager should be refactored to use the new code immediately.
    3. Proceed to implementation planning using the verified ErrorCode.java structure.

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

    About this skill

    Assumptions about a codebase lead to broken builds and wasted sprints. This skill forces a rigorous, read-only audit of the repository to establish what is true right now before a single line of code is written. It validates claims made in tickets against the actual files, tests, and architectural boundaries currently in place.

    What it does

    • Anchor extraction identifies package, class, and file names from ticket context to use as search targets.
    • Deep discovery searches by behavior and feature area if literal names from the ticket are missing or renamed.
    • Pattern identification reads neighboring implementations and tests to document existing conventions and abstractions.
    • Boundary mapping notes whether changes impact core modules, feature-specific folders, or frontend/backend splits.
    • Fact verification strictly separates verified findings from inferences to prevent implementation based on guesswork.

    How it works

    1. Analyze input to extract concrete anchors from the ticket summary and description.
    2. Locate components by searching the local checkout for literal matches or behavioral equivalents.
    3. Audit surrounding code to understand established conventions and architecture boundaries.
    4. Generate report using the repositoryContext schema, documenting facts, assumptions, and risks.

    Frameworks & tools

    This skill is language-agnostic and works with any repository structure. It relies on local file system access and basic search capabilities to inspect source code, tests, and configuration files.

    Why this beats prompting it yourself

    Manual prompting often results in the LLM hallucinating file contents or assuming a ticket's claims are accurate. This skill enforces a "read-only" constraint and a strict verifiedFacts vs assumptions classification that prevents planning on stale mental models.

    Use cases

    • Auditing a legacy codebase to find where a specific feature actually lives.
    • Validating if a bug report's suggested fix location is the correct architectural boundary.
    • Identifying reusable abstractions before implementing a new feature to avoid duplication.

    Known limitations

    Requires a locally checked out and readable repository. It cannot perform edits or create new files, as it is strictly restricted to read-only investigation.

    Requires a locally checked out and readable repository. Does not perform edits, creations, or deletions. Limited to files that can be located via name or behavior search.

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

    Requires

    Git

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    File Scopes

    **/*

    Read-only — never edits, creates, or deletes any file, regardless of what it finds.

    Listed18 days ago

    What's inside

    Frequently Asked Questions

    This skill prevents "hallucinated planning" by forcing the agent to verify file existence and architectural patterns before proposing changes, ensuring that development plans are based on actual code rather than outdated ticket descriptions.

    The skill is language-agnostic and works with any repository structure, as it relies on universal search patterns and behavioral discovery rather than specific language compilers.

    No, this is a read-only audit tool; it is strictly restricted to inspecting source code and configuration files to ensure your codebase remains untouched during the investigation phase.

    You will receive the core skill logic, the standardized 'repositoryContext' reporting schema, and integration documentation to connect it to your preferred agentic framework.

    The skill requires the repository to be checked out locally and readable by your AI agent's environment, as it performs direct file system inspection to verify facts.

    While standard prompting relies on the LLM's internal memory, this skill enforces a strict classification of 'Verified Facts' versus 'Inferences,' requiring the agent to prove its claims with file-level evidence.

    New in Agents & Orchestration