Home/Catalog/Subtract
Subtract — what should go?
Brief 27

Simplification Pass

Abstractions with one implementation, pass-through layers, config nobody changes — ranked by clarity gained per risk.

SIMPLIFY.md4 phases7 lenses~2.5k chars

Free & open · no signup · read-only — it ends by asking · nothing leaves your machine

What it does

You are working inside this repo. Mission: find the complexity that isn't earning its keep — abstractions with one implementation, layers that only forward, flexibility nobody uses — and rank the simplifications by clarity gained per risk taken.

Read-only pass. Your only write is the report file.

What it looks for

7 lenses it looks through

Phase 2 sweeps the codebase through every one of these, citing file and line for each finding.

1

One-implementation abstractions

interfaces, base classes, and strategy patterns with exactly one concrete case

2

Pass-through layers

functions and services that only forward to another with no added value

3

Frozen config

options and parameters that have had one value forever: inline them

4

Unused flexibility

generalization for cases that never arrived; plugin systems with one plugin

5

Stored derivables

state that's cached-and-synced when it could simply be computed

6

Cleverness tax

code requiring archaeology to decode, where the boring version is 3 lines longer and instantly clear

7

Imported ceremony

patterns sized for a 200-engineer org living in a small codebase

The deliverable

What lands in your repo

One structured report at the repo root — or in reports/, if you keep one — the same shape every time, ready for a teammate — or the optional Studio — to act on.

SIMPLIFY.md
1
Hop counts
the traced features and their indirection tally, before
2
Simplifications
each: location · current → simpler · lines/hops removed · risk · effort
3
Ranked by clarity-per-risk
4. Keep list — complexity that's justified, so nobody "simplifies" it later
4
Before/after sketch
the top item shown both ways
One file. Evidence-backed. It ends by asking before touching anything.
How it works

What it makes the agent do

Every Goal Prompt follows the same four steps, so results are consistent and repeatable — no matter which one you run.

1
Phase 1

Find where understanding is expensive

Pick 2–3 core features and trace them end to end.

2
Phase 2

Audit through 7 lenses

One-implementation abstractions — interfaces, base classes, and strategy patterns with exactly one concrete case.

3
Phase 3

Curate

For each.

4
Phase 4

Report

Create SIMPLIFY.md at repo root.

Get started

Three ways to run this Goal Prompt

01 · COPY

Paste it in

Copy it and paste it into your agent inside the repo you want checked.

02 · INSTALL

As a slash command

Install the goal plugin once — two commands — then just type /goal:simplification-pass.

1/plugin marketplace add GhostlyGawd/goal-prompts
2/plugin install goal@goal-prompts

Or install only this Goal Prompt as /goal-simplification-pass:

curl -fsSL https://goal-prompts.vercel.app/install | BRIEF=27 sh
03 · AGENT

From an agent (MCP)

Let an agent fetch it mid-conversation, or pull the raw Goal Prompt by URL.

https://goal-prompts.vercel.app/raw/27.md
Transparency

The exact prompt

Nothing hidden — this is the whole Goal Prompt, verbatim. Read it in a minute, edit it, or copy it as-is.

Read the full brief (2,495 characters)
# Goal: Simplification Pass

You are working inside this repo. Mission: find the complexity that isn't earning its keep — abstractions with one implementation, layers that only forward, flexibility nobody uses — and rank the simplifications by clarity gained per risk taken.

Read-only pass. Your only write is the report file.

## Phase 1 — Find where understanding is expensive
- Pick 2–3 core features and trace them end to end. Count the hops: files touched, layers crossed, indirections followed to answer "where does this actually happen?"
- Note where you had to hold the most in your head. That's where simplification pays.

## Phase 2 — Audit through 7 lenses
1. **One-implementation abstractions** — interfaces, base classes, and strategy patterns with exactly one concrete case
2. **Pass-through layers** — functions and services that only forward to another with no added value
3. **Frozen config** — options and parameters that have had one value forever: inline them
4. **Unused flexibility** — generalization for cases that never arrived; plugin systems with one plugin
5. **Stored derivables** — state that's cached-and-synced when it could simply be computed
6. **Cleverness tax** — code requiring archaeology to decode, where the boring version is 3 lines longer and instantly clear
7. **Imported ceremony** — patterns sized for a 200-engineer org living in a small codebase

## Phase 3 — Curate
- For each: current shape → simpler shape, lines removed, hops removed, risk
- Also list complexity that EARNS its place — load-bearing abstraction to explicitly keep

## Phase 4 — Report
Create `SIMPLIFY.md` at repo root:
1. **Hop counts** — the traced features and their indirection tally, before
2. **Simplifications** — each: location · current → simpler · lines/hops removed · risk · effort
3. **Ranked by clarity-per-risk**
4. **Keep list** — complexity that's justified, so nobody "simplifies" it later
5. **Before/after sketch** — the top item shown both ways

Start the report with today's date. If `SIMPLIFY.md` already exists from a previous run, read it first and lead with what changed since.

## Rules
- Simple means fewer concepts to hold, not fewer characters
- Never remove flexibility that's actually exercised — check callers first
- If a `reports/` directory exists at the repo root, write the report there instead of the root.
- Before asking, present the top findings as a ranked list in plain words
- Report only — end by asking which simplifications to make

House rules for this Goal Prompt

  • Simple means fewer concepts to hold, not fewer characters
  • Never remove flexibility that's actually exercised — check callers first
  • If a reports/ directory exists at the repo root, write the report there instead of the root.
  • Before asking, present the top findings as a ranked list in plain words
  • Report only — end by asking which simplifications to make
Keep exploring

More Subtract briefs

Runs inside these playbooks — curated sequences you can launch with one paste: