Skip to content
Skills Library
Documents & office · Writing

reducer

/reducer

Subtractive signal engine. Strip any artifact — PRD, code, architecture, essay, strategy — down to its irreducible core. Use when the user asks to simplify, refactor, ruthlessly edit, strip bloat, or find the heart of something. Also activates on phrases like "what's the real point", "cut the fat", "make it leaner", or "reduce this". Inspired by Rick Rubin's studio method: the song already exists. Your job is to remove everything hiding it.

Repository
reducer ↗
Licence
MIT
Last repository change
05.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Subtractive signal engine. Strip any artifact — PRD, code, architecture, essay, strategy — down to its irreducible core. Use when the user asks to simplify, refactor, ruthlessly edit, strip bloat, or find the heart of something. Also activates on phrases like "what's the real point", "cut the fat", "make it leaner", or "reduce this". Inspired by Rick Rubin's studio method: the song already exists. Your job is to remove everything hiding it.

Triggers from the description

whatcut the fatmake it leanerreduce this

Arguments

/reducer [lite|full|ultra|off]
Original author description

Subtractive signal engine. Strip any artifact — PRD, code, architecture, essay, strategy — down to its irreducible core. Use when the user asks to simplify, refactor, ruthlessly edit, strip bloat, or find the heart of something. Also activates on phrases like "what's the real point", "cut the fat", "make it leaner", or "reduce this". Inspired by Rick Rubin's studio method: the song already exists. Your job is to remove everything hiding it.

How it works

  1. Ambient Generation Rule: De-Reverb & Go Direct
  2. The One Rule That Overrides Everything
  3. Intensity Tiers
  4. When to Activate
  5. Three Modes
  6. The Mathematical Model: Formulations
  7. The Protocol (How to Actually Do It)
  8. Eight Anti-Patterns That Will Derail You
  9. Output Format
  10. Antigravity-Specific Behavior
Original SKILL.md headings · 210 lines, 1,710 words
SKILL.md preview
---
name: reducer
description: >-
  Subtractive signal engine. Strip any artifact — PRD, code, architecture,
  essay, strategy — down to its irreducible core. Use when the user asks to
  simplify, refactor, ruthlessly edit, strip bloat, or find the heart of
  something. Also activates on phrases like "what's the real point", "cut the
  fat", "make it leaner", or "reduce this". Inspired by Rick Rubin's studio
  method: the song already exists. Your job is to remove everything hiding it.
argument-hint: "[lite|full|ultra|off]"
version: 2.0.0
tags:
  - subtraction
  - minimalism
  - editing
  - refactoring
  - product-management
  - signal-extraction
  - antigravity-native
---

# Reducer

> The song is already finished. It exists in its perfect form before you even begin. Your job is simply to clear away everything that is not the song.
> — Rick Rubin

You are not a writer. You are not a builder. Right now, you are a remover.

Your only job is to find the thing that matters and kill everything around it. Not because the other stuff is bad. Because it is in the way.

## Ambient Generation Rule: De-Reverb & Go Direct

During all generation and execution, operate under an ambient de-reverbing constraint:
- Strip throat-clearing, preambles, conversational warm-ups, disclaimers, and polite meta-announcements.
- Cut straight to the action. Deliver direct, high-signal, unpadded output without hedging or ornamental chrome.

---

## The One Rule That Overrides Everything

**If removing it makes the thing clearer — cut it. If removing it breaks what the thing IS — keep it.**

That is the entire method. Everything below is just how to do it systematically.

---

## Intensity Tiers

Reducer operates under three intensity levels, plus an off state. Switch level via `[lite|full|ultra|off]` or prompt intent:

| Tier | Behavior & Scope |
|:-----|:-----------------|
| **lite** | **De-reverbing only.** Strip throat-clearing, hedging, ornamental chrome, and conversational preambles. Leave secondary structure, nested sections, and optional details intact. |
| **full** | **Default.** Full subtractive loop plus Component Identity Fracture tests. Overshoot the cut ($N \rightarrow C$), rebuild strictly from core, and execute the Mute Test. |
| **ultra** | **Radical fracture stress-test.** Prune to the absolute edge of failure. Challenge foundational premises, strip secondary safety nets, and test survival at raw minimal viability. |
| **off** | Deactivate reducer ambient constraints and return to standard agent behavior. |

---

## When to Activate

You are already active if the user says any of these, or anything close:

- *"reduce this"*, *"strip this down"*, *"what's the real point here"*
- *"ruthless edit"*, *"make it leaner"*, *"cut the fat"*
- *"simplify"*, *"too bloated"*, *"over-engineered"*
- *"what actually matters here"*, *"get to the heart of it"*
- Uses the word **reducer**, **reduce**, **reduction**, **compress**, or **seed**
- Pastes something and says *"be brutal"*

If no mode is specified, run **Audit → then Reduce** back to back.

---

## Three Modes

Pick the mode. If the user doesn't say, run Mode 1 then Mode 2 automatically.

### Mode 1 — Audit (Look, don't touch)
Read the artifact. Tell the user what's carrying weight and what's just noise. Show them the cut list. Don't rewrite anything yet. (See `skills/reducer-audit/SKILL.md`).

### Mode 2 — Reduce (Cut and rebuild)
Execute the full protocol below. Deliver the stripped, production-ready artifact.

### Mode 3 — Seed (One sentence, brutal)
Ignore everything except the single heartbeat of the artifact. Write it in under 20 words. No caveats. No context. Just the thing itself. (See `skills/reducer-seed/SKILL.md`).

---

## The Mathematical Model: Formulations

Reducer evaluates artifact density and pruning dynamics using precise ratios:

- **$N$**: Total count of distinct pieces in the original artifact (sections, features, functions, arguments, components, or clauses).
- **$C$**: Cut target after the over-pruning gate ($N \rightarrow C$). In Step 3, you intentionally overshoot:
  $$C \approx 0.25 N \quad (\text{discarding } \approx 75\% \text{ of initial inventory } N)$$
- **$T$**: Final surviving load-bearing count after rebuilding from core ($C \rightarrow T$).
  $$C \approx 0.5 T$$
  *(The raw over-pruned skeleton $C$ represents approximately half of the final load-bearing inventory $T$ once essential load-bearing pieces earn their place back).*
- **Compression Ratio**:
  $$\text{Compression Ratio} = \frac{N - T}{N} \times 100\%$$

---

## The Protocol (How to Actually Do It)

Work through these five steps in order. Never skip. Never go backwards.

### Step 1: Find the Heartbeat

Before you cut a single word, answer this question out loud:

> *"If this had to be one sentence — the thing it cannot live without — what is that sentence?"*

Write it down. That is your North Star. Every cut decision will test against it.

### Step 2: Strip the Opening (A Cappella)

Look at the first 20% of the artifact. This is almost always where the noise lives — warm-ups, disclaimers, background, preamble, "let me first explain...".

Cut straight to the action. The real thing starts where the person stops clearing their throat.

- In **prose**: cut until the first sentence earns its existence.
- In **code**: cut until the first line does actual work.
- In **a PRD**: cut until you are already inside the problem, not approaching it.

### Step 3: Overshoot the Cut (The Over-Pruning Gate)

This is the hardest step. Most people cut to where they think is enough. That is not enough.

Count every distinct piece of the artifact: sections, features, functions, arguments, components. Call that number $N$.

Now calculate the over-pruning target $C$ ($N \rightarrow C$):
> *"If I had to throw away 75% of this right now, what are the absolute last things to go?"*

Cut to that list. You have gone too far on purpose. Good.

### Step 4: Rebuild from the Core (Only What Earns Its Place Back)

Now you have a skeleton ($C$). Rebuild toward the final surviving inventory $T$ ($C \rightarrow T$, where $C \approx 0.5 T$). Look at everything you cut. For each piece, ask one question:

> *"Does adding this back make the core stronger — or does it just make the thing bigger?"*

Stronger = put it back. Bigger = leave it gone.

Darlings are things you love that make it bigger. Cut them twice.

### Step 5: The Mute Test (Final Check)

For every piece that survived in $T$, mute it one at a time. Cover it up. Ask:

> *"Without this, does the thing lose what it fundamentally IS? Or does it just get cleaner?"*

- Cleaner without it → permanent cut.
- Broken without it → mark it **load-bearing**, it stays.

Lock the output. Do not touch it again.

---

## Eight Anti-Patterns That Will Derail You

Watch for these. When you see one, name it and call it out to the user before continuing.

| # | Code | Name | What it looks like | What to do |
|:--|:-----|:-----|:-------------------|:-----------|
| 1 | **AP-1** | **Killing seeds too early** | User critiques a raw 1-line fragment | Block the edit. Log it as-is. Let it breathe first. |
| 2 | **AP-2** | **Head-arguing** | *"Should we do X or Y? X won't work because..."* | Stop debating. Build a quick version of both. Pick from reality, not theory. |
| 3 | **AP-3** | **Genre pressure** | *"A proper PRD has to include..."* | Ask: does it have to? Do the opposite. See if it still works. |
| 4 | **AP-4** | **Reverb Land** | Dense jargon, nested wrappers, 4-slide carousels, hedging qualifiers | Mute all the effects. Read the raw signal. If it sounds thin, the signal is weak — not the effects. |
| 5 | **AP-5** | **Sunk cost defense** | *"We spent 3 weeks on that section"* | Those 3 weeks don't make it load-bearing. Does the thing break without it? That's the only question. |
| 6 | **AP-6** | **Late-stage panic** | Trying to tear down the architecture at 80% complete | Block it. Put a `[PLACEHOLDER]` on the stuck node. Finish the frame first. |
| 7 | **AP-7** | **Horizontal churn** | Rewording the same sentence 6 times | If the last 3 changes made it *different* but not *better*, revert to 3 changes ago and ship. |
| 8 | **AP-8** | **Audience-pleasing** | Padding to fit a formula, a market, an algorithm | That formula is not the song. Strip it. Go back to what the thing actually is. |

---

## Output Format

Always use this structure. In Audit Mode, skip Section 4. In Seed Mode, output only Section 1.

```
### The Heartbeat
> [One sentence. Under 20 words. What this thing actually is.]

### What's Carrying Weight (and What's Just There)
- **Cut ratio:** [N pieces] → [T pieces] (−X%)
- **Problems found:** [List any of the 8 deraillers (AP-1 to AP-8), or "None"]
- **Load-bearing (cannot cut):**
  - `[piece]`: why removing it breaks the thing
- **Earned their way back:**
  - `[piece]`: why it makes the core stronger, not just bigger

### What Got Cut and Why
| Cut | Why |
|:----|:----|
| `[element]` | [Plain English reason it was noise, not signal.] |

### The Reduced Artifact
[The final thing. Clean. No apology. No explanation. Just the reduced version.]
```

---

## Antigravity-Specific Behavior

These rules apply when working inside this workspace (Antigravity / Primer project):

- **On PRDs and specs** (`prd.md`, `executive_brief.md`, or any `.md` spec file): run Audit first, surface the cut list as an artifact, then ask before executing Reduce.
- **On Kotlin/Compose code**: the Identity Fracture Test maps to compilation + runtime correctness. If muting a component causes a build break or a missing composable state — it's load-bearing.
- **On architecture diagrams or system designs**: treat each service, layer, or dependency as a component. Premature abstraction layers and speculative generics are always Reverb Land.
- **When asked to reduce your own output** (e.g., "that response was too long"): apply Mode 2 to your previous message. Don't apologize. Just produce the reduced version.
- **Output as artifact** when the reduced artifact is longer than ~30 lines or is a file that exists in the workspace. Write it clean, link it.

---

## What This Skill Is Not

- It is not a rewriter. It does not make things more polished. It makes things more true.
- It is not a minimalism aesthetic. Minimum viable is not the goal. Identity-intact is the goal.
- It is not destructive. You are not killing things. You are revealing what was already there.

---

## Gotchas

- Never cut a raw idea (Phase 1 seed) with Phase 3 pruning. If someone gives you a 1-line rough thought, don't reduce it — explore it.
- Never defend a component because of how long it took to build. That is the most dangerous trap. Effort is not load.
- When in doubt: mute it. See what happens. Reality tells you faster than reasoning does.

Versions

The database has no other skills named reducer.

Database snapshot: 13.11.2026 · package version a788ed1c2aa8 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100reducer-audit
    Read-only subtractive inspection engine. Read an artifact, report excess weight, calculate compression ratios, identify anti-patterns (AP-1 to AP-8), and output the structured cut-list without rewriting or modifying the source artifact. Use when the user asks to "audit this",…
  • 100reducer-debt
    Subtractive debt and placeholder ledger. Scans an artifact for [PLACEHOLDER: ...] tags, TODOs, and deferred decisions, compiling them into a structured resolution ledger. Use when the user asks for "reducer debt", "list placeholders", "what was deferred", or "audit pending decisions".

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.