code walkthrough

    1

    Follow a traceable execution path through source code with file references and verified snippets.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    code walkthrough

    Example session with this skill installed

    Explain how a user login request is handled in this repo, starting from the auth controller.

    • Read your context and instructions
    • Compiled the code walkthrough

    I have traced the login flow from the initial request through to the session creation. This walkthrough identifies the validation logic, the database query, and the specific error handler for invalid credentials.

    Login Request Walkthrough

    StepFileSymbol/ReferenceDescription
    1. Entrysrc/controllers/auth.tsAuthController.loginReceives POST request, extracts email and password.
    2. Validatesrc/middleware/validate.tsloginSchemaJoi schema validation. Rejects if email format is invalid.
    3. Querysrc/services/user.tsUserService.findByEmailQueries Postgres. Returns null if user not found.
    4. Verifysrc/utils/crypto.tsverifyPasswordCompares hashed password using bcrypt.compare.
    5. Tokensrc/lib/jwt.tsgenerateTokenSigns a new JWT with user ID and 24h expiry.

    Source Snippet: Validation Logic

    // src/middleware/validate.ts line 12
    export const loginSchema = Joi.object({
      email: Joi.string().email().required(),
      password: Joi.string().min(8).required(),
    });
    

    Example Trace

    1. Input: { "email": "dev@example.com", "password": "password123" }
    2. Transformation: auth.ts passes payload to loginSchema.
    3. Database: UserService returns user object with ID usr_99.
    4. Outcome: HTTP 200 with Authorization: Bearer <token>.

    Key Invariants

    • Password comparison only occurs if the user record exists in the database.
    • JWT secret is loaded from environment variables during the sign step.

    Unknowns

    • src/lib/jwt.ts uses an external library for signing; the internal implementation of jsonwebtoken was not inspected.

    Next steps

    1. Review src/services/user.ts to see how connection pooling is handled.
    2. Inspect tests/integration/auth.test.ts to see how the invalid password case is tested.

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

    About this skill

    Onboarding to a new codebase is slow and error-prone. This skill prevents the "wall of text" explanation by forcing a traceable execution path through actual source files. It stops the agent from guessing how code works and requires it to cite specific files, symbols, and line references.

    What it does

    • Traceable execution follows the logic flow from entry points like requests, commands, or events in chronological order.
    • Source verification extracts actual snippets from the repository rather than generating hallucinations from memory.
    • Static analysis separation distinguishes between observed implementation details and inferred developer intent.
    • Context mapping provides a flow map and identifies key invariants that must hold true across the path.
    • Evidence-based tracing tracks inputs through transformations and error handling, linking back to existing tests.

    How it works

    1. Identify the entry point and inspect the repository structure to locate relevant files.
    2. Follow the execution path, documenting dependencies and outputs at each step.
    3. Extract and cite code snippets for every critical logic gate or transformation.
    4. Produce a flow map including a concrete example trace and identified unknowns.

    Frameworks & tools

    This skill is language-agnostic and works with any repository reachable via the agent's file system tools. It relies on static analysis of source files and test suites.

    Why this beats prompting it yourself

    Standard prompts often result in high-level summaries that skip over edge cases or hallucinate function names. This skill enforces a strict linear walkthrough pattern that requires the agent to prove its logic with line-level evidence.

    Use cases

    • Onboarding developers to complex legacy modules by tracing a single successful request.
    • Debugging logic by following an input path to identify exactly where validation or transformation fails.
    • Audit preparation by mapping how sensitive data moves from an API endpoint to a database.
    • Code review of large PRs to understand the actual runtime impact of new logic flows.

    Known limitations

    This skill does not execute code and relies on static analysis. It is not designed to perform code edits or refactors. Snippets are filtered to avoid leaking secrets.

    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.

    Only performs static analysis, not execution. Cannot be used to modify code. Requires access to source files. Scope is limited to the provided repository context.

    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

    1 use

    Times used to date

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    • Free with an Agensi account

    Permissions

    Read Files
    Listed24 days ago

    What's inside

    Frequently Asked Questions

    Standard prompts often generate generalized summaries; this skill forces the agent to use a linear, evidence-based tracing pattern that requires file-level citations and actual code snippets for every logic gate.

    The skill is language-agnostic and works with any repository accessible via your agent's file system, relying on static analysis of source files and test suites rather than runtime execution.

    This skill is designed for AI agents with file-system access; simply import the skill into your agent's library and point it toward the entry point of the codebase you wish to analyze.

    No, this skill is strictly for analysis and tracing; it identifies logic flows and documents invariants but does not perform code edits, refactors, or direct modifications to your files.

    You receive the full skill definition including the tracing logic, documentation on integration, and any future version updates released by the developer.

    The skill includes built-in filtering to prevent the extraction of sensitive strings, ensuring that only relevant logic and symbol references are used in the walkthrough.

    New in Code Quality & Review

    Free