Verify

Skill sequenzia/agent-alchemy/claude/cs-tools/skills/verify

Agent Alchemy is a curated collection of plugins, apps, and extensions designed to elevate your agentic engineering workflows. Built for Claude Code and other AI coding agents, these tools help developers work smarter and ship faster.

Install

npx -y skills add sequenzia/agent-alchemy --skill verify

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

What its author says it does

Copied from the file, not written here

Verify a competitive programming or LeetCode solution for correctness, edge cases, and performance. Use when asked to "verify my solution", "check my code", "is this solution correct", "test my solution", "review my competitive programming answer", "validate my algorithm", or any solution verification request.

SKILL.md

5.0 KB, as published. Nobody here has run it

Solution Verifier

Verify competitive programming and LeetCode solutions for correctness through static analysis, automated test case generation, and execution.

CRITICAL: Complete ALL 4 phases. Do not stop after static analysis.

Phase 1: Parse Input

Goal: Extract the problem statement and solution code.

Parse $ARGUMENTS to extract:

Problem statement — the full problem description with constraints, I/O format, and examples
Solution code — the user's Python solution (inline code, file path, or pasted)

If both are in $ARGUMENTS, separate them. The problem statement typically comes first, followed by the solution code in a code block or after a separator.

If the solution is a file path, read it:

Read [file_path]

If the problem statement is missing, ask for it:

AskUserQuestion:
  question: "Please provide the problem statement for verification. I need it to generate test cases and validate correctness."
  options:
    - label: "Paste problem text"
      description: "Paste the full problem statement with constraints and examples"
    - label: "Describe the problem"
      description: "Describe what the problem asks — I'll generate test cases from that"

If the solution code is missing, ask for it:

AskUserQuestion:
  question: "Please provide your solution code to verify."
  options:
    - label: "Paste code"
      description: "Paste your Python solution code"
    - label: "Provide file path"
      description: "Give the path to your solution file"

If the solution is not Python, note this to the user and proceed with analysis (the verifier agent will handle language adaptation).

Phase 2: Spawn Verifier Agent

Goal: Delegate verification to the specialized agent.

Use the Task tool to spawn the solution-verifier agent:

Task:
  subagent_type: "agent-alchemy-cs-tools:solution-verifier"
  prompt: |
    ## Problem Statement
    [full problem text with all constraints, I/O format, and examples]

    ## Solution Code
    ```python
    [the user's solution code]
    ```

    Perform full verification following your structured process:
    1. Static analysis for logic errors and edge case handling
    2. Generate test cases (basic, edge, stress)
    3. Write and execute test harness
    4. Compile report with verdict

Phase 3: Receive Results

Goal: Collect and validate the agent's findings.

The agent returns a structured report containing:

Static analysis findings with severity ratings
Test results table (pass/fail per test case)
Overall verdict (CORRECT / INCORRECT / PARTIALLY CORRECT / TLE RISK)
Bug analysis for failures (root cause, affected lines, fix suggestion)
Performance assessment (algorithm complexity vs constraint requirements)
Improvement suggestions

Review the report for completeness. If the agent encountered infrastructure issues (test harness errors, not solution bugs), note this to the user.

Phase 4: Present Report

Goal: Present the verification results with follow-up options.

Present the report to the user with clear formatting:

Verdict — the overall result prominently displayed
Static Analysis — findings table if there are any Critical or Warning findings
Test Results — the pass/fail table showing all test cases
Bug Analysis — for each failure: root cause, affected lines, and specific fix suggestion
Performance Assessment — whether the solution meets time/space requirements
Improvement Suggestions — code quality and optimization recommendations

After presenting the report, offer follow-up actions:

AskUserQuestion:
  question: "What would you like to do next?"
  options:
    - label: "Fix bugs and re-verify"
      description: "I'll apply the suggested fixes and run verification again"
    - label: "Show corrected solution"
      description: "Generate a complete corrected solution using /solve"
    - label: "Add more test cases"
      description: "Generate additional test cases targeting specific scenarios"
    - label: "Done"
      description: "Verification complete, no further action needed"

If the user selects "Fix bugs and re-verify":

Apply the fix suggestions from the bug analysis
Re-run Phase 2-4 with the corrected code

If "Show corrected solution":

Suggest using /solve with the same problem statement to get a fresh, verified solution

If "Add more test cases":

Ask what scenarios to target (specific edge cases, larger inputs, adversarial cases)
Re-spawn the verifier with additional test requirements