clone-me: code and review like you

    1

    Teach your agent to code and review like you, from your PRs and every correction you make.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    clone-me: code and review like you

    Example session with this skill installed

    Review PR 42 (feature/orders) like me.

    • Read your context and instructions
    • Compiled the clone-me

    Summary

    Reviewed PR 42 (feature/orders → main, one commit adding src/orders.ts) against your style skill. Nothing was posted to the PR.

    Already raised: I agree with alex's open thread on src/orders.ts:13 (SQL injection). The same fix covers lines 14–15, so I haven't repeated it.

    New findings, most severe first

    Format follows your rule: file:line — problem → fix.

    1. src/orders.ts:8 — any logged-in user can read anyone's orders → return 403 unless admin or owner, like users.ts:13.
    2. src/orders.ts:24 — any logged-in user can cancel any order → select user_id and check ownership.
    3. src/orders.ts:20 — 500 response sends err.stack to the client → log it server-side, return a generic error.
    4. src/orders.ts:26 — rows[0] is undefined for an unknown id, so the handler throws and the request hangs → return 404.
    5. src/orders.ts:25-27 — read-then-write race between SELECT and UPDATE → one UPDATE … WHERE status <> 'shipped', branch on rowCount.
    6. src/orders.ts:15 — OFFSET page * limit skips the first page → use (page - 1) * limit.
    7. src/orders.ts:9-10 — page/limit unbounded → validate with zod, cap limit at 100.
    8. src/orders.ts:11 — leftover console.log (your Flag rule) → remove.
    9. src/orders.ts:7,12 — comments restate the code → remove.

    Not flagged: missing JSDoc on handlers (your Don't-flag rule).

    Evidence

    • (1)(2): requireAuth only checks that req.user exists.
    • (4): Express 4 doesn't catch errors from async handlers.
    • (6): with page=1, limit=20 the query uses OFFSET 20.

    Next steps

    Want me to fix these? If you disagree with any finding, tell me and I'll update your Don't-flag list so I stop raising it.

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

    About this skill

    Tired of fixing the same things in your agent's code every session? clone-me learns your style and keeps it.

    What it does

    • 🔍 Learns from your history. It reads your commits and the review comments you left on teammates' PRs, and keeps only the patterns that repeat. You approve the list before it's used.
    • 👂 Learns from every correction. A requested change, a review comment, or you quietly rewriting its code (it checks git diff). Each one becomes a one-line rule, so you never make the same correction twice.
    • 🕵️ Reviews like you. It checks, in order: logic and edge cases, then security, then your own rules, then language best practices. It skips what teammates already raised and confirms every finding before reporting it. It never posts to a PR without asking.
    • 💬 Learns from review arguments. Say "too picky" and it stops flagging that. Point out a miss and it flags it next time. Reword a comment and it writes the next one your way.
    • 🛡️ Has standards. It writes in your repo's own language and follows its best practices: secure by default, with no useless comments. It copies your style, never your shortcuts. Security rules can't be argued away.

    Where your rules live

    Rules are saved to your own style skill (~/.claude/skills/my-code-style/SKILL.md, or the implementation or review skill you already use), so they're yours to read and edit.

    Requirements

    git. Reading PRs and review comments also needs the GitHub CLI (gh), signed in.

    Open source

    MIT licensed. Source, issues and the downloadable skill: https://github.com/ManarArabi/clone-me

    Tested with Claude Code only so far. Reading PR history needs the GitHub CLI (gh) signed in. It keeps only patterns that repeat, so early sessions lean on the built-in baseline until it has learned enough. It never saves a rule that weakens a security check.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 10 days ago

    • Free with an Agensi account

    Requires

    git
    GitHub CLI (gh)
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed10 days ago

    What's inside

    Frequently Asked Questions

    On first use it asks which repos or PRs to learn from, then reads your commits and the review comments you left on others' PRs. You approve the rules it finds. After that, every correction you make, spoken or a silent edit, becomes a new one-line rule.

    Any. It detects your repo's language, framework and linter config from its files and follows that language's best practices. It has been tested on a TypeScript/Node.js project.

    Yes. Rules are plain one-line entries in your own style skill file (for example ~/.claude/skills/my-code-style/SKILL.md). Edit or delete them any time, and it tells you in one line whenever it adds or replaces one.

    Only if you ask. Reviews come back to you in chat, and nothing is posted, approved or pushed unless you say so. Reading your history is read-only.

    The skill learns autonomously by monitoring your manual edits and review disagreements. When you correct the agent's output or perform a 'silent edit' on a file it touched, it detects the delta and updates its internal rules to ensure it doesn't repeat the same mistake.

    No. Learned rules can change style choices, but never a security rule. If you ask it to remember something unsafe, like building SQL from strings, it refuses to save it, explains which rule it breaks and offers a safe alternative.

    Yes. It's free here and MIT licensed on GitHub: https://github.com/ManarArabi/clone-me

    New in Code Quality & Review