Information Redundancy

---
name: information-redundancy
description: "Maps where redundancy creates resilience and error correction versus where it creates waste. Use when asked about 'duplication', 'repetition', 'backup systems', 'is this redundant?', 'we're saying the same thing twice', 'single point of failure', or 'is this repetition helping or hurting'."
---

# Information: Redundancy

Redundancy is the presence of more information than is strictly necessary to transmit a message. In everyday usage, "redundant" is a criticism — meaning wasteful, duplicative, bloated. Shannon's information theory revealed the other side: redundancy is also the mechanism by which messages survive noisy channels. Without redundancy, a single corrupted bit destroys the message. With the right kind of redundancy, errors are detectable and correctable.

English has roughly 75% redundancy — far more than the minimum required to convey meaning. This is not a design flaw. It's what allows us to understand messages even when words are missing, sentences are incomplete, or the channel is imperfect. The same principle appears everywhere: RAID arrays duplicate data across disks so a drive failure doesn't mean data loss; aviation uses triple-redundant systems so a single component failure doesn't mean a crash; well-structured arguments repeat their core claim in multiple forms because readers approach text non-linearly and a single statement may be missed.

The analytical task is to distinguish these two faces of redundancy. Load-bearing redundancy serves a function: fault tolerance, error correction, pattern reinforcement, or verification. Wasteful redundancy serves no function: it is repetition without purpose, bulk without benefit, duplication that increases cost without increasing robustness. The line between them is determined by the system's failure modes and the value of what it's protecting.

Shannon's coding theorems established that redundancy can be added optimally — there is a minimum amount of redundancy needed to achieve a given level of error correction. This is the basis of modern error-correcting codes. The applied insight: before eliminating redundancy, understand whether the redundancy is doing error-correction work you'd otherwise lose.

---

## Your Process

**Step 1: Identify All Instances of Redundancy**
Enumerate every place where information, functionality, or effort is duplicated. Be exhaustive first; classify second. Types to look for:
- **Informational redundancy:** the same claim, data point, or message appears in multiple places
- **Structural redundancy:** the same function is performed by multiple components
- **Organisational redundancy:** multiple teams, roles, or processes do the same work
- **Communication redundancy:** the same message is delivered through multiple channels or phrasings
- **Temporal redundancy:** something is repeated over time — regular check-ins, repeated reminders, copies of backups

**Framing check:** Confirm the domain and the redundancy concern before continuing. State what you've identified — the system being analysed and the specific redundancy in question — in one sentence, then use `AskUserQuestion`:
- **Question:** "I'm reading this as: [your one-sentence framing of the system and the redundancy question]. Is that right?"
- **Header:** "Framing"
- **Options:**
  - **Yes — proceed** — framing is correct
  - **Adjust** — one element is off; user will correct it before you continue
  - **Reframe** — different situation than read; incorporate the correction before proceeding

**Step 2: Classify Each Redundancy**
For each identified instance, determine its function:

**Load-bearing redundancy — preserve it:**
- *Fault tolerance:* if one instance fails, another takes over. The redundancy is the backup.
- *Error correction:* the duplication allows detection and recovery of errors (checksums, parity bits, double-entry bookkeeping)
- *Reinforcement:* repetition is needed because the channel is lossy or the receiver is inattentive — the repeat carries the message where the first instance failed
- *Verification:* two independent calculations that should agree; disagreement signals an error

**Wasteful redundancy — remove it:**
- *Accumulated duplication:* redundancy that arose through process accretion, not design
- *Defensive repetition:* saying something multiple times because the communicator is uncertain it was heard — a symptom of a broken feedback loop, not a solution
- *Uncoordinated effort:* multiple teams performing the same work without awareness of each other
- *False safety:* redundancy that appears to offer fault tolerance but actually creates coupled failure — two backups stored in the same building, or two reviewers from the same team

**Step 3: Assess the Failure Mode**
For each load-bearing redundancy: what failure does it protect against? How likely is that failure? What is the cost of the failure if it occurs? This determines whether the redundancy is appropriately sized.

For each candidate for removal: what is lost if the redundancy is cut? Is there a currently-hidden coupling that the redundancy is silently compensating for?

**Before recommending cuts:** Present the full analysis before making any removal recommendations. Use `AskUserQuestion`:
- **Question:** "I've mapped [N] redundancies as load-bearing and [M] as wasteful. Before I recommend what to cut, are there failure modes I should understand better, or any redundancies you know serve a purpose I haven't identified?"
- **Header:** "Failure modes"
- **Options:**
  - **Proceed with your recommendations** — the analysis looks right
  - **There's a failure mode you missed** — user will describe it
  - **One of the 'wasteful' redundancies is actually load-bearing** — user will identify it

**Step 4: Recommend Redundancy Strategy**
- Specify which redundancies to preserve (and why — what failure they protect against)
- Specify which to eliminate (and the net gain — cost savings, reduced confusion, cleaner signal)
- Identify any redundancies that are the wrong kind — providing false safety — and what to replace them with
- Flag any single points of failure exposed by the current redundancy architecture

---

## Human Check-in

Before proceeding, use the `AskUserQuestion` tool. State your interpretation of the situation in 1–2 sentences — what system is being analysed, what the redundancy concern is, and what the key trade-off is — then ask:

- **Question:** "My read: [your 1–2 sentence interpretation]. How do you want to proceed?"
- **Header:** "Scope"
- **Options:**
  - **Full analysis** — Complete all steps with reasoning, failure modes, and full recommendations
  - **Key findings only** — Which redundancies are load-bearing, which are wasteful, and what to do
  - **Specific focus** — Zoom in on one system: the communication redundancy, the organisational duplication, or the fault tolerance architecture
  - **Reframe** — The read is off; correct it and the analysis will follow the corrected framing

Proceed based on their selection. If the user reframes, incorporate the correction before running any analysis.

## Output Format

**Redundancy Map**

| Instance | Type | Classification | Failure Protected | Recommendation |
|---|---|---|---|---|
| [instance] | Informational / Structural / Organisational / Communication / Temporal | Load-bearing / Wasteful / False safety | [what it protects — or "none"] | Preserve / Remove / Replace |

**Single Points of Failure:** [Anything currently unprotected that should have redundancy]

**False Safety Redundancies:** [Redundancies that appear protective but aren't — coupled failure risks]

**Net Impact of Recommendations:**
- Removing wasteful redundancy: [cost savings, clarity gains, confusion reduction]
- Preserving load-bearing redundancy: [failure modes protected]
- Adding missing redundancy: [what to add and why]

---

## Notes

Redundancy analysis is most powerful when the failure modes are explicit. The question "is this redundant?" cannot be fully answered without "redundant in protecting against what?" A message that seems repetitive in a reliable channel becomes essential in an unreliable one.

This skill is adjacent to but distinct from `/information-compression` (which is about representation efficiency) and `/systems-archetype-matching` (which includes patterns where redundancy either creates or masks systemic failure). For organisational duplication specifically, `/resource-waste-audit` may be the more direct tool.

---

## What's Next

After delivering this output, use `AskUserQuestion` to offer the next move:

- **Question:** "Redundancy mapped. What's next?"
- **Header:** "Next"
- **Options:**
  - `/information-compression` — Remove the wasteful redundancy as part of a broader compression strategy
  - `/systems-feedback-mapping` — Understand the system dynamics that produced the redundancy pattern
  - `/resource-waste-audit` — Extend the analysis to other forms of organisational waste
  - **Done** — Wrap up and synthesise what we have so far