Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Sofware Engineering Rulebook

    1

    Review code reliably using a rulebook anchored in software engineering litterature.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Sofware Engineering Rulebook

    Sofware Engineering Rulebook

    Example session with this skill installed

    User Request

    "Review this PR for logic errors. The calculate_discount function should apply a 10% discount when the order reaches $100."

    Original PR code:

    def calculate_discount(total_amount):
        if total_amount > 100:
            return total_amount * 0.10
        return 0
    
    • Read your context and instructions
    • Compiled the sofware engineering rulebook

    Engineering Rulebook — Essentials

    PASS 1 — INSPECT

    Finding: Incorrect threshold comparison

    • Severity: Medium — Incorrect business logic
    • Location: discount_service.py, calculate_discount()
    • Root cause: The strict > comparison excludes the exact $100 threshold.
    • Impact: An order totaling exactly $100 receives no discount, contradicting the specified business rule.

    Boundary analysis:

    Order totalExpected discountCurrent result
    $99.99$0.00$0.00
    $100.00$10.00$0.00 ❌
    $100.01$10.001$10.001

    Engineering principles applied: Boundary correctness, minimal changes, and regression evidence.

    Recommendation: Change the comparison to include the threshold. No broader refactoring is justified.

    PASS 2 — FIX

    Proposed minimal patch:

     def calculate_discount(total_amount):
    -    if total_amount > 100:
    +    if total_amount >= 100:
             return total_amount * 0.10
         return 0
    

    Change scope:

    • One operator modified.
    • No new dependencies.
    • No unnecessary abstractions.
    • No changes to unrelated business logic.

    PASS 3 — VERIFY

    Focused regression test:

    import pytest
    
    @pytest.mark.parametrize(
        "amount, expected",
        [
            (99.99, 0),
            (100, 10),
            (100.01, 10.001),
        ],
    )
    def test_discount_boundary(amount, expected):
        assert calculate_discount(amount) == pytest.approx(expected)
    

    Expected verification sequence:

    CheckBefore fixAfter fix
    Below thresholdPASSPASS
    Exactly at thresholdFAILPASS
    Above thresholdPASSPASS

    These are expected outcomes for the demonstration, not results from an executed test run.

    Engineering Summary

    • Patch: One comparison operator
    • Regression coverage: Three boundary cases
    • Scope expansion: None
    • Verification status: Tests proposed; execution pending

    The agent should run the regression tests and report the actual outcomes before declaring the repair verified.


    The Difference

    Generic AI approach:
    "Change > to >=. Fixed!"

    Engineering Rulebook approach:
    Establish the defect, identify the relevant engineering principle, make the smallest justified correction, test the boundary, and report observable evidence.

    One defect. One minimal patch. A repeatable engineering discipline.

    Essentials handles focused repairs. Extended brings the full multi-pass engineering workflow to cross-file changes, larger features, and deeper verification.

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

    About this skill

    Software Engineering Rulebook — Essentials

    Build more reliable code with a disciplined, literature-grounded approach to AI-assisted development.

    Extended and Pro versions are also available.

    AI coding agents can produce convincing solutions that introduce subtle bugs, unnecessary complexity, or unrelated changes. Software Engineering Rulebook — Essentials helps prevent these problems by applying established software engineering principles to code review and targeted defect repair.

    Built around a structured Inspect → Fix → Verify workflow, Essentials guides your coding agent toward small, intentional changes supported by reproducible evidence and focused regression testing.

    What It Does

    • Literature-grounded code review: Identifies up to three significant issues, prioritizes them by risk, and connects recommendations to established engineering principles and rule references.
    • Targeted defect repair: Diagnoses and fixes one localized issue through a disciplined three-stage workflow.
    • Minimal, controlled patches: Limits modifications to the smallest necessary scope, reducing accidental regressions and unnecessary refactoring.
    • Evidence-based verification: Establishes the expected failure before applying a correction, then verifies the result through focused regression checks.
    • Essential security safeguards: Checks critical trust boundaries, including exposed secrets, unsafe input handling, and sensitive information disclosure.

    How It Works

    1. Inspect — Understand before changing

    Analyze the relevant code, identify the underlying problem, and establish observable evidence of the defect. For repair tasks, create or identify a reproducible failing test whenever feasible.

    2. Fix — Make the smallest effective change

    Apply a focused correction that respects existing architecture, coding conventions, and established software engineering practices. Avoid unrelated modifications, speculative improvements, and unnecessary abstractions.

    3. Verify — Demonstrate the result

    Run applicable regression checks, compare observed behavior against expectations, and report precisely what was verified. Reference relevant engineering rule IDs and explicitly identify any remaining uncertainty.

    Supported Languages & Frameworks

    Designed for use with AI coding agents across languages and frameworks, including:

    • JavaScript and TypeScript
    • Python
    • Go
    • Other languages with independently testable logic

    The workflow is framework-agnostic and supported by a curated reference library of literature-grounded software engineering rules.

    Why Use It Instead of Generic AI Prompts?

    A generic instruction such as "fix this bug" leaves your coding agent free to reinterpret the problem, modify unrelated code, or declare success without sufficient evidence.

    Essentials introduces a repeatable engineering discipline that emphasizes:

    • Evidence over assumptions
    • Minimal changes over unnecessary rewrites
    • Verification over unsupported claims
    • Established engineering principles over improvised solutions

    The result is a more controlled, reviewable, and reliable AI-assisted coding workflow.

    Ideal Use Cases

    • Reviewing AI-generated code or pull requests for significant logic defects.
    • Correcting isolated bugs, edge cases, and missing guard conditions.
    • Adding regression tests for previously reported failures.
    • Reducing unnecessarily large patches to focused corrections.
    • Improving the consistency and reliability of everyday AI-assisted development.

    Scope & Limitations

    Essentials is optimized for localized defects and focused code reviews.

    It does not include large-scale refactoring, database schema migrations, complex concurrency engineering, advanced performance optimization, or CI/CD orchestration.

    For broader engineering tasks, Software Engineering Rulebook — Extended adds a comprehensive multi-pass development workflow, dedicated frontend and backend engineering guidance, cross-file changes, and more extensive verification.

    For production-level engineering, Software Engineering Rulebook — Pro extends the system with advanced security, computation optimization, Docker deployment, and repository-level governance.


    Start with the fundamentals. Make every change intentional. Verify what actually works.

    Handles local changes to one module only. No support for multi-file refactors, public schema migrations, or complex distributed systems. Requires host-provided tools for actual test execution.

    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 today

    Requires

    GitHub

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    Allowed Hosts

    api.github.com
    Listedtoday

    What's inside

    Frequently Asked Questions

    Unlike a standard AI prompt, **Engineering Rulebook Essentials enforces a repeatable, literature-grounded engineering workflow** rather than relying on improvised solutions. It systematically inspects code, applies minimal fixes, and verifies results through focused regression checks. By prioritizing established engineering principles, limiting scope creep, and requiring evidence before claiming success, it makes AI-assisted coding more consistent, traceable, and reliable.

    This skill is language-agnostic and works with any codebase where logic can be isolated, such as TypeScript, Python, Go, and JavaScript. It is compatible with major AI agent platforms that support multi-step tool execution and file system access.

    Each purchase includes the 'Software Engineering Rulebook Essentials' skill package, a curated library of engineering rules used for citations, and integration documentation for your preferred agent environment.

    No, this skill is purpose-built for 'micro-fixes'—specific, localized defects within a single logical responsibility. It is not designed for architectural refactoring, multi-file migrations, or managing complex infrastructure changes.

    Setup is straightforward: you import the skill into your AI agent's library and point it toward your repository. The skill then waits for your instruction to either enter 'Review' mode for analysis or 'Fix' mode for active repair.

    Yes, updates to the underlying rulebook and refinement of the triage logic are included. Buyers will receive notifications through the marketplace whenever a new version is released to address emerging security patterns or agent optimizations.

    New in Code Quality & Review