moyu-lite

Overview of moyu-lite skill

What moyu-lite does

moyu-lite is a lightweight guardrail skill for code editing. It helps an agent stay inside the user’s exact request by avoiding extra refactors, new abstractions, broad rewrites, and “helpful” side changes. If you want a moyu-lite skill for Code Editing that favors minimal diffs over cleverness, this is the right fit.

Who should use it

Use moyu-lite when the main risk is over-editing: fixing one issue but accidentally changing unrelated files, architecture, or behavior. It is especially useful for maintenance work, small bug fixes, partial file edits, and requests where the user says “only change X,” “keep it simple,” or “don’t refactor.”

What it optimizes for

The skill centers on three rules: only change what was asked, choose the simplest solution first, and ask when unsure. That makes moyu-lite valuable when correctness depends on restraint, not invention. It is less about generating a big code solution and more about controlling scope, which is often the real blocker in code editing workflows.

How to Use moyu-lite skill

Install and activate moyu-lite

For moyu-lite install, add the skill from the repo path in your environment, then confirm the agent is reading the skill file before editing. A typical install command shown in the source is:
npx skills add uucz/moyu --skill moyu-lite

Give it a tight edit request

The best moyu-lite usage starts with a request that names the exact target, desired outcome, and boundaries. Strong input looks like: “Update src/auth.ts so login accepts email aliases; do not change other auth logic or file structure.” Weak input sounds like “Improve auth,” which invites scope creep and forces the skill to guess.

Read the right files first

Start with SKILL.md, then inspect any linked repo guidance such as README.md, AGENTS.md, metadata.json, or folders like rules/, references/, resources/, and scripts/ if they exist. In this repo, the signal is intentionally compact, so reading the skill text closely matters more than hunting for extra helper files.

Use it as an edit policy, not a rewrite prompt

moyu-lite is best applied before the model starts coding: ask it to preserve the current structure, limit diffs, and pause for confirmation if the request expands. That makes it useful for patching existing code, where the right answer is often the smallest safe change rather than a better architecture.

moyu-lite skill FAQ

Is moyu-lite only for tiny changes?

No. It is for any Code Editing task where the user values narrow, controlled changes. A large feature can still use moyu-lite if the instruction is to keep the diff minimal and avoid unasked-for refactors.

How is this different from a normal prompt?

A normal prompt may describe the task but still leave room for the model to “improve” the code. moyu-lite adds an explicit restraint layer: if the request does not authorize a change, the skill treats it as out of bounds. That makes it more reliable when you want the agent to act like a careful editor, not a redesign assistant.

When should I not use moyu-lite?

Skip it when you actually want exploration, redesign, or broad cleanup. If the goal is to re-architect, normalize patterns, or use the task as a chance to improve surrounding code, moyu-lite may be too conservative.

Is moyu-lite beginner-friendly?

Yes, because the rules are easy to apply: change less, ask sooner, and prefer the smallest correct edit. The main thing beginners need to remember is that “helpful” extra work is usually the failure mode this skill is trying to prevent.

How to Improve moyu-lite skill

Make the edit boundary explicit

The strongest moyu-lite guide inputs name the exact file, region, and acceptable scope. Include what must stay untouched, such as “do not change tests,” “no new dependencies,” or “preserve current API.” This reduces ambiguity and helps the skill enforce restraint instead of guessing intent.

Describe the smallest acceptable outcome

Users usually care about output safety, not elegance. State the minimum success condition: “fix the failing branch,” “replace the hardcoded path,” or “adjust this one function without changing callers.” If you want moyu-lite for Code Editing to work well, give it a target that can be satisfied with one constrained diff.

Watch for common failure modes

The skill is most likely to drift when the prompt is vague, the codebase is messy, or the task sounds like an invitation to improve nearby code. If the first pass adds abstractions, touches unrelated files, or rewrites more than needed, tighten the instruction and restate the boundary before asking for a second pass.

Iterate by narrowing, not expanding

If the initial result is too broad, correct it by shrinking the request: specify the exact line, file, or behavior to keep unchanged, then ask for only the missing edit. For moyu-lite, better results usually come from more constraint, not more context.