code review lite

    1

    Senior engineer code reviews for security, logic, and performance with actionable fixes and test plans.

    Free

    1 installSecurity scanned

    Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseOpenClawOpenClaw+21 more

    code review lite

    Example session with this skill installed

    Review this Python snippet for a custom cache decorator:

    def cache(func):
    data = {}
    def wrapper(*args):
        if args in data:
            return data[args]
        result = func(*args)
        data[args] = result
        return result
    return wrapper
    • Read your context and instructions
    • Compiled the code review lite
    • Generated the document

    I have reviewed the cache decorator snippet. The analysis focuses on memory management, thread safety, and key collision risks.

    Code Review Report

    Review Scope: Single-file Python decorator implementation.
    Assumptions: Target environment is a multi-threaded web server; args are expected to be hashable.

    SeverityLocationIssueImpactFix
    Criticaldata = {}Unbounded CacheMemory exhaustion (OOM) as the dictionary grows indefinitely.Use collections.deque or cachetools.TTLCache to limit size.
    WarningwrapperThread SafetyRace conditions in multi-threaded environments during read/write.Implement a threading.Lock() around dictionary access.
    Warningdata[args]Key CollisionsUsing args as a key ignores kwargs, leading to incorrect hits.Use functools._make_key to include both args and kwargs.
    Suggestiondata scopePersistenceCache is lost on reload; no persistence layer.Wrap with a decorator that supports a Redis or disk backend.

    Positive Observations

    • Simplicity: The closure implementation is clean and avoids unnecessary external dependencies for basic use cases.
    • Logic: The check-then-act flow is correctly ordered for a basic memoization pattern.

    Test Plan & Next Steps

    1. Memory Leak Test: Run a loop with 1,000,000 unique arguments and monitor RSS memory usage.

    Concurrency Test: Use concurrent.futures to call the decorated function from 10 threads simultaneously to check for RuntimeError.
    3. Keyword Test: Verify that func(a=1) and func(a=2) do not return the same cached result.

    Next steps

    • Replace the dict with a Least Recently Used (LRU) structure.
    • Add *kwargs support to the wrapper and cache key logic.

    code-review-lite.pdf

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Reviewing pull requests or messy diffs often leads to missed edge cases and superficial feedback. This skill enforces a systematic inspection of your code through the lens of a senior engineer to catch logic flaws and security risks before they hit production.

    What it does

    • Critical triage categorizes issues by severity to prioritize blockers over style suggestions.
    • Evidence-based auditing maps every finding to specific lines or files with technical impact analysis.
    • Actionable refactoring provides minimal code fixes for every identified bug or performance bottleneck.
    • Contextual verification evaluates tests and edge cases to ensure logical correctness under stress.
    • Maintainability scoring highlights complex patterns that will increase technical debt.

    How it works

    1. Provide the code snippet, full file, or git diff you need reviewed.
    2. The agent analyzes security, correctness, and performance without making up execution results.
    3. You receive a structured table of findings including the specific impact and proposed fix.
    4. The review concludes with a targeted test plan to verify the changes.

    Frameworks & tools

    This skill is language-agnostic and works with any source code, including JavaScript, Python, Go, Rust, C++, and SQL. It is optimized for git diff formats and CI/CD pull request outputs.

    Why this beats prompting it yourself

    Standard prompts often produce vague "looks good to me" feedback or hallucinations about code execution. This skill uses a strict senior-engineer persona that demands evidence for every finding and prioritizes logic over linting.

    Use cases

    • Audit a critical PR for race conditions or security vulnerabilities.
    • Refactor a complex legacy function for better performance and readability.
    • Validate unit test coverage and identify missing edge case scenarios.
    • Standardize code quality across a multi-language engineering team.

    Known limitations

    Does not execute code or run actual linters. It cannot verify external API behavior unless the interface definitions are provided in the context.

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    1 install

    Downloaded by developers to date

    Free forever

    No account required to browse

    Trust & safety

    Security scanned

    Verified clean today

    • Free to download with an account

    Listedtoday

    What's inside

    Frequently Asked Questions