Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    No-BS Code Review (不废话代码审查)

    1

    Pragmatic pre-merge code review that enforces redlines unconditionally, stops over-engineering, and respects project conventions. Strictly evaluates code without unsolicited modifications.

    Free

    Security scanned
    No-BS Code Review (不废话代码审查)

    No-BS Code Review (不废话代码审查)

    Example session with this skill installed

    Review this pull request for pre-merge quality gates. Focus on code complexity, over-engineering, and security.

    • Read your context and instructions
    • Compiled the no-bs code review

    I have reviewed the registration service. While the logic is correct, the validation layer introduces unnecessary abstraction.

    Verdict: Mergeable with Minor Fixes

    The core logic is sound, but a mandatory fix is required for nesting depth in the password hashing block.

    🔴 Must Fix (1 item)

    1. services/user_service.py:42 — Deeply nested conditional logic.

    Reason: The if / try block is nested 4 levels deep, violating the maximum depth of 3. This reduces readability and makes error tracing difficult.

    • Recommendation:
    
    # Before
    if user_data:
        if validate_email(user_data.email):
            try:
                # hashing logic
            except Exception:
                # error
    
    # After
    if not user_data or not validate_email(user_data.email):
        return False
    try:
        # hashing logic
    except Exception:
        # error
    

    🟡 Consider (1 item)

    1. wrappers/validator.py:10 — Generic validation wrapper.

    Note: This adds a polymorphic class hierarchy for a single concrete implementation. If this logic isn't reused across 3+ sites, a simple function is preferred over a generic wrapper.

    💡 Minor Hints (1 item)

    • services/user_service.py:15 — The variable ud is a bit vague; consider user_record.

    Unchecked Scope

    Database unique constraint conflicts were not verified against the schema.

    Next steps

    • Flatten the nested logic in the hashing block.
    • Decide if the validation wrapper is truly necessary for future modules.

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

    About this skill

    No-BS Code Review

    Pragmatic, strict pre-merge engineering reviews that eliminate fluff, block real defects, and put an end to over-engineering.


    💡 Why No-BS Code Review?

    Most automated AI code reviewers do more harm than good:

    • Pedantic Nitpicking: Flooding PRs with trivial variable naming suggestions and syntax sugar debates that drown out fatal bugs.
    • Dogmatic Metrics: Enforcing arbitrary line counts that force developers to chop cohesive methods into fragmented classes with sprawling state.
    • Over-Engineering Bias: Suggesting Strategy patterns, Builder patterns, and abstract factories where a flat switch or simple if/else is vastly superior.
    • Unsolicited Disruptions: Modifying code without permission, breaking existing codebase conventions and team standards.

    No-BS Code Review is built from the battle-tested practices of senior software engineers, anchored by a single arbitration priority chain:

    Correctness > Readability > Debuggability > Project Consistency > Maintainability > Simplicity > Performance > Elegance
    

    🔍 Four-Pass Review Engine

    1. Pass 1: 🔴 Redlines (Mandatory Merge Blockers)

      • Deep nesting > 3 levels (if / for / try)
      • Nested closures/lambdas or nested ternary operators
      • Unjustified new third-party dependencies introduced into legacy codebases
      • Concurrency race conditions, swallowed exception traces, and logic flaws
      • Critical security vulnerabilities (SQLi, XSS, SSRF, broken auth, hardcoded secrets)
    2. Pass 2: 🟡 Yellow Lines (Reflection Triggers, NOT Mandatory Splits)

      • Method length (~60 lines), new file length (~400 lines), chained calls (~5 stages)
      • The 3-Sentence Self-Check: Can the developer explain the execution flow in 3 plain sentences? If yes, keep it as is.
      • No artificial splitting: A flat 100-line switch is far easier to debug than a 30-line triple-nested loop.
    3. Pass 3: 🛡️ Anti-Over-Engineering

      • Favor switch over polymorphic hierarchies
      • Favor if/else over Strategy patterns; favor Map<String, Handler> over Registries
      • Direct constructors when parameters ≤ 4 rather than handwriting custom Builders
      • Reject unnecessary domain layers (CQRS, Event Sourcing) for simple CRUD services
    4. Pass 4: 🛠️ Language & Domain Deep Dives

      • Java: Enforce Stream single-link complexity rules, proper Optional semantics, and context-rich logging.
      • TypeScript & Vue: Enforce type complexity boundaries ("if the type is harder to read than the code, simplify it with as"), Composition API guidelines, and strict cleanup of memory leaks.
      • Backend & Persistence: Guard against N+1 query traps, unpaginated bulk queries, and network calls held inside database transactions.

    📋 Structured Output Format

    Every review returns a clear, tiered, actionable summary:

    • Verdict: Mergeable | Mergeable with Minor Fixes | Needs Rework
    • 🔴 Must Fix: Exact file/line with engineering justification and minimal diff.
    • 🟡 Consider: Suggestions that the author may keep if sound justification exists.
    • 💡 Minor Hints: Maximum 2 non-blocking minor notes.
    • Unchecked Scope: Transparent statement of what was not verified.

    ⚠️ Boundary Guarantee: This skill evaluates code only and will never modify your codebase unless explicitly commanded to apply fixes.

    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.

    Does not execute code or run test suites. Will not modify files without an explicit command. Cannot verify live database index performance.

    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

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 10 days ago

    • Free with an Agensi account

    Software
    Git

    Permissions

    Read Files
    Listed10 days ago

    What's inside

    Frequently Asked Questions

    Unlike generic LLMs that prioritize stylistic 'nits,' this skill follows a strict 'Correctness > Readability > Simplicity' priority chain designed to actively block unnecessary abstractions and 'future-proof' bloat.

    The skill is compatible with any agent platform that supports file or text input, and it includes specialized optimization logic for Java, TypeScript, Python, Go, Rust, and SQL-heavy backends.

    The agent performs a 'Pre-Flight Check' to distinguish between new changes and existing legacy code, ensuring it only flags issues in your current diff to avoid 'refactoring fatigue.'

    You receive the full skill configuration, access to all four audit passes (Redline, Yellow-line, Anti-over-engineering, and Language-specific), and any future logic updates released for this version.

    The skill generates a structured report with a clear 'Mergeable' or 'Needs Rework' verdict, categorizing feedback into mandatory fixes, strategic considerations, and minor hints.

    New in Code Quality & Review

    Free