find-design-necessity — quality + safety report

---
name: find-design-necessity
description: Force a "why does this part exist" audit on any product, system, codebase, or process where redundant artifacts have accumulated because two teams each thought they owned the problem. Trigger this skill aggressively when the user is doing a product audit, architecture review, dependency cleanup, BOM scrub, redundancy hunt, refactor scoping, or asking "why does this exist", "the bill of materials looks bloated", "we have a wrapper around a wrapper", "there's a service that just proxies another service", "this layer doesn't do anything", "why do we have two databases storing the same field", "the schema has redundant columns", or any moment a team is treating organizational artifacts as physical requirements. Also fires on bloated configs, duplicate CI steps, parallel pipelines that produce the same artifact, and any inherited structure no one can justify from first principles. Trigger eagerly even when the user does not name Musk or the framework.
stacks_with:
  - shortest-path-communication
---

# Find Design Necessity

> "Find the design necessity of every part and every process."
> — Elon Musk, *The Book of Elon* (Chapter: Remove Organizational Boundaries (design-necessity subsection))

## What this skill captures

Every part of a product is either traceable to a real, surviving physical or functional requirement — or it is organizational residue. Musk's specific diagnostic from the Model 3 battery pack: "You can see the organizational boundaries in the product. You'll often get a box in a box... because both teams thought they needed an enclosure, the product ends up with an enclosure in an enclosure." The Model 3 battery had its own top cover; the car already had an underbody sitting directly above it. Two teams, two enclosures, one redundant slab of mass and cost. "You don't need a cover on the battery — there's a car on top of it." Delete it.

This skill forces the user to walk every part, layer, service, schema field, build step, or process stage and ask: what surviving requirement does this trace to? If the only answer is "another team built theirs assuming we wouldn't build ours" — it should be deleted. The value: you stop paying mass, cost, latency, and cognitive tax for boundaries that exist only on an org chart.

## When to use this skill

- Product audits where the BOM, schematic, or architecture diagram has accumulated layers no one can justify from first principles.
- Refactor scoping where two services, two schemas, two configs, or two abstractions cover overlapping responsibility.
- Reviewing a system where you spot a wrapper around a wrapper, a proxy in front of a proxy, or a config that just re-declares another config.
- Onboarding into an inherited codebase and asking "why is this here" about a class, table, microservice, or build step nobody owns.
- Hardware or manufacturing reviews where mass, cost, or part count looks bloated relative to function.
- Any moment the user says "both teams thought they needed X" or "we ended up with two of these."

## The how-to

1. List every part, layer, or process stage explicitly. Don't audit in your head — enumerate.
   > "Find the design necessity of every part and every process."
   > — *The Book of Elon*
   You cannot delete what you have not named. Make the list exhaustive even if it feels tedious.

2. For each item, force a one-sentence justification grounded in a surviving physical or functional requirement — not in "another team expected it."
   > "You can see the organizational boundaries in the product. You'll often get a box in a box. You realize, 'Why is this thing in two boxes?'"
   > — *The Book of Elon*
   If the justification names another team, a legacy contract, or a historical assumption rather than a current requirement, flag it.

3. Look explicitly for the "box in a box" pattern: two enclosures, two validators, two caches, two retry layers, two schemas storing the same field.
   > "Turns out, because both teams thought they needed an enclosure, the product ends up with an enclosure in an enclosure."
   > — *The Book of Elon*
   These are almost always organizational, not physical. They are the first things to delete.

4. Quantify the cost of every flagged part — mass, dollars, latency, lines of code, cognitive load, on-call surface area.
   > "Putting the cover on the battery pack adds mass and cost, so it should be deleted."
   > — *The Book of Elon*
   "It seems harmless" is not a defense. Every unjustified part is paying rent in some currency.

5. Delete the redundant one. Default to deletion; require the owner to prove necessity, not the auditor to prove redundancy.
   > "It makes sense from an individual team's perspective, but you don't need a cover on the battery — there's a car on top of it."
   > — *The Book of Elon*
   Individual-team logic is exactly what produces the box-in-a-box. Override it at the system level.

6. Put the designers and the manufacturers (or the architects and the operators) in the same room when reviewing. Distance hides redundancy.
   > "If your hand is on a stove and it gets hot, you pull it right off. But if it's someone else's hand on the stove, it will take you longer to do something about it."
   > — *The Book of Elon*
   The team that pays the cost of the redundant part must be in the review, or the redundancy survives.

## Common failure modes

- **Auditing in the abstract.** Talking about "simplification" without naming individual parts. The diagnostic only works at the part level.
- **Accepting "another team owns that" as a justification.** That is the exact pathology — organizational boundaries presenting as design requirements. Reject it.
- **Local-team optimization.** "It makes sense from an individual team's perspective" is true and irrelevant. The system-level question is whether the part is necessary at all.
- **Deleting the wrong box.** When you find a box-in-a-box, identify which one carries the load (the car body, not the battery cover) and delete the one that exists only because a team thought it needed one.
- **Stopping at the obvious.** One round of deletion exposes the next layer. Re-run the audit after the easy wins.

## When NOT to use this skill

- The redundancy is intentional defense-in-depth for a catastrophic-failure mode (safety-critical isolation, security boundaries with adversarial threat models). Two enclosures around a high-voltage pack near humans is not residue — it's regulation.
- You are debating communication flow or chain-of-command problems. That's `shortest-path-communication`, not this.
- You are early in a design and have not yet built the part. This is an audit tool for existing artifacts, not a greenfield design constraint (use `the-algorithm` step 2 "delete the part" for greenfield).
- The "redundant" part has a different SLA, failure domain, or consumer than the part it appears to duplicate. Confirm before deleting.

## Source

The Book of Elon by Eric Jorgenson (2026, Scribe Media). Chapter: "Remove Organizational Boundaries (design-necessity subsection)" (in "Designing the Organization").