Core Primitive
Set expiration dates on time-sensitive information so it does not clutter your system.
Your system is not too empty. It is too full.
You have been taught, across decades of productivity advice, that the danger is losing information. Capture everything. Save it for later. File it somewhere you can find it. The fear is always the same: what if you need it and it is gone?
This fear is reasonable in a world of scarcity. When information lived in physical books, paper files, and handwritten notes, losing a document meant losing access to the knowledge it contained. The cost of loss was high. The cost of storage was also high — physical space, filing cabinets, retrieval time — but the fear of loss almost always won. Better to keep too much than to lose something important.
You do not live in that world. You live in a world where storage is effectively free, where every app encourages you to save, bookmark, clip, and archive, and where the cost of keeping something is invisible — until it is not. The cost does not announce itself as a storage bill. It announces itself as friction. Every search that returns eight results instead of two. Every review session where you spend minutes re-evaluating items you have already decided are irrelevant. Every moment of hesitation when you encounter an old note and cannot immediately tell whether it reflects current reality or a reality that no longer exists.
The previous lesson taught you spaced repetition — the systematic practice of reviewing information at calibrated intervals to move it into long-term memory. That lesson answered the question: how do you keep what matters? This lesson answers the question that spaced repetition deliberately avoids: how do you release what no longer matters?
Not all information deserves retention. In fact, most information has a finite lifespan. And a system that retains everything indefinitely is not comprehensive — it is cluttered. It is an attic that never gets cleaned, where the Christmas decorations from 2003 sit next to the ones from last year and you cannot tell which is which without opening every box.
Information expiration is not loss. It is maintenance. And the failure to maintain your information system degrades it just as surely as the failure to add new information.
The half-life of facts
In 2012, Samuel Arbesman, a computational biologist and complexity scientist, published The Half-Life of Facts, a book-length argument that knowledge itself decays at measurable, predictable rates. Arbesman's central claim is that facts — the things we treat as stable, settled truths — change constantly, and they change at rates that can be modeled mathematically.
His evidence is striking. Medical knowledge has a half-life of roughly 45 years, meaning that half of what a medical school graduate learns is either wrong or obsolete within 45 years of graduation. In some fast-moving subfields, the half-life is far shorter. A study published in the Annals of Surgery found that the half-life of surgical knowledge — the time for half of established surgical practices to be contradicted by new evidence — was approximately 45 years as well, but in rapidly evolving areas like laparoscopic techniques, the effective half-life was closer to a decade. In physics, the half-life of factual claims is longer. In technology, it is dramatically shorter.
Arbesman's insight is not that knowledge is unreliable. It is that knowledge is dynamic, and that treating it as static — filing it away and assuming it remains valid — is a systematic error. Every fact you store in your system was true at the time you stored it. Whether it is still true depends on its category, its domain, and how much time has passed. The pricing data you saved last quarter is almost certainly outdated. The principles of negotiation you noted from a book published in 1981 are almost certainly still valid. But your system treats them identically: both are notes. Both appear in searches. Both occupy space in your reviews.
This is the cost of missing expiration metadata. Without it, your system cannot distinguish between information that is current and information that has silently become wrong.
The Lindy effect: what survives deserves to stay
If Arbesman tells you that knowledge decays, Nassim Nicholas Taleb tells you which knowledge resists decay. The Lindy effect, which Taleb explored in Antifragile (2012) and expanded in Skin in the Game (2018), provides a powerful heuristic for predicting the remaining lifespan of non-perishable things — ideas, books, technologies, practices.
The principle is simple: for non-perishable items, the expected remaining lifespan is proportional to the current age. A book that has been in print for fifty years is expected to remain in print for roughly another fifty years. A technology that has been in use for a century is expected to remain in use for roughly another century. A restaurant that opened last month has a short expected lifespan. A restaurant that has been open for forty years is likely to remain open for decades more.
Applied to your information system, the Lindy effect produces an actionable sorting rule. When you assess a piece of stored information, ask: how old is this, and is it still considered valid?
If it is old and still valid — a principle of logic, a fundamental insight about human psychology, a mathematical theorem, a philosophical argument that has survived centuries of critique — it is Lindy-robust. It does not need an expiration date. It is more likely to remain valid precisely because it has already survived so long. Mark it as evergreen and stop worrying about it.
If it is new and untested — a hot take, a trending framework, a recently published study that has not yet been replicated, a prediction about next quarter — it is Lindy-fragile. It may or may not survive. Give it a short expiration date and force yourself to re-evaluate when that date arrives. Most new information will not survive its own expiration window, and that is not a tragedy. It is the normal lifecycle of time-bound knowledge.
The combination of Arbesman and Taleb gives you a two-part framework: knowledge decays at measurable rates (Arbesman), and the best predictor of future survival is past survival (Taleb). Together, they tell you that your system should contain a small core of evergreen material that grows slowly and a much larger flow of time-bound material that enters, serves its purpose, and exits.
Stewart Brand's pace layers: different speeds of change
The architect and writer Stewart Brand proposed a model called "pace layers" in his 1999 book The Clock of the Long Now. Brand observed that civilization operates at multiple speeds simultaneously. Fashion changes in months. Commerce changes in years. Infrastructure changes in decades. Governance changes in generations. Culture changes over centuries. Nature changes over millennia.
The layers interact: fast layers innovate, slow layers stabilize. Fast layers propose, slow layers dispose. The health of the system depends on each layer operating at its own appropriate speed — and on the layers not being confused with each other.
Your information system contains all of these layers simultaneously, and the mistake most people make is treating them as if they operate at the same speed. Here is what the pace layers look like in a personal knowledge system:
Fashion-speed information (weeks to months). News. Social media trends. Current events. Product announcements. Conference talks. Viral articles. This information is interesting in the moment and nearly worthless three months later. It should enter your system only if it connects to an active decision or project, and it should carry a short expiration date.
Commerce-speed information (months to years). Project documentation. Market analyses. Competitive intelligence. Technical specifications for current tools. Industry reports. Best practices in your field as currently understood. This information is useful for the duration of a project or a role and should be reviewed when the project or role ends.
Infrastructure-speed information (years to decades). Career skills. Domain expertise. Professional relationships. Organizational knowledge. Technical fundamentals. This information changes, but slowly. Review it annually or when major shifts occur in your field.
Governance-speed information (decades to centuries). Principles of logic. Decision-making frameworks. Ethics. Human psychology. Foundational scientific findings. Mathematical truths. History. Philosophy. This information is effectively permanent. It does not need expiration dates. It needs only to be accessible.
When you capture a new piece of information, placing it on the correct pace layer immediately tells you its approximate expiration window. A tweet about a trending AI tool is fashion-speed — expires in weeks. A research paper on transformer architectures is commerce-speed — valid for a few years until the field shifts. A note on the principles of clear writing is governance-speed — valid indefinitely.
The maintenance cost of stored information
Every item in your system carries a hidden cost. Not a storage cost — digital storage is so cheap that it is effectively free. The cost is cognitive.
Research on information overload, including work by Martin Eppler and Jeanne Mengis published in The Information Society (2004), consistently finds that beyond a threshold, additional stored information does not improve decision quality — it degrades it. The mechanism is retrieval friction. When you search for information and get two results, you evaluate both quickly and act. When you search and get twenty results — many of which are outdated, partially relevant, or duplicative — you spend time evaluating, comparing, and discarding before you can act. The decision is delayed. The cognitive load is higher. The confidence in the final choice is lower, because you were exposed to more conflicting or ambiguous data.
This is the paradox of digital storage. Because keeping everything costs nothing in money, people keep everything. But keeping everything costs something in attention every time you interact with your system. The cost is distributed — a few extra seconds here, an extra minute of evaluation there — which makes it invisible in any single instance and devastating in aggregate.
Research on digital hoarding, including work by Ofer Bergman and Steve Whittaker in The Science of Managing Our Digital Stuff (2016), finds that excessive information retention creates measurable anxiety and decision-fatigue effects similar to those documented in physical hoarding research. People who keep everything report lower confidence in their information systems, spend more time searching, and are more likely to abandon search entirely and recreate information from scratch — even when the information they need exists in their system. The system has become so cluttered that searching it is more expensive than starting over.
The fix is not more storage. It is not better search. It is less information — specifically, less expired information. When you remove items that have outlived their usefulness, every remaining item becomes easier to find, easier to evaluate, and more likely to be relevant. The signal-to-noise ratio improves not because you added signal but because you removed noise.
TTL: what engineers already know
Software engineers solved this problem decades ago. Every caching system, every network protocol, every database with temporary data uses a concept called TTL — Time to Live. When a piece of data is created, it is assigned a TTL: the duration for which it is considered valid. When the TTL expires, the data is automatically purged or flagged for refresh. No human decision is needed at the moment of expiration. The decision was made at the moment of creation.
DNS records have TTLs. Web browser caches have TTLs. CDN caches have TTLs. API responses have TTLs. Session tokens have TTLs. Every temporary piece of data in a well-designed system carries an explicit declaration of when it stops being valid.
The reason engineers enforce TTLs is not that storage is expensive (it is cheap for them, too). It is that stale data causes errors. A cached DNS record that points to an IP address that has changed will send traffic to the wrong server. A cached API response that reflects outdated pricing will show customers the wrong price. A session token that never expires creates a security vulnerability. In engineering, the cost of stale data is not vague "clutter" — it is incorrect behavior. Systems break.
Your personal information system has the same vulnerability, but the failures are quieter. A stale competitor analysis does not crash your browser. It causes you to make a decision based on outdated intelligence. A stale set of meeting notes does not throw an error. It causes you to reference a plan that has already been revised. A stale article clipping does not return a 404. It causes you to cite a finding that has been superseded by newer research.
The engineering principle translates directly: assign a TTL at the moment of creation. When the TTL expires, archive or delete. Make expiration the default, and make retention the exception that requires an affirmative renewal.
The sunset review: your expiration enforcement mechanism
An expiration date without a review process is a label without a function. The mechanism that converts expiration dates into actual cleanup is the sunset review — a scheduled, recurring pass through your system in which you evaluate and remove expired content.
The term comes from government and corporate policy, where "sunset provisions" are built into legislation and contracts. A sunset clause states that a law or agreement automatically expires on a specific date unless it is actively renewed. The purpose is to prevent policy accumulation — the tendency for rules, regulations, and agreements to pile up indefinitely because repealing them requires effort while keeping them requires nothing.
Your information system suffers from the same accumulation dynamic. Adding a note requires a small effort. Deleting a note requires a small effort. Keeping a note requires no effort at all. The asymmetry guarantees accumulation: over time, your system grows in only one direction, because the path of least resistance is always to keep.
The sunset review counteracts this by creating a scheduled moment when the default is reversed. During the review, the question for each expired item is not "should I delete this?" (which defaults to keeping) but "should I renew this?" (which defaults to deletion). The framing matters. When you ask whether to delete, you search for reasons to keep — and you can always find one. When you ask whether to renew, you search for active reasons the information is still serving you — and for most expired items, you cannot.
Here is a practical sunset review protocol:
Monthly sweep (15 to 30 minutes). Review all items with expiration dates that have passed since the last sweep. For each: archive or delete if expired. Renew with a new expiration date if still relevant. This handles the fashion-speed and commerce-speed layers.
Quarterly deep review (60 to 90 minutes). Review all items in project-specific folders or tags for projects that have ended. Archive the entire context. Review reference material that is older than six months and assess whether it still reflects current reality. This handles the infrastructure-speed layer.
Annual purge (half day). Review your entire active system. Assess the overall volume. Check for categories that have grown disproportionately. Identify patterns in what you keep but never access. Ask: if I were building this system from scratch today, would I include this item? If the answer is no, archive or delete.
The annual purge is the information equivalent of Marie Kondo's method — not the caricature of "does this spark joy?" but the underlying principle: handle every item, make a deliberate decision, and do not keep things by default. Kondo's actual protocol, described in The Life-Changing Magic of Tidying Up (2011), works because it forces contact with every possession and replaces passive accumulation with active curation. The annual information purge does the same for your knowledge system.
The psychology of letting go
If expiration is so obviously useful, why do so few people practice it? The answer is psychological, not logistical.
Research on the endowment effect — the tendency to value things more highly simply because you own them — applies directly to information. A note you captured feels valuable because you captured it. The act of saving it created a sense of ownership, and ownership inflates perceived value. Deleting the note triggers a mild loss aversion response: what if I need this someday?
The "someday" problem is the primary psychological barrier to information expiration. For any individual item, the probability that you will need it someday is nonzero. That nonzero probability, combined with loss aversion, is enough to prevent deletion. But the calculation is wrong, because it considers only the cost of losing one item and ignores the cumulative cost of retaining thousands of items you will never access.
The correct calculation is: what is the expected cost of not having this item when I need it, versus the ongoing cost of storing it across every search, review, and interaction with my system from now until I die? For the vast majority of stored items, the ongoing cost vastly exceeds the expected loss cost — especially in a world where most information can be re-found through a web search if you ever do need it again.
This is the key insight: expiration is not permanent loss. It is reclassification from "in my personal system" to "in the world." The article you delete from your notes still exists on the internet. The data you archive still exists in the archive. You are not destroying information. You are choosing not to carry it in your active working set, the same way you choose not to carry every book you have ever read in your backpack. The books are still in the library. You can go get one if you need it.
The Third Brain: AI as expiration assistant
AI is exceptionally well-suited for information expiration because it can evaluate staleness at scale — something humans find tedious and resist doing.
An AI assistant can perform your sunset review for you as a first pass. Feed it your stored items with their creation dates and expiration tags, and ask it to identify: items whose expiration dates have passed, items with no expiration date that appear to be time-bound based on content analysis, and items that reference events, products, or conditions that have changed since the note was created. The AI can flag candidates for removal, and you make the final call.
More powerfully, AI can assign expiration dates at the moment of capture. When you save a new piece of information, an AI can analyze the content and suggest a TTL: "This appears to be a quarterly market report — suggest expiration in 4 months." "This appears to be a foundational principle — suggest marking as evergreen." "This references a software version that is likely to be superseded — suggest expiration in 12 months." You review the suggestion, adjust if needed, and save. The expiration decision is made at the moment of creation, when it is cheapest and most accurate, rather than deferred to a future review session when you have lost the original context.
AI can also detect staleness proactively. An AI that periodically scans your note system can identify notes that reference outdated statistics, superseded tools, completed projects, or changed conditions — even if those notes were never given explicit expiration dates. This is particularly valuable for legacy content: the hundreds or thousands of notes you created before you adopted expiration practices, sitting in your system with no metadata to indicate their shelf life.
The sovereignty principle holds: you define what "expired" means. You make the final decision on every item the AI flags. The AI handles the scanning, evaluating, and flagging that makes human review sessions intractable. Without AI, reviewing a thousand notes for staleness takes hours. With AI, it takes the time to review the fifty flagged candidates.
The bridge to search
You have now built a complete information lifecycle. Information enters your system through curated inputs (Input curation). It is triaged by priority (Information triage). It is processed — acted on, stored, or discarded (Processing means deciding what to do with each item). What is stored goes into reference systems (The reference filing system) or action systems (The action filing system). What deserves deep engagement enters a read-it-later queue (Read-it-later systems). What you process gets captured in atomic, connected notes (Note-taking as information processing, The Zettelkasten method). What deserves long-term retention gets reinforced through spaced repetition (Spaced repetition for retention). And now, what has outlived its usefulness gets expired and removed.
This lifecycle means your system is not a one-directional accumulator. Information flows in and information flows out. The system breathes. It stays lean, current, and trustworthy.
And that trustworthiness — the confidence that what your system contains is actually valid — changes how you retrieve information. When your system is cluttered with stale, expired, and outdated content, you cannot trust search results. You have to manually evaluate every result for currency, which makes search slow and unreliable. When your system contains only current, non-expired content — because you have been systematically removing what has expired — you can trust that what search returns is worth your attention.
This trust is what makes the next paradigm possible. The next lesson introduces search over sort — the principle that in a well-maintained system, powerful search tools make elaborate folder hierarchies unnecessary. But "well-maintained" is the operative phrase. Search over sort only works when the information being searched is current. Expiration is the practice that makes that condition true.
Sources:
- Arbesman, S. (2012). The Half-Life of Facts: Why Everything We Know Has an Expiration Date. Current/Penguin.
- Taleb, N. N. (2012). Antifragile: Things That Gain from Disorder. Random House.
- Taleb, N. N. (2018). Skin in the Game: Hidden Asymmetries in Daily Life. Random House.
- Brand, S. (1999). The Clock of the Long Now: Time and Responsibility. Basic Books.
- Eppler, M. J., & Mengis, J. (2004). "The Concept of Information Overload: A Review of Literature." The Information Society, 20(5), 325-344.
- Bergman, O., & Whittaker, S. (2016). The Science of Managing Our Digital Stuff. MIT Press.
- Kondo, M. (2011). The Life-Changing Magic of Tidying Up. Ten Speed Press (English translation, 2014).
- Kahneman, D., Knetsch, J. L., & Thaler, R. H. (1990). "Experimental Tests of the Endowment Effect and the Coase Theorem." Journal of Political Economy, 98(6), 1325-1348.
- Bhatt, S., et al. (2014). "Evaluating the Half-Life of Surgical Knowledge." American Surgeon, 80(7), 726-731.
Frequently Asked Questions