Skip to main content
skill CX Codex

thinking-via-negativa — Claude Code skill: subtract before you add

A skill that makes the agent look for what can be removed before it adds anything new. Useful when the reflex is to bolt on another layer or dependency.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add tjboudreaux/cc-thinking-skills --skill thinking-via-negativa -a claude-code
Open on GitHub

What thinking-via-negativa does

The skill lays out a seven-step procedure. The agent states the goal and the proposed addition in one line, then lists what could be removed or stopped to reach the same goal with less surface area. Candidates need evidence: usage data, a call graph, metrics or an experiment, not taste.

An irreversibility guard runs before any deletion. The agent sorts elements into reversible and hard-to-restore, finds dependents, and refuses to delete unproven mystery guards. It removes the safest high-value candidate first, monitors the result, and only then moves to the next one. An addition is allowed if the goal still fails after subtraction, and the agent records why removal was not enough.

A separate section covers when not to use it: auth, validation, tests, rate limits, retries and safety checks are presumed necessary until proven dead. The agent will not strip those for purity or a smaller line count. Output is a report with the goal, removal candidates, the action taken, a verification plan, and a do-not-touch list.

Install goes through npx skills add, and the skill file lands in the platform's skills directory.

What it helps with

  • stop the reflex to add a dependency for every problem
  • find unused code from call data instead of guesswork
  • tell a reversible deletion apart from an irreversible one
  • keep safety checks intact while cleaning up a codebase
  • document why subtraction failed and a minimal change is needed

Example prompts for the agent

  • Before adding a cache, check what can be removed from this path
  • Run the via negativa procedure on this bottleneck
  • Find dependencies here that are not used and propose removal with evidence

How to install thinking-via-negativa

1Skills CLI (Vercel)

npx skills add tjboudreaux/cc-thinking-skills --skill thinking-via-negativa -a claude-code

2Manually: put the files in place

~/.claude/skills/thinking-via-negativa/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/thinking-via-negativa/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about thinking-via-negativa

How do I install thinking-via-negativa in Claude?

Run npx skills add tjboudreaux/cc-thinking-skills --skill thinking-via-negativa -a claude-code. The skill file ends up at ~/.claude/skills/thinking-via-negativa/SKILL.md.

What does thinking-via-negativa do?

It makes the agent look for what can be removed or stopped first, and add something only if subtraction fails. Before deleting, it checks how hard the element would be to restore.

What does the skill say not to remove?

Auth, validation, tests, rate limits, retries and safety checks. They count as necessary until proven dead.

Source text

SKILL.md · MIT
---
name: thinking-via-negativa
description: Use when the reflex is to add a feature, layer, or process. Prefer removing harmful or nonessential elements first, with an irreversibility guard before deletion.
disable-model-invocation: true
---

# Via Negativa

Improve by subtraction before addition. Prefer removing harm, waste, and nonessential complexity; add only when a demonstrated need remains after removal candidates are exhausted.

## When to Use

- About to add a feature, abstraction, dependency, process, or control to fix a problem.
- Simplifying a system or workflow where complexity is the tax.
- Prioritizing by deciding what not to keep, build, or maintain.
- Performance or reliability work where eliminating a bad path beats bolting on mitigation.

## When NOT to Use

- Load-bearing controls: auth, validation, tests, rate limits, retries, safety checks — presume necessary until proven dead.
- A demonstrated requirement that cannot be met by removal or simplification.
- Aesthetic minimalism without evidence of non-use or net harm.
- Irreversible deletion without a rollback path when impact is unknown.

## Procedure

1. **Pause the add reflex.** State the goal and the proposed addition in one line.
2. **Ask the subtraction question first.** List what could be removed or stopped to achieve the same goal with less surface area.
3. **Catalog candidates with evidence.** Prefer unused, redundant, high-cost/low-value, or harmful elements. Require usage, call-graph, metrics, or experiment evidence — not taste.
4. **Apply the irreversibility guard.** Classify reversible vs hard-to-restore; identify dependents; refuse deleting unproven mystery guards. Plan staged removal or flag when risk is non-trivial.
5. **Remove the safest high-value candidate first.** Subtract, monitor, and verify absence of needed behavior before the next removal.
6. **Add only if the goal still fails.** If subtraction cannot meet the need, add the minimum change and record why removal was insufficient.
7. **Stop** when the goal is met by absence, or remaining candidates fail the irreversibility/evidence bar and a minimal addition is justified.

**Stop condition:** Goal achieved via removal, or residual need documented after evidence-backed subtraction failed.

## Output

```text
Goal: <desired outcome>
Proposed add (if any): <thing>
Removal candidates: <element — evidence — risk — reversible?>
Action: remove <X> | staged remove <X> | add minimal <Y> because <why removal failed>
Verification plan: <how absence/success is checked>
Do-not-touch: <load-bearing items preserved>
```

## Verification

- Falsify if something was deleted without non-use/harm evidence, or a safety control was removed as "complexity."
- Falsify if an addition shipped without a prior subtraction pass on the same goal.
- Over-application guard: do not delete for line-count or purity when the element is load-bearing or the need is demonstrated.

© tjboudreaux · MIT · tjboudreaux/cc-thinking-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set27

thinking-reversibility A skill that makes the agent check how expensive a decision is to undo before it decides how much analysis to spend. Useful when you can't tell whether deep thought is warranted. CX Codex +1 577installs thinking-circle-of-competence Makes the agent answer only from what it read or ran in this session. Useful when a confident wrong answer costs you. CX Codex +1 572installs thinking-five-whys-plus Builds an evidence-backed causal chain from a localized fault to its systemic root. It helps uncover why an issue happened when symptom-level hotfixes keep failing. CX Codex +1 571installs thinking-ooda A skill for incidents and moving-target debugging: it runs the agent through Observe→Orient→Decide→Act at ~70% confidence, then re-observes. CX Codex +1 572installs thinking-jobs-to-be-done Works out the progress a user hires a product for, then ranks features by it. Useful when you cannot tell what to cut and what to grow. CX Codex +1 568installs thinking-cynefin Sorts a problem into a Cynefin domain by cause and effect, then names the response mode: runbook, analysis, probe or stabilize. Useful when a method keeps failing. CX Codex +1 567installs thinking-bounded-rationality A skill that halts a search at the first option clearing a threshold you set beforehand, instead of comparing forever. CX Codex +1 563installs thinking-model-combination A skill that sequences 2–3 mental models with named roles when one model leaves a blind spot. Built for multi-domain decisions. CX Codex +1 563installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor