CODE: A Four-Step Loop for Knowledge That Compounds.

1. 1

   CODE is a four-step workflow for turning information into output. The steps are Capture, Organize, Distill, and Express, run as a cycle rather than a one-time sequence. The same piece of content can cycle through CODE many times: captured once, organized once, distilled in passes, expressed eventually as part of work you ship. The cycle is what makes it different from passive note-taking: every step has a forward motion, and the existence of the next step shapes how you do the current one.

2. 2

   Capture is the intake step. Anything you find worth keeping (a quote, a link, a thought, a voice memo, a screenshot, a stray idea between meetings) lands in your second brain quickly, without filtering at the door. The principle is "save broadly, decide later". Forte argues that the moment of capture is exactly the wrong moment to make organizational decisions, because you cannot yet know whether the item will turn out to matter. Better to save with low friction and sort later than to filter rigorously at the door and lose half of what mattered.

3. 3

   Organize is the routing step. Captured items get placed in PARA buckets: Projects, Areas, Resources, or Archives. The placement reflects how you will use the item, not what topic it covers. Most items land in Resources by default; only a fraction relate to an active Project. The Organize step is supposed to be fast: a couple of seconds per item, ideally done in batches rather than at capture time. Slow organize routines are the symptom of a system that is asking too much of the user.

4. 4

   Distill is the compression step. Long captures become short notes. Highlights become marginalia. Marginalia become takeaways. Each pass strips the original down to its essence, so a year later you can scan a paragraph instead of re-reading the source. Distillation is iterative by design: you do not need to produce the final summary on first contact. The first pass might just be a few sentences. Months later, when the topic resurfaces, you compress further. The slow accumulation of distilled versions is what makes the saved material usable years later.

5. 5

   Express is the output step. The point of saving, organizing, and distilling is to use what you have learned in real work: a paper, a memo, a presentation, a product decision, a conversation, a teaching moment, a piece of writing. The other three steps exist to feed this one. Forte's frequent reminder: if the system never produces output, it is a hobby. A real second brain produces things, even small things, on a regular cadence. The cadence matters more than the size of any individual output.

• Knowledge workers who want their reading to do something

  If you read a lot but feel like the reading sits inert, CODE is the workflow that closes the loop. The fix is not reading less; it is treating each thing you read as raw material that gets distilled and expressed downstream. The shift in mindset is what matters: every article, podcast, book, and conversation becomes something that will eventually feed a memo, a decision, or a piece of writing. The Capture step gets easier with this frame because you stop wondering "do I really need to save this"; you save it because you trust the rest of the cycle to make use of it.

• Writers shipping non-fiction

  Articles, books, newsletters, essays: every piece of long-form non-fiction is a CODE cycle. Capture the sources, organize them by Project, distill the essence into your own words, express the result. Writers who consistently ship are running CODE explicitly or instinctively; the ones who get stuck almost always have a missing or weak step. Usually it is Distill: they have plenty of captured material organized into Project folders but never compressed it into usable summaries, so each writing session restarts from raw source instead of from synthesis.

• Researchers and PhD students

  A dissertation is a multi-year CODE cycle. The literature review is Capture and Organize, paper by paper. The thesis-building is Distill, where dozens of papers compress into the few claims your dissertation actually makes. The defense and the published paper are Express. Treating the doctorate as a CODE workflow keeps the work organized without requiring a new system every chapter. The same applies to any long research project: a book proposal, a multi-year industry analysis, a policy paper that needs to draw on a decade of evidence.

• Anyone whose knowledge feels stuck

  A lot of "I know things but cannot use them" is really a missing Express step. CODE makes the absence of Express visible: if you are only Capturing and Organizing, the cycle is incomplete and the saved material accumulates without paying you back. The fix is to put a small Express step at the end of every week, even a private one: a one-page memo for yourself, a Slack message to a coworker, a journal entry, a comment on a colleague's draft. The output does not have to be public to count.

• Capture: save broadly, filter later

  The most common failure mode for second brains is over-filtering at the moment of capture. CODE inverts the instinct: when something resonates, save it, even if you cannot yet articulate why. The cost of a save you never use is small (some disk space, a few cents of AI processing, no time penalty if capture is fast). The cost of not saving something that turned out to matter is high (you forget it existed, the work you could have done with it never happens). The asymmetry favors saving generously. The discipline is not "save less", it is "trust the later steps to handle the volume".

• Organize: by actionability, not topic

  CODE's Organize step uses PARA, which puts items in buckets based on how you will use them rather than what they are about. A marketing PDF for an active campaign goes in Projects. The same PDF a year later goes in Archives. The location follows the action, not the topic. This is the same principle PARA stands on, and the reason the two methods are designed to work together. The shortcut to getting Organize right is to ask "what would I do with this item" instead of "what is this item about". The first question routes the item correctly; the second leads to topic folders that fail over time.

• Distill: progressive summarization

  Forte calls his Distill technique "progressive summarization". A long captured note gets re-read; the important parts get bolded. On the next re-read, the most important of the bolded parts get highlighted. On the third pass, the highlighted parts get rewritten as a one-sentence summary. Three passes, three layers, ten times faster to scan in the future. The layered structure means you can read the note at any depth: the one-sentence summary for a quick scan, the highlights for moderate detail, the full note when you need everything. Distillation is the step most people skip; it is also the step that pays the largest dividend, because it is what makes future-you actually able to use what past-you saved.

• Express: the cycle is for shipping

  Express is not optional. Without it, the previous three steps become a collecting hobby. Express can be small: a memo, a slack message, a private journal entry, a comment on someone else's document, a tweet, a paragraph in your team's wiki. The point is to convert distilled material into produced material. Frequency of Express is what makes the second brain pay off; a system that produces one polished essay a year is less valuable than one that produces a small piece of output every week. Forte argues for what he calls "intermediate packets": small reusable chunks of finished thinking that feed into larger work later.

• Capturing without ever Distilling

  The first three months of running CODE often look like aggressive Capture and weak Distill. The library fills with material no one has compressed yet. The fix: schedule a weekly Distill block, even just thirty minutes, where you re-read recent captures and bold the important parts. Without this rhythm, captured material becomes inert and the cycle stops paying you back.

• Treating Express as "write a book"

  Newcomers imagine Express as the final output of a year of work. They never start, because the output bar is set impossibly high. The fix: redefine Express as anything that converts distilled material into produced text. A two-paragraph internal memo counts. A Slack reply that links to a captured insight counts. The cadence matters more than the polish; do small Express every week, and the big outputs accumulate from the small ones.

• Using CODE without PARA underneath

  CODE and PARA were designed together. Running CODE on a topic-based folder structure breaks the Organize step: you end up routing items by subject rather than by action context. The fix: adopt PARA explicitly for the Organize bucket structure. The two methods are not optional pairs; CODE assumes PARA is doing the routing work.

• Skipping the cycle pattern

  CODE is a loop, not a linear sequence. New users sometimes treat it as Capture → Organize → Distill → Express → done, and feel betrayed when they need to revisit earlier steps. The fix: expect to cycle. The same item can be re-organized as your projects change, re-distilled when the topic resurfaces, and expressed differently in different contexts. The cyclical nature is the feature, not a bug.

Mindly was built around the CODE workflow without naming it that way. Quick Capture is the Capture step: one shortcut, any content, no folder decision at intake. The principle of "save broadly, decide later" is enforced by the tool because the capture flow does not ask you to categorize anything; you press the shortcut, drop in the content, and the item lands in your library to be sorted later. Spaces and AI tagging handle the Organize step: items land in their right Space automatically, with topic tags applied by AI in the background, so the routing happens without you stopping to think about it. AI summaries do the first pass of Distill: a 2,000-word article becomes a five-sentence summary in seconds, and you can refine that summary further as you re-encounter the item over time. The progressive summarization Forte describes happens naturally because Mindly lets you re-edit the AI summary into your own words, then re-edit it again later. The Notes Editor is the Express surface: write directly inside Mindly using the distilled material that already sits in your library, with one-click references to past notes, captured highlights, and voice memos that feed your current draft. The full cycle (Capture, Organize, Distill, Express) happens in one tool, in the same window, instead of spread across four apps. That consolidation is the entire point of a second brain, and it is the part that most note apps still get wrong. If you have been running CODE across a stack of separate tools (capture in one app, organize in another, distill in a third, express in a fourth), the friction between steps is what is making the cycle break. Running the whole loop in one place is what finally makes the system durable.

• OrganizationPARA MethodPARA Method
• Thinking systemZettelkasten MethodZettelkasten Method