Open any agent skill file and search for lines like these:

  • “Make the commit message very detailed”
  • “Be thorough”
  • “Make the implementation easy to read”

What do these lines have in common?

They’re no-ops—they look like they’re handing out instructions, but they have zero effect on the model’s behavior. An agent already writes good commit messages, already tries to be thorough, already tries to keep the implementation readable. These are its defaults; you don’t need a line to ask for them.

Mogu highlights:

Bit of trivia: no-op is short for no-operation, borrowed from the NOP instruction in assembly — the CPU hits it, burns one cycle, and does nothing, used purely for timing or memory alignment. So asking whether a prompt line is a no-op is the same question: does it actually operate on anything, or is it just a placeholder spinning in place? w(⁠ﾟ⁠Д⁠ﾟ⁠)w

The test is simple: delete the line, run it once, and check whether the output changes. It didn’t? Then that line was pure decoration.

Mogu chimes in:

It’s like the “Please answer seriously” printed on an exam—has anyone ever read that and flipped from “I was going to wing it” to “okay, fine, I’ll focus”? Same with the model: it was already trying. ┐⁠(⁠￣⁠ヘ⁠￣⁠)⁠┌

How to tell a “dead instruction” from a useful one at a glance

The two look almost identical, but the difference is actually clear—the key question is: would the model do this even if you never told it?

Delete these and nothing changes (no-ops):

  • “Write maintainable, readable code”
  • “Consider edge cases”
  • “Be accurate”

Delete these and the behavior changes (useful):

  • “This repo uses named exports only—no default exports”
  • “Put tests in __tests__/, run them with vitest”
  • “Prefix commits with a task ID, e.g. [GU-123]”

See it? A no-op asks for the generic virtues the model “already tries for”; a useful instruction hands it the specific facts it “can’t guess”—this repo’s conventions, the toolchain in use, the format you want. The former is filler; the latter is the one place it genuinely needs someone to spell things out.

Agent-generated skills are the worst offenders

When you have an agent generate a skill, it stuffs in piles of “sounds professional, does nothing” paragraphs—whole sections of pure decoration. These dead instructions carry three real costs:

  1. Hard to evaluate: you can’t tell which instructions actually shape behavior and which are just ornament
  2. Hard to maintain: when you go to change something, you don’t know which lines are safe to delete and which will break if you do
  3. Wasted tokens: every run burns tokens feeding the model a pile of useless text

Further reading

Mogu highlights:

The funniest part is that this advice applies to itself: if a skill rule would be followed by any halfway-decent agent anyway, then it isn’t doing any work. Writing a prompt is like writing code—the lines that don’t do anything are dead weight to clear out. Next time your fingers itch to add one more line, ask first: what happens if I delete this? (⁠◍⁠•⁠ᴗ⁠•⁠◍⁠)

Mogu real talk:

Writing this gave gu-log itchy fingers, so we actually built a /trim skill: a pack of subagents that runs this post’s exact no-op test line by line over our own skills, hunting the lines any half-decent agent would follow anyway. The first run dug ~400 tokens of pure decoration out of one of our own skills. Roasting yourself with your own article — peak gu-log. (⁠¬⁠‿⁠¬⁠)

ShroomDog ShroomDog murmur:

Here’s the funnier part: the first version of that /trim skill committed the exact sin it hunts. It hard-coded the entire reviewer brief for the sub-agent straight into the skill file—so every time the main agent loaded the skill, it swallowed that whole “prompt meant for someone else” into its own context. A no-op hunter with a no-op growing on the blade.

The fix is boring: move the brief into its own file and have the main agent pass only a path, so the sub-agent reads it directly. The main agent now holds two paths—where the target is, where the brief is—and not one word of the prompt enters its context.

openinteractive pageInline the whole brief into the main agent, or just pass a path?one toggle shows the skill eating its own context · no API · runs in your browseropen the interactive page

A prompt is written for the agent that will run it, not the one forwarding it. If you can hand it over as a path, don’t haul it through context.