
<h2 className="micro">The Context</h2>

We are all familiar with the recommendation algorithm – the dark forces that shove fad-diet-shills, flat-earthers, and Jordan Peterson into our feeds.

They've become a modern myth. There are a thousand moral panic op-eds raising the alarms; algorithms are controlling us, manipulating us, radicalizing us, and preying on our insecurities and "secret desires." All just to sell us overengineered toothbrushes, vegan whey powder, and blow-up paddling pools, among other goodies.

While it's unclear whether algorithms are truly "harming the children"<Footnote idName={1}>And other such hand-wavy claims that fail to clearly define 'algorithms', 'harm', or identify which specific children we should be morally panicked about</Footnote>, there's still a few legitimate concerns in the ways we're allowed to interact with them in modern interfaces.

For a start, we aren't told what kinds of data go into our algorithmic systems, and have no visibility into why certain results come out. Most algorithm-driven interfaces blackbox their internal logic and decision-making rules. Faced with these opaque systems, we end up fetishising the algorithms – we attribute human agency and capacities to them, and in doing so hide the very real human agents designing and maintaining them. We call them "magic" to dismiss the need to make them legible to users.

As an audience we have no visibility into what metrics the engineers are optimising for. The engineers themselves don't always understand how the algorithms choose what to recommend. The lack of transparency makes it difficult to understand why we're shown certain content. It hides the fact some algorithms maximise for qualities like emotional outrage, shock value, and political extremism. We lack the agency to evaluate and change the algorithms serving us content.

<Spacer size="small" />

<h2 className="micro">The Pattern</h2>

When an automated system recommends a piece of content, it should include an [[Epistemic Disclosure]] message explaining **why** it suggested it, and what factors went into that decision.

Transparency tips integrated into user interfaces like “**Recomended because you liked Pride and Prejudice**" or “**Recommended because Mary Douglas read this**” help us see the chain of logic.

Transparency alone isn't enough though. Users should have control over the data that feeds algorithmic systems they're subjected to. We should be able to to remove whole input sources, as well as individual pieces of content.

Pinterest does a good job of telling you why you're seeing certain pins, as well as giving you controls to remove the pin and see fewer like it:

<BasicImage
  width="800px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_800/v1640730625/maggieappleton.com/patterns/algo_6_kai29c.jpg"
  alt="A screenshot of the Pinterest interface saying why a specific pin was recommended"
/>

They also have a "tune your home feed" settings page where you can remove specific pins, boards, or topics:

<ImageFrame
  width="1000px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_1000/v1640730625/maggieappleton.com/patterns/algo_4_pqaggw.jpg"
  alt="A screenshot of the Pinterest setting page where you can tune your home feed"
/>

Despite being a notorious algorithmic bad boy, YouTube also gives you the ability to mark videos in your feed as "not interested"<Footnote idName={1}>Although anecdotally, no matter how many times I say I don't want Jordan Peterson videos, they keep showing up</Footnote> or "don't recommend channel", then follows up asking _why_ you marked it.

<ImageFrame
  width="1100px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1100/v1640730625/maggieappleton.com/patterns/algo_1_r8i1y4.jpg"
  alt="The YouTube homescreen with the options menu expanded on a single video"
/>

<ImageFrame
  width="1100px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1100/v1640730625/maggieappleton.com/patterns/algo_2_tw5bws.jpg"
  alt="The YouTube homescreen after you select 'not interested' with a modal asking why you're not interested"
/>

They also offer a "remove this video" option on your watch history page:

<ImageFrame
  width="1100px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1100/v1640730625/maggieappleton.com/patterns/algo_3_yd68as.jpg"
  alt="The YouTube watch history page with the option to remove a video from it"
/>

Letting users remove single videos/posts/tweets/whathaveyous from their algorithmic soup is the bare minimum for any platform. We're a long way from meaningful transparency that makes internal algorithmic decisions clear and empowers users to design their own feeds.


Algorithms that make their reasoning visible

Algorithmic Transparency


<AssumedAudience>
  Active readers and writers of the web. Particularly ones frustrated by context
  collapse and the proliferation of generic articles that try to accomodate
  every possible audience online
</AssumedAudience>

<Spacer size="small" />

<h2 className="micro">The Context</h2>

Readers are a problem for every writer. Writers have to write for a specific person. That specific person is almost always imaginary. Anytime you put writing in public, posted somewhere a vast range of people might happen upon it, imagining the reader becomes an exercise in desperate speculation.

Who is truly reading this? I haven't a clue.

All I can do it guess. I have to _assume_ things about you. Assumptions I make based off the other people my Twitter neighbourhood and extended gardening network.

This includes how much you know about the history of hypertext. Whether you're caught up on the latest JavaScript framework gossip. How much you can tell me about embodied cognition and its role in interface design. Whether you know who Clifford Geertz, Bret Victor, Ted Nelson, and George Lakoff are.

If I assume incorrectly, I'll lose you in the middle of a sentence – either because I'll assume you know more than you do, and drown you in unfamiliar words and alienating jargon. Or I'll assume too little and bore you with basic, repetitive definitions of things you personally helped invent.

If I don't make clear who I'm writing for, and you don't know who should be reading this, we're far more likely to end up in an unsatisfying reader/writer mismatch.

<Spacer size="small" />

<h2 className="micro">The Pattern</h2>

At the beginning of many of my posts, I have a small informational box that tells you my **assumed audience** – who I think I'm writing this piece for.

A few examples to illustrate the point:

<AssumedAudience>
  JavaScript developers who have some familiarity with data visualisation,
  interactive narratives, and/or scrollytelling articles.
</AssumedAudience>

<AssumedAudience>
  People who understand the basic historical arc of postmodernism,
  post-postmodernism, the rationalist movement, and the post-rationalists. Would
  describe yourself as Very Online.
</AssumedAudience>

<Spacer size="xs" />

These small boxes free both of us of unspoken obligations and expectations. As the writer, I am now free to write for an informed audience without defining every term and qualifying every statement. We can jump straight to the gritty details and contentious debates rather than doing a full literature review of the field.

You still might no have a clue what I'm talking about, but you were forewarned. You have chosen to venture into this article as a bemused voyeur – willing to sacrifice comprehension to feed your curiosity.

The same way you might eavesdrops on a conversation between two Dev Ops engineers vehemently fighting over the practicality of kubernetes. None of us know what they're saying, but the jargon is to die for.

<References>
  <ReferencesLink
    title="Assumed Audience: everyone on the internet"
    href="https://v4.chriskrycho.com/2018/assumed-audiences.html"
    author="Chris Krycho"
  />
</References>


Naming your invisible audiences to free yourself from unspoken obligations

Assumed Audiences


<h2 className="micro">The Context</h2>

Being able to quickly capture a new idea, a loose piece of information, or a vaguely formed thought is a critical feature of any worthwhile personal knowledge management system.<Footnote idName={1}>Also known as a note-taking system, but with a bit more emphasis on creating _personal knowledge_ rather than just creating _notes_</Footnote>

When you need to get an idea down, you want to get into an open text input as fast as possible. Ideally within a single click or keystroke. You don't want to think about what to name the page it will live on, where it fits into your existing information architecture, or what other ideas it should be linked to.

Half the time I begin typing something, I'm not even sure what I'm writing yet. Writing it out is an essential part of thinking it out. Once I've captured it, re-read it, and probably rewritten it, I can then worry about what to label it, what it connects to, and where it should 'live' in my system.

And sometimes (perhaps often), I stare at the written note and I'm _still_ not sure where to put it. It connects to many other bits of information and themes. It doesn't neatly fit into a single labelled folder. I have to think hard about _when_ I want to see this idea again. I have to make it findable for future me.

This organising work takes a non-trivial amount of mental effort, and there are plenty of moments when I can't be bothered. And I am not alone in this.

Sometimes we need to capture ideas and then let them sit for a while. Before we shift to organising and synthesising them. They need to hang out in limbo, uncategorised, in a place we can still find and revisit them. These could be inboxes or scrap piles; the equivalent of post-it notes left scattered around a desk.

This presents a problem for designers of these systems; how do we give people open, free-flowing, and unstructured inputs... that _also_ allow them to consistently rediscover, revisit, and organise their ideas?

<Spacer size="small" />

<h2 className="micro">The Pattern</h2>

The Daily Notes Page (colloquially, the DNP) is one of the most popular solutions to the problem of balancing frictionless input with future discoverability.

Many note-taking and knowledge management apps now have one. The DNP is usually an entry point – you begin there by default when you open the app. Every day, a fresh blank page appears with today's date at the top. And you are free to begin writing in it.

<ImageFrame
  width="1100"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_1800/v1650355782/maggieappleton.com/patterns/dailynotes_1_pgidin.png"
  alt="The daily notes page in Remnote"
  showalt
/>

<ImageFrame
  width="1100"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_1800/v1650355782/maggieappleton.com/patterns/dailynotes_3_mbs19s.png"
  alt="The daily notes page in Roam Research"
  showalt
/>

<ImageFrame
  width="1100"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_1800/v1650355782/maggieappleton.com/patterns/dailynotes_2_gnjo0n.png"
  alt="The 'unsorted' daily notes page in Craft App"
  showalt
/>

If you want to see a previous day's entries, you usually scroll down or use the built-in date picker. It's quick to jump back a few days and see what you've been thinking about.

Each day becomes a reference point. When you encounter a bit of writing in the future, you know exactly when you captured it. You can look at what else you wrote on the days surrounding it. This extra context makes it easier to know what it relates to and where it should eventually live.

You might decide it doesn't need to ‘live’ anywhere at all. It can just stay on the DNP. This absolves you of the need to find a suitable home for every piece of information. As long as you can find it again via search and tags, why go to the trouble of filing everything away?

The DNP doesn't demand any particular rigour, format, or formality. As an unopinionated dumping ground, people seem to find it freeing. Being able to write out strange thoughts, misguided ideas, and half-baked theories without any obligation to immediately resolve them is arguably necessary to arriving at higher quality ideas. There's little risk of cluttering up your database, as tomorrow the page will automatically be swept away into the archives. The passage of time acts as a natural way to clear out old notes; new day, new page.

### Daily Templates

Setting up templates that auto-fill your DNP has become popular in many of the newer knowledge management apps. Users of apps like Obsidian, Roam, and Logseq share [their](https://www.reddit.com/r/ObsidianMD/comments/pjp8d1/daily_note_templates_please_share/) [personal](https://matthewweeks.medium.com/the-daily-notes-template-i-use-in-roam-research-after-1-year-of-daily-use-and-refinement-fa8ffb85849d) [templates](https://nesslabs.com/9-useful-templates-for-roam-research) in [spades](https://www.youtube.com/watch?v=JCIdJBZGQLQ).

These commonly include journaling prompts such as “How are you feeling?”, “What's on your mind?”, or “What's the most important thing you need to work on today?”.
Others have designated areas for task lists, time tracking logs, and capturing ideas.

Rather than simply being static prompts, many of these include dynamic queries and buttons connected to programming scripts. They can fetch unfinished todo items, show you yesterday's journal entires, start and stop timers, or calculate word counts. For more on these type of flows, see [[Programmable Notes]]

<ImageFrame
  width="800px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:best,w_1100/v1652083037/maggieappleton.com/patterns/dailynote_roam_qgr7ej.png"
  alt="An example of a daily note template in Roam Research"
  sourceUrl="https://www.youtube.com/watch?v=5YsbNKkEoJs"
  sourceTitle="Jeffery Webber"
  showalt
/>

These templates work as a kind of [programmable attention](https://notes.andymatuschak.org/zJrfPCbY7GcpV9asEc8NTVzXTAV4TvRFMuY6). You are directed to answer specific questions each morning, log certain kinds of thoughts, record daily activities, or track your habits. Many people find them helpful as a way to structure their working days, and encourage self-reflection and metacognition. This turns the DNP into more of a workflow management tool, rather than a place to capture information.

### Potential Problems and Consequences

The DNP solves a tricky problem, but like all design solutions, comes with costs. The daily cadence of a DNP frames the system as a kind of personal diary. Which we may not necessarily _want_ in a personal knowledge base.

Mixing up your notes on Heidegger's _“The Question Concerning Technology”_ and your reflections on whether your mother is gaslighting you might lead to uncomfortable context collapse. It could easily be distracting when search results turn up both academic claims and uncharitable rants about your significant other. Don't shit where you need to critically think, as the old saying goes.

There's also a good chance the DNP encourages people to spend non-significant amounts of time journaling and writing notes they never look back on. We risk creating large piles of unstructured cruft and free-flowing thoughts that don't amount to larger realisations or meaningful outputs. Or at least, are an inefficient means of getting us there.

It would be hard to measure whether that concern is true in any ‘objective’ sense. But we should fear it nonetheless.

<References>
  <ReferencesLink
    title="A great Twitter thread on DNPs"
    href="https://twitter.com/TfTHacker/status/1494933522242539522?s=20&t=Fn7-OXIsT79Xj1cdIDwFIA"
    author="@TfTHacker"
  />
</References>


Daily notes as a frictionless default input for personal knowledge management systems

Daily Notes Pages


<h2 className="micro">The Context</h2>

For most of the words we read online, we have a limited amount of context about the writer and how much effort they've put into the piece we're reading.

We might have a name and tiny 32px profile image. We don't know how long it took them to write these words, how many hundreds of tabs they read through, or whether they spent years earning a graduate degree on the topic. We rarely have a rich backstory with a comprehensive educational and professional history at hand.

If we disagree with their points, we're more likely to be ungenerous Epistemic Peers who assume the worst: they've barfed this garbage up in a single, frenzied caffeine rush and haven't so much as opened Google Scholar to check for prior art.

That might all be true. Which is fine. As long as they _disclose_ the situation up front. The only true source of dissapointment – in both reading and life – is unmet expectations.

<Spacer size="small" />

<h2 className="micro">The Pattern</h2>

At the beginning of a piece of writing, the author writes a sentence or two about the **epistemic status** of the work. _Epistemology_ is the study of knowledge – how we know things, the methods we use to gain knowledge, and how we validate knowledge as "true.” So an _epistemic status_ usually covers how the author came to know what they know. This includes how much effort they put into researching it, how they validated the information, and how sure they are about their conclusions.

Scott Alexander of [Slate Star Codex](https://slatestarcodex.com/) was one of the earliest well-known bloggers to do this. Many of his posts include statuses that range from "total conjecture” to "pretty good, but I make no claim this is original.” Here's a few more choice examples:

<ImageFrame
  style={{ margin: "0 auto 1rem" }}
  width="900px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1641161435/maggieappleton.com/patterns/epistemic1_w0umsf.png"
  alt="A Scott Alexander post with the epistemic status more crackpottish than usual"
/>

<ImageFrame
  style={{ margin: "0 auto 1rem" }}
  width="900px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1641161787/maggieappleton.com/patterns/epistemic2_syifue.png"
  alt="A Scott Alexander post with the epistemic status very speculative"
/>

<ImageFrame
  style={{ margin: "0 auto 2rem" }}
  width="900px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1641161787/maggieappleton.com/patterns/epistemic3_meynmd.png"
  alt="A Scott Alexander post with the epistemic status very speculative and not necessarily endorsed"
/>

[Gwern](https://www.gwern.net/) is another blogger who adds rich metadata to each post. They have a numerical "certainty" rating on each post:

<ImageFrame
  style={{ marginTop: 0 }}
  width="900px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1641198514/maggieappleton.com/patterns/gwernepistemic_1_jpo0dp.png"
  alt="A Gwern post on spaced repetition with a certainty rating of highly likely"
/>

The rationalist and Effective Altruist communities have been particularly enthusiastic about the pattern. In true Rationalist style, one person write up a comprehensive proposal to [standardize epistemic statuses](https://www.reddit.com/r/LessWrong/comments/eesr4y/a_proposal_for_standardizing_epistemic_status/) on the r/LessWrong subreddit.

<References>
  <ReferencesLink
    title="Epistemic Effort on LessWrong"
    href="https://www.lesswrong.com/posts/oDy27zfRf8uAbJR6M/epistemic-effort"
    author="Raemon"
  />
  <ReferencesLink
    title="Epistemic Statuses are Lazy and that is a Good Thing"
    href="https://devonzuegel.com/post/epistemic-statuses-are-lazy-and-that-is-a-good-thing"
    author="Devon Zuegal"
  />
</References>


Providing clear metadata on the epistemic validity of content

Epistemic Disclosure


<h2 className="micro">The Context</h2>

Most "note-taking” or "knowledge management” software acts as a passive storage container. You create notes, shuffle them around into folders, add a few tags, and then they sit there. Waiting. Until you consciously remember to go looking for them.

This warehouse approach to notes requires us – the human agent in the system – to do a **lot** of cognitive labour if we want to _use_ our notes. And _using_ our notes is the entire point of any note-taking enterprise.

Most of us have an ulterior motive beyond writing notes – we want to remember, understand, synthesise ideas, come to confident conclusions, generate new ideas informed by historical and social events, write coherent essays, or work through difficult problems.

Getting to any of these outcomes requires far more work than typing words into a storage container and retrieving them again. Most note-taking software doesn't guide us towards any particular workflows or ways of thinking with our notes. We have to develop them ourselves.

We have to remember what kind of information we saved in the first place. We have to know what keywords or search methods will allow us to find it again. We have to develop ways to integrate old ideas with new ones. We have to prompt ourselves to expand on our notes, combine them, synthesise them into new realisations, and critique our own conclusions.

Thankfully, there's a long history of people finding ways to make these cognitive tasks easier. We can draw on well-established cultural practices and techniques; we can write [[Evergreen Notes]] and build [Zettelkastens](https://zettelkasten.de/posts/overview/). We can practice [knowledge synthesis](https://oasislab.pubpub.org/pub/54t0y9mk/release/3) and [critical thinking](https://en.wikipedia.org/wiki/Critical_thinking). We can use [spaced repetition](https://notes.andymatuschak.org/z7iCjRziX6V6unNWL81yc2dJicpRw2Cpp9MfQ?stackedNotes=z2gqazXUkf9qyFjMQg4W3dw6yegnAJszvDywN) to regularly resurface old ideas. We can write for an engaged and discerning public audience. We can even sign up for expensive masters degrees that will force us to ask hard questions and conjure up defensible answers.

These practices are what turn notes into understandings, conclusions, informed opinions, new ideas, and original creations. But we've yet to see note-taking software that **actively facilitates and encourages** these workflows. They are, for the most part, still behaving like storage boxes.

What if we started to think about note-taking systems as active agents, rather than receptacles?

Agents can prompt you to do specific activities in a sequence. They can ask you questions. They can suggest relevant material based on what you've already written. They can periodically resurface old ideas to ask if they still ring true. They can prompt you to connect two disparate ideas together. They can mimic conversational partners who debate the strengths and weaknesses of a point – naive partners perhaps, but still better than no partner at all.

"Agents” here are simply programmes<Footnote idName={1}>Or "algorithms" if you're trying to convince someone this programme is more complex than a list of instructions. It's not. But it does sound better.</Footnote>; pre-written sequences of instructions that facilitate standardised cultural practices and repeatable ways of relating to the world.

We could, in essence, run automated programmes and algorithms over our notes. Programmes that we have the agency to write as users.

<Spacer size="small" />

<h2 className="micro">The Pattern</h2>

Programmable notes are note-taking systems that allow you to write programmatic rules that facilitate particular ways of working with your notes.

Based on triggers (specific conditions are met, input from the user, time of day), they kick off a sequence of actions. Actions might be prompts for the user to answer, transformations on the notes themselves, or requests to external websites and data sources for information.

We're floating into the land of computational abstraction so let's make this tangible with some examples:

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I open my note-taking app first thing in the morning</NoteTrigger><NoteAction>ask what I'm currently thinking about. Once I've marked this complete, show me what I said yesterday, three days ago, and last week.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I create a note related to a specific book</NoteTrigger><NoteAction> pull in the author, cover, and publication date from the Google Books API.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>a week has passed since I've written notes on a book</NoteTrigger><NoteAction>ask me everything I remember about it off the top of my head. Put this into the summary section of my notes as a first draft.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>a month has passed since I last touched a note marked as an essay draft</NoteTrigger><NoteAction>gently prompt me to read through it again and write down why I'm stuck.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I state a claim</NoteTrigger><NoteAction>ask what evidence I have to back it up and what other notes, books, or academic articles I want to mark as sources for this claim.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-xs)">

When <NoteTrigger>I mark an essay draft as complete</NoteTrigger><NoteAction>ask me all the questions my favourite writing professor would ask.</NoteAction>

- Do you actually have a point and have you made it?
- Does your introduction present a compelling problem?
- Are you assuming the audience is thicker than a brick?
- Is this littered with passive voice (to be, is, was, were...) and evasive language?

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I write a note that shares many of the same keywords and phrases as an existing note</NoteTrigger><NoteAction>show them to me side by side and ask if I want to combine them.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I mark a note as [[Evergreen]]</NoteTrigger><NoteAction>ask me what other Evergreen notes I want to link it to, and offer suggestions based on ones with similar keywords, tags, and references.</NoteAction>

</SimpleCard>

<SimpleCard alignLeft padding="var(--space-s) var(--space-l) var(--space-m)">

When <NoteTrigger>I say I'm stuck for new ideas</NoteTrigger><NoteAction>select a few random notes from my database and ask me to expand upon them using prompts from generative frameworks like [SCAMPER](https://en.wikipedia.org/wiki/SCAMPER) or [oblique strategies](https://en.wikipedia.org/wiki/Oblique_Strategies).</NoteAction>

</SimpleCard>

I could go on, but I'll spare you from my other 99 mediocre programmatic note ideas. It's hopefully clear that the goal of these is to encourage practices like reflection, synthesis, connection, and serendipity. The goal is not to simply amass notes.

None of the automations I've suggested above are impractically complex or technologically impossible. They all follow a reasonably simple _if this, then that_ structure that most of us will find familiar. Many are perfectly possible and currently used in existing platforms.

The [Smartblocks](https://roamjs.com/extensions/roam42/smartblocks) plug-in for [Roam Research](https://roamresearch.com/) is the system I personally use to build these types of workflows. It offers a set of triggers, variables, and commands you can chain together into fairly readable statements like: `<%SET:topOfMindToday,<%INPUT:What's on your mind today?%>%>` or `<%RANDOMBLOCKFROM:Writing Ideas%>`.

Even with limited programming knowledge, many people in the community have been able to fashion their own Smartblock flows. Plenty of them have [published](https://github.com/dvargas92495/SmartBlocks/issues?q=is%3Aopen+is%3Aissue+label%3ASmartBlock) their workflows to the community Github for others to use. These include [sentiment analysis](https://github.com/dvargas92495/SmartBlocks/issues/171) over a selection of text, pulling data [from wikipedia](https://github.com/dvargas92495/SmartBlocks/issues/42) into your notes, and a [decision making](https://github.com/dvargas92495/SmartBlocks/issues/88) flow walking you through the benefits, risks, and costs of all your options.

The UX of both Smartblocks and Roam is still pretty rough. But they're pointing towards something promising. They're also not alone in enabling users to write their own programmable notes. There are a wide range of user-created plug-ins for similar platforms like [Obsidian](https://obsidian.md/plugins) and [Logseq](https://logseqweekly.com/plugins/) that enable some of these same workflows.

[Coda](https://coda.io/) is another app that allows users to build fairly complex programmatic systems within documents. You can create buttons that trigger actions and write automation scripts with conditional logic.

<ImageFrame
  width="1200"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1647715244/maggieappleton.com/patterns/coda-2_wtvyeo.jpg"
  alt="The Coda interface with customisable buttons and an open sidebar for creating automation rules"
/>

Another project I'm watching closely is [Gordon Brander](https://gordonbrander.com/)'s app [Subconscious](https://subconscious.substack.com/p/launching-subconscious-alpha-1?s=r) (currently in alpha) that promises to feature _"geists"_ – "little scripts that find connections between notes, and use procedural generators to construct algorithmic provocations.” <Footnote idName={2}>From Gordon's Subconscious newsletter: [SCAMPER and procedural idea generation](https://subconscious.substack.com/p/scamper?s=r)</Footnote>

These trends all bode well for programmable notes. They prove that – given enough agency – users will enthusiastically write their own programmes that facilitate the particular note-taking practices and techniques they find valuable.

This is [end-user programming](https://www.inkandswitch.com/end-user-programming/) in action. The developers and designers of note-taking apps will never be able to create systems that suit the needs of everyone's particular knowledge management workflows. Enabling users to design and share their own is the only way to give people agency over their knowledge bases.

#### But what about AI???

It is impossible to propose agentive computational systems designed to help us think better without bringing up **THE AI**. Let's first point out the term "AI” is a nebulous and finicky cultural narrative. People use it in all sorts of ways depending on the political agenda of the speaker.

In this context, I'm using _AI_ to refer to systems that use natural language processing, neural networks, and machine learning to respond to people in seemingly 'intelligent' ways. These will play an enourmous role in the future of programmable notes.

We've yet to see note-taking platforms meaningfully add _AI_ affordances into their systems, but there are hints at how they could in other platforms.

The most impressive and promising I've seen is [Elicit](https://elicit.org/), a research tool that helps academics and students find relevant papers and data based on natural language inputs. You can ask it a question like "What's the point of note-taking?” and receive a list of research papers that are likely to hold the answer. Even better, Elicit creates a one sentence summary of the paper's main finding and presents it in the results.

<ImageFrame
  width="1200"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1647728451/maggieappleton.com/patterns/elicit3_1_whsaop.png"
  alt="Elicit search results showing summaries and titles of relevant papers"
  showalt
/>

Finding relevant research papers is critical for academics and researchers but isn't a large part of everyone's writing and sense-making process. <Footnote idName={3}>Although tools like Elicit will hopefully play a role in making academic research less intimidating and more accessible to everyday knowledge workers. You don't need a degree to do a quick literative review when you're trying to solve a well-defined problem.</Footnote>

Elicit has an alternative suite of tools that I find much more intriguing for our use case. Using the same NLP technology you can run requests like:

- Clarify a concept
- Suggest similar search terms
- Brainstorm possible counterarguments
- Rephrase a sentence
- Help me be more specific.

<ImageFrame
  margin="var(--space-s) auto var(--space-s)"
  width="1200"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1647850074/maggieappleton.com/patterns/elicit4_g1q0zz.png"
  alt="Elicit suggesting possible counterarguments to a provided claim"
/>

<ImageFrame
  width="1200"
  margin="0 auto var(--space-xl)"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1647726850/maggieappleton.com/patterns/elicit1_1_lcwpel.png"
  alt="Elicit suggesting ways to rephrase a sentence"
/>

These simple linguistic transformations and generative prompts don't require a high level of intellectual sophistication to be useful. Sometimes you just need a wall to bounce ideas off. And modern NLP systems are a great wall. They can give us just a touch of reflection, perspective, and serendipity when we get stuck in our own heads.

To address the slippery-slope argument, I think it's pointless to worry about these systems doing too much of our thinking for us. Rephrasing a sentence is a far cry from writing an informed and insightful social criticism essay.

They certainly might prompt us to think in novel and unfamiliar ways though. [Augmenting human cognition](https://www.dougengelbart.org/content/view/138/) is still the end goal here. Let's hope we see more of it.

<References>
  <ReferencesLink
    title="True Algorithms of Thought Have Arrived"
    href="https://www.cortexfutura.com/algorithms-of-thought-have-arrived/"
    author="Cortex Futura"
  />
  <ReferencesLink
    title="Spaced repetition systems to program attention"
    href="https://notes.andymatuschak.org/Spaced_repetition_systems_can_be_used_to_program_attention"
    author="Andy Matuschak"
  />
</References>


Agent-based note-taking systems that can prompt and facilitate custom workflows

Programmable Notes


<h2 className="micro">The Context</h2>

Our web browsing experience hasn't changed much over the last three decades.

Here's Mosaic, the first browser that made the web popular outside niche academic circles. Built in 1993, its _"killer feature"_ was inline images.<Footnote idName={1}>As opposed to images you had to download and open in a separate window</Footnote>

<ImageFrame
  width="900px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_900/v1642358019/maggieappleton.com/patterns/moasic_fxat9i.png"
  alt="The Mosaic web browser interface in 1993"
/>

And here's Chrome, currently the most widely used browser, 29 years later:

<ImageFrame
  width="1100px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1100/v1642358018/maggieappleton.com/patterns/chrome_wbjk5d.png"
  alt="The Chrome browser interface from 2019"
/>

On the surface, not much has changed. The layouts, icons, and button arrangement haven't moved. Address bar at the top. Arrow icons to move between pages. Access to the same basic controls; print, refresh, save, and search.

Modern Chrome certainly gained the veneer of minimalist modern design; we've reduced the interface to a low-contrast sea of whitespace. It's also vastly more powerful; 1993 Mosaic certainly couldn't load 20 tabs running WebGL animations.

But from a user's perspective, the core browsing experience isn't different. Enter URL, load the page, click on links, move forwards and backwards in browser history. We can only see one website at a time, or max two if we stack our browser windows in columns.

Chrome and Mosaic are not uniquely similar. All the major characters in this browser drama – Firefox, Safari, Opera, and Internet Explorer/Edge – feel like they're wearing the same outfit.

This historical consistency is impressive. Perhaps it means we nailed this interface pattern on the first try. Or perhaps it means building browsers is an enourmously complex challenge, and the only companies with enough engineering resources to dedicate towards it aren't interested in mucking about. They're too busy keeping up with W3C web standards and negotiating cross-compatability concerns, leaving little room for experimental interface patterns.

This isn't for lack of want though. There have been plenty of calls to _"reinvent"_ the browser. Places like [The Browser Company](https://thebrowser.company/) make a lot of noise about it (but we've yet to see a product demo). Foundations like Mozilla have funded extensive [experimental explorations](http://patrykadas.com/browser.html) of alternative browsers.

There's a steady stream of ideas and speculative sketches floating around Twitter that prompt us to reconsider our browsery assumptions and ask good design questions:

<TweetEmbed tweetId="1418749070336684034" />

<TweetEmbed tweetId="1450479522609090562" />

<TweetEmbed tweetId="1256317316452810755" />

The dreams in some of these speculative suggestions are starting to materialise.

<Spacer />

<h2 className="micro">The Pattern</h2>

There are some new apps appearing that offer alternative ways of browsing the web, but sidestep the problem of needing to build an entire browser.

Through the use of `<iframe>` embeds (or sometimes darker magic like live-updating screenshots in `<img>` tags), these apps are creating a form of web inception; allowing us to embed tiny browser windows inside a larger canvas. <Footnote idName={2}>This is a tricky as many websites deny access if they're embedded inside other webpages. This isn't out of malice; they're trying to protect themselves from cross-site scripting attacks</Footnote>

This canvas-based approach adds _spatial_ dimension to the web browsing experience; they allow us to arrange browser windows above, below, to the left, and right of other browser windows.

The same way we're able to put an open book next to a piece of paper and below a row of sticky notes in meatspace. Arranging objects in space to create groupings, indicate relationships, and build hierarchies is one of those classical human skills that never goes out of style.

#### Spatial Browsing Apps

1. [Kosmik](https://lithium.paris/) is a canvas-based note-taking app for iOS and Mac app that includes frames for web browsing. It's still in early development, but as a native app it doesn't seem to have the same cross-site blocking issues as web apps.

<ImageFrame
  width="1200px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1642582738/maggieappleton.com/patterns/kosmik_rm0rpy.jpg"
  alt="A Kosmik canvas with three open browsers arranged next to one another"
/>

2. [Nette](https://www.nette.io/) is a browsing app designed for researchers that allows you to open multiple browser windows, draw physical connections between frames, pull out key concepts, and write markdown notes directly into your canvas. <Footnote idName={3}>Still pre-release but looking promising</Footnote>

<ImageFrame
  width="1200px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1642543667/maggieappleton.com/patterns/nette_kjqsgj.jpg"
  alt="A Nette canvas with open browsers, diagrams, and notes arranged next to one another"
/>

3. [Sprout](https://sprout.place/) is designed with social interaction in mind – an open, multiplayer canvas where you can video/voice chat, write notes, and browse webpages together. It cleverly sidesteps the issue of cross-site blocking by using screenshots in `<img>` tags instead of true `<iframe>` elements.

<ImageFrame
  width="1200px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1642543667/maggieappleton.com/patterns/sprout_ffcyrn.jpg"
  alt="A Sprout canvas with two open browsers arranged next to one another"
/>

4. [Natto.dev](https://natto.dev/) isn't designed to be a browsing or knowledge management app, but inadvertently implements this pattern. It's a spatial canvas for programming that happens to allow HTML elements, such as `<iframe>`:

<ImageFrame
  width="1200px"
  src="https://res.cloudinary.com/dxj9qr5gj/image/upload/c_scale,f_auto,q_auto:good,w_1200/v1642543667/maggieappleton.com/patterns/natto_cfqkov.jpg"
  alt="A Natto canvas with three open browsers arranged next to one another"
/>

All of these examples allow you to add different blocks and elements to your canvas other than simply browsers. This turns the interface into a true research space. You can add notes, images, and links connected to these browsers – pulling out information in order to arrange it in ways that make sense to you.

At least... in theory. The above platforms are promising, but they're all at beta/alpha stage for the moment. They're worth playing with, but not stable enough to build up an extensive database of notes and browser trails in.

We're so close though. Here's to hoping we have widely useable spatial browsing tools within the next year or two.

#### Postscript

I should touch on the impulse to bring in even more dimensions here. When you search for "_spatial web browsing_,” you'll find there are whole engineering teams trying to stick web browsers on [walls within 3D AR/VR](https://venturebeat.com/2021/05/13/spatial-unveils-web-browser-collaboration-in-3d-workspace-and-nft-virtual-galleries/) environments. To me this feels like putting the cart before the poorly rendered, nausea-inducing horse, given we haven't built tools to properly browse the web in 2D space yet.

<References>
  <ReferencesLink
    title="Browser.html speculative research"
    href="http://patrykadas.com/browser.html"
    author="Patryk Adas"
  />
  <ReferencesLink
    title="Spatial Interfaces"
    href="https://darkblueheaven.com/spatialinterfaces/"
    author="John Palmer"
  />
  <ReferencesLink
    title="Spatial Software"
    href="https://darkblueheaven.com/spatialsoftware"
    author="John Palmer"
  />
</References>


Adding spatial affordances to the experience of browsing the web

Pattern Catalogue

A catalogue of design patterns gathered from my own observations and research.

Algorithmic Transparency

Assumed Audiences

Daily Notes Pages

Epistemic Disclosure

Programmable Notes

Spatial Web Browsing