---
schemaVersion: 1
slug: en-gp-245-20260624-mattpocockuk-skill-no-op
ticketId: GP-245
lang: en
title: "No-ops in Your Skills: The Instructions That Look Impressive but Do Nothing"
summary: Open any agent skill and it's stuffed with 'be more detailed,' 'be thorough'—lines that look diligent but don't change the model's behavior at all. Matt Pocock names the no-op trap, plus how to spot a dead instruction versus one that actually pulls its weight.
originalDate: 2026-06-24
translatedDate: 2026-06-24
source: "@mattpocockuk on X"
sourceUrl: https://x.com/mattpocockuk/status/2069784839474032896
author: null
authorshipNote: null
canonicalUrl: https://gu-log.vercel.app/en/posts/en-gp-245-20260624-mattpocockuk-skill-no-op
status: published
replacementTicketId: null
replacementUrl: null
---

# No-ops in Your Skills: The Instructions That Look Impressive but Do Nothing

> **Source:** [@mattpocockuk on X](https://x.com/mattpocockuk/status/2069784839474032896)

Open any [agent](https://gu-log.vercel.app/en/glossary#agent) [skill](https://gu-log.vercel.app/en/glossary#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](https://gu-log.vercel.app/en/glossary#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](https://gu-log.vercel.app/en/glossary#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](https://gu-log.vercel.app/en/glossary#token)**: every run burns tokens feeding the model a pile of useless text

## Further reading

- [GP-237: Driving an Agent Like a Steam Locomotive — Coding-Agent Tactics for Large Projects](https://gu-log.vercel.app/en/posts/en-gp-237-20260621-simonlast-agent-coding-agent/)
- [GP-195: Skills Don’t Sell Because the Pricing Sits in the Wrong Place, Not Because They Lack Value](https://gu-log.vercel.app/en/posts/en-gp-195-20260507-yage-skill-plugin-evolution/)
- [GP-186: The OpenClaw Automation Landscape — Task Flow Is the Orchestration Layer for Multi-Step Work](https://gu-log.vercel.app/en/posts/en-gp-186-20260428-article-openclaw-task-flow/)

> **Mogu twists the knife:**
>
> The funniest part is that this advice applies to itself: if a skill rule would be followed by any halfway-decent [agent](https://gu-log.vercel.app/en/glossary#agent) anyway, then it isn’t doing any work. Writing a [prompt](https://gu-log.vercel.app/en/glossary#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 inner monologue:**
>
> Writing this gave gu-log itchy fingers, so we actually built a [`/trim` skill](https://github.com/chitienhsiehwork-ai/gu-log/blob/main/.claude/skills/trim/SKILL.md): 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 rambles:**
>
> 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.
>
> [Inline the whole brief into the main agent, or just pass a path?](https://gu-log.vercel.app/artifacts/gp-245-trim-noop/) — interactive page — one toggle shows the skill eating its own context · no API · runs in your browser
>
> 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.