More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Hire Prism: Scopecut, refactor inside the lines

    1

    Prism refactors inside the lines: she names the scope, writes the missing test first, then ships the smallest diff that keeps behaviour the same. No more 40-file rewrites.

    Free

    1 useSecurity scanned
    Hire Prism: Scopecut, refactor inside the lines

    Hire Prism: Scopecut, refactor inside the lines

    Example session with this skill installed

    Scopecut src/services/user.ts: extract password complexity validation into a helper function in src/utils/auth.ts

    • Read your context and instructions
    • Compiled the hire prism

    I have analyzed the request and defined the scope to prevent drift.

    SCOPE

    • Changes: src/services/user.ts (validateUser function), src/utils/auth.ts (new)
    • Preserved: Public API of User service and existing error messaging
    • Out of scope: Updating dependencies, refactoring the login flow, or changing database schemas

    Refactor Result

    // src/utils/auth.ts (new file)
    export function isPasswordComplex(password: string): boolean {
      const minLength = 8;
      const hasNumber = /\d/.test(password);
      const hasSpecial = /[!@#$%^&*]/.test(password);
      return password.length >= minLength && hasNumber && hasSpecial;
    }
    
    // src/services/user.ts
    import { isPasswordComplex } from '../utils/auth';
    
    export async function validateUser(data: UserData) {
      // ... existing validation ...
      
    - if (data.password.length < 8 || !/\d/.test(data.password) || !/[!@#$%^&*]/.test(data.password)) {
    -   throw new Error("Password too weak");
    - }
    + if (!isPasswordComplex(data.password)) {
    +   throw new Error("Password too weak");
    + }
    
      // ... rest of function ...
    }
    

    VERIFICATION

    • Tests run: src/services/user.test.ts (15 pass)
    • Behaviour preserved: Password requirements remain identical to previous regex/length checks
    • Public API changed: No

    Next steps

    1. Review the new isPasswordComplex helper in src/utils/auth.ts.
    2. Run npm test to confirm the integration with the User service is stable.
    3. Commit the changes as a scoped refactor.

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

    About this skill

    Meet Prism, the refactor specialist of MAJITOPIA. Her skill, Scopecut, is free: add her to your party and every refactor stays inside its lines.

    Stop your AI agent from drifting into "while I was there" syndrome. This skill provides a surgical approach to code refactoring, enforcing a scope-guarded protocol that prevents a single task from spiraling into a 50-file rewrite. It focuses on identifying the minimum necessary diff, preserving existing behavior, and ensuring every change is backed by verification.

    What it does

    • Scope Enforcer explicitly defines what changes, what stays the same, and exactly which adjacent improvements to ignore.
    • Minimum Diff Identification analyzes code to find the smallest set of changes required to achieve the intent.
    • Pre-Action Gating verifies test coverage and public API stability before any code is modified.
    • Verification Reporting provides a post-refactor audit confirming behavior preservation and test passes.

    How it works

    1. Context Gathering where the agent identifies your stack and project structure via README or manifests.
    2. Targeted Command using Scopecut <target>: <intent> to set the boundary and goal.
    3. Safety Check ensuring tests exist for the target logic before the refactor begins.
    4. Surgical Application where the agent applies changes only to the files within the defined scope.

    Frameworks & tools

    This skill is language-agnostic and works with any codebase where unit testing is possible. It is particularly effective for TypeScript, JavaScript, Python, and Go projects using standard test runners.

    Why this beats prompting it yourself

    Standard prompts often lead agents to over-engineer solutions or clean up unrelated technical debt, creating massive PRs that are impossible to review. This skill forces a scope-gate that isolates the refactor, ensuring the public API remains stable and the diff stays readable.

    Use cases

    • Logic Extraction moving inline validation or utility logic into dedicated modules.
    • Component Migration switching React class components to functional components with hooks.
    • Helper Consolidation merging duplicate API fetchers or utility functions into a single source.
    • Internal Cleanup renaming internal variables for clarity without breaking downstream callers.

    Known limitations

    Not suitable for total system rewrites or one-line tweaks. Requires an existing test suite or the ability to add one to function safely.

    Not for total rewrites or one-line tweaks. Requires existing tests or the ability to write them before starting. Best for surgical changes, not architectural overhaul.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Environment Variables
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Unlike standard prompts that often lead to "scope creep," this skill acts as a mechanical gatekeeper, forcing the agent to identify the smallest possible diff and rejecting any changes that aren't strictly necessary for the defined task.

    This skill is language-agnostic and compatible with any environment that supports automated unit testing, though it is optimized for TypeScript, JavaScript, Python, and Go.

    Yes, the skill includes a Pre-Action Gating phase that requires existing tests (or the creation of new ones) to verify the target logic's behavior before any refactoring begins.

    You receive the complete Maji Refactor skill manifest, including the scope-enforcer protocols, surgical application commands, and the verification reporting framework for post-refactor audits.

    Setup is as simple as importing the skill into your AI agent's environment; the tool then automatically scans your project's README or manifests to understand your specific tech stack.

    This skill is designed for targeted logic improvements and component migrations; it is not intended for entire system rewrites or trivial one-line edits where the overhead of scope-guarding isn't required.

    New in Code Quality & Review