In the age of information overload, we all yearn for efficient ways to capture, review, and make sense of what we read. The Reading Knowledge Capture (RKC) system, a branch of personal knowledge management (PKM), is here to streamline this process. This guide will walk you through RKC’s clever structure, combining science with practicality, to help you retain and revisit valuable knowledge. Expect insights, a touch of wit, and a system that adapts to your unique style of learning.

The Problem with Traditional Highlight Systems

Most of us rely on Kindle or other reading platforms that capture highlights and notes. But here’s the issue: these systems often keep your insights locked within proprietary platforms, limiting where and how you can access them. Previous RKC versions automated highlight capture but required a Kindle, a computer, and a click to initiate the process. The current iteration removes these restrictions and introduces a more universal, flexible approach, accessible from virtually any reading device.

Enter the New RKC: Capture, Review, and Showcase

With this new version, the RKC process is divided into three main stages: Capture, Review, and Consume. Let’s dive into each stage.

Stage 1: Capture

The capture stage is all about simplicity and speed. Here’s how it works:

1. Read Anywhere, Note Instantly: Whether on a Kindle, a web browser, or a mobile app, if you find something noteworthy, select the text, copy it, swipe down to the control center, and tap a shortcut button.
2. Drafts Integration: The captured text goes straight to Drafts, an app where it can be tagged, organized, and filed for later review.

With this setup, every meaningful quote or passage is only a swipe and tap away from being stored in your knowledge bank. No need to open additional apps or worry about compatibility with different reading devices.

*It is worth noting that copy pasting books has a limit of (usually) 10% of the book. This is a publishing thing. So bear that in mind when copy pasting too many highlights.

Implementation Details

Shortcut

Clipboard Capture

• Get content of screen (This only helpful for websites)
• Get Content of clipboard
• Text with the content of the clipboard and the content of screen
• Create new draft with text
  

Hook this up on control center, every time you need to keep something, select, copy, swipe down, and run this shortcut.

Stage 2: Review

The review stage is where you transform raw snippets into lasting knowledge.

1. Book Notebook: When starting a new book or line of research, create a notebook per book or topic. That’s ideal but you do you, the point of this is to have a landing area.
2. Review and Reflect: Open Drafts, read through your saved clips, and reflect. Add comments, contextual thoughts, or even counterpoints to deepen your understanding.
3. Organize by Book: Once satisfied, you simply select the “Add to Book” action. The script will append the draft’s contents to a designated “book” note, creating a cohesive record of highlights, reflections, and insights for each book.

At this stage, the content is tailored and categorized, moving from raw highlight to a refined summary. Once a book note is complete, it’s ready for final storage in Obsidian.

Implementation Details

Draft Actions

New Book

• Run Script

let p = Prompt.create();
p.addTextField("textFieldBook", "Book", "");
p.addTextField("textFieldAuthor", "Authors", "");
p.addButton("Done");
let didSelect = p.show();
let author = p.fieldValues["textFieldAuthor"];
let book = p.fieldValues["textFieldBook"];
if (p.buttonPressed == "Done") {
    draft.setTemplateTag("book_title", book)
    draft.setTemplateTag("author_names", author)
}

• Create Draft

Template:

# [[book_title]]
->authors: [[author_names]]
->started: [[time]]
->tags: 
## Highlights

This will create a new draft with that template (custom for me). It also adds some custom tags im using to classify within my workspaces. Up to you.

Add To Book

• Run Script

function toISOLocal(d) {
  var z  = n =>  ('0' + n).slice(-2);
  var zz = n => ('00' + n).slice(-3);
  var off = d.getTimezoneOffset();
  var sign = off > 0? '-' : '+';
  off = Math.abs(off);
  return d.getFullYear() + '-'
         + z(d.getMonth()+1) + '-' +
         z(d.getDate()) + 'T' +
         z(d.getHours()) + ':'  + 
         z(d.getMinutes()) + ':' +
         z(d.getSeconds()) + '.' +
         zz(d.getMilliseconds()) +
         sign + z(off/60|0) + ':' + z(off%60); 
}
let f = () => {
    // select an existing draft
    let d = app.selectDraft(Workspace.find("Books"));
    if (!d) {
        return false;
    }
    // append current draft
    let datee = draft.createdAt;
    d.content = d.content + "\n---\n**"+ toISOLocal(datee) + "**\n" + draft.content + "\n";
    d.update();
    return true;    
}
if (!f()) {
    context.cancel();
}

This will show a list of Drafts in the ‘Books’ workspace. (where I have my books). After selecting a draft from that list. it will append the content of the current draft to it and archive it.

Send Book

This is an action that runs a shortcut that saves the whole draft in the obsidian folder designated for books.

Stage 3: Consume

Here’s where the magic happens: making these insights constantly visible and accessible.

1. The “Smart Reads” Shortcut: This shortcut scans your Obsidian library for book notes, randomly selects one, and pulls a random highlight. The chosen highlight then replaces the content of a dedicated “Quote” draft in Drafts.
2. Widget Display: Using Drafts’ widget functionality, the “Quote” draft is displayed on your home screen. Each time the shortcut runs, a new quote appears, offering you a bite-sized reminder of your readings.

This setup creates a rotating feed of knowledge on your home screen, which you can configure to update automatically or manually.

Diagram Placeholder: [Widget Flow – Diagram showing the random selection and widget update process]

Note: Depending on widget update timing, there may be occasional lag in displaying the latest quote. However, the key here is consistency: regular exposure to captured insights helps solidify them in your memory.

Implementation Details

Shortcut

Smart Reads

• Get content of folder containing books.
• Get random number between 1 and the count of books in the folder.
• Get the book indexed at the random number
• Split the content of that file by — (Or whichever separator)
• Get a random number between 1 and the count of items after the split.
• From the Split content, get the item indexed at the random number.
• Get draft and update its content to whatever text from the previous step.
• Add to whichever frontend you want

_{This one is a bit convoluted and may vary depending on your implementation}

RKC’s Capture-Review-Consume cycle offers an efficient, scientific approach to knowledge retention. With the clever use of iOS shortcuts, Drafts, and Obsidian, this system is adaptable, allowing you to scale or modify it based on your needs. The result is a simple yet powerful way to enrich your learning, keeping valuable insights accessible, organized, and ever-present.

This system could revolutionize your approach to reading and knowledge capture. Give it a try—and never let valuable knowledge fade into obscurity again.

To mitigate this, we need a few things:

• An inventory of what sensor uses what battery
• Active monitoring
• Quick response

Inventory

This can take many forms. It can be a Word document, a piece of paper with handwritten notes, or a Lovelace markdown card(s). The important thing is to have this information readily available; it will make the whole process a lot faster. List all the different sensors in the house and what kind of battery each one uses. You can get as fancy as you like by using images and other details, but just having a menu of what battery you need for each sensor beforehand makes a big difference. You can also include details about your battery stock in case you choose to buy a bunch and have them available whenever needed. Highly recommended maneuver.

Active Monitoring

Home Assistant has many cards and ways to visualize battery levels, some even with color. Just having this isn’t enough unless you’re constantly checking, which is not ideal. What’s ideal is to have a notification system in place. This system will allow you to set a threshold to send a notification when the battery level of any sensor drops below it. Between 5% and 10% seems to be the sweet spot; higher allows procrastination, and lower might not give enough time to replace the battery.

Quick Response Plan

This is about having a stock of batteries and acting fast as soon as the notification pops up. When the notification appears, it’s a matter of time before the sensor stops working. Having to go to the store to get more batteries adds to the delay. It might not be a problem, but it’s worth considering because ‘not having batteries available and forgetting to get them when going to the store’ is the leading cause of broken automations.

Links

https://github.com/cbulock/lovelace-battery-entity

https://github.com/maxwroc/battery-state-card

https://community.home-assistant.io/t/low-battery-notifications-actions/653754

This covers data that can be encoded into text, there’s another one of these for photos.

Everything starts on Drafts, because it’s the best and the fastest tap-to-text around. It usually goes in by typing, sometimes from the clipboard and rarely via dictation. For the most part the input is on the go while doing or trying to focus on something else with makes it tricky.

Once the text is Drafts, there’s a range of options. It can be sent to Reminders as a single reminder or as a ‘project’ with sub-tasks. You can add events through Fantastical, send notes, or interact with Obsidian, which is where text goes to rest.

It may seem like there are only three options, and for the most part, yes, any text is either a reminder that goes on the calendar, an actionable that goes as a task, or notes for ongoing projects. However, there’s a lot of gray area in the last bit, and it’s a constant battle between learning behaviors and habits to develop a better pipeline and organizational scheme and the desire to keep evolving and improving my habits and behaviors.

Calendar

Anything with a date goes in the calendar. After writing in Drafts, there’s an action that sends the same text to Fantastical, which is like a magician understanding that kind of speech.

Actionables / Tasks

Anything that ‘has to be done’ goes to the Reminders app. There are two main shortcuts for this, ‘Add Reminder’ and ‘Add Reminder Project’.

‘Add Reminder’ will create a reminder with the text from the draft and will show a list of tags to select from. Alternatively, it can pick them up from the draft itself, splitting the draft with a pipe like ‘|tag,tag,tag’.

‘Add Reminder Project’ is similar; however, this will also add as a sub-task anything below starting with a dash (-).

Musings

Musings are meant for anything that comes out of my brain—ideas, thoughts, etc. This may stay as a draft for a while with constant updates. Once it loses its importance, it goes to Obsidian as a general note. The action will pop up a list of tags to assign to this note.

Projects

Projects are for structured initiatives, whatever they may be. It starts with a project note, like a homepage of sorts, ideally containing some descriptions and intentions. This action will create a note in the Projects directory of Obsidian.

Any text or content supporting a project goes to ‘To Project’. This action will ask for a Project Note (showing all the notes in the Projects directory). Upon selecting a project, it will add a note to that project note with the date and a link to the new note, which is stored in the Projects/notes folder.

Book Notes

Book Notes are notes regarding books I read. A plugin in Obsidian fetches my book highlights from Kindle and creates a note for each book. Here, I can link the notes I write with the highlights from Kindle, making referencing any book highlight, note, or idea I had while reading it pretty easy.

Journal

Every morning, I attempt to write 1200 words. Studies show some benefits to writing every day, so there’s a little ecosystem of things to enhance the experience, like pre-filling templates, extracting tasks to reminders, or keeping track of various things.

These are a few of the protocols which will be broken down and elaborated on as we go.

While storing a copy of the data doesn’t directly address the storage problem, it shifts it to the hard drive, which is more manageable. Moreover, this approach offers numerous advantages. For instance, storing the data in a CSV file enables various analyses, such as calculating the duration it took for each reminder to be completed and conducting other statistical assessments.

The frequency of triggering this process is flexible, depending on individual preferences. It can be initiated manually or set to run automatically at regular intervals. Personally, I find a monthly schedule to be reasonable, but longer intervals can also suffice. The determining factor is the time it takes to execute the process.

This shortcut streamlines the process of accessing sports information, making it quicker and more convenient. Upon activation, it presents a list of sports that I’m interested in. With just a tap on any sport, it instantly opens a quick-view browser, set to Google’s search results for the corresponding league. This comprehensive search results page provides everything I need, from upcoming matches and scores to league tables and team lineups.

The beauty of this shortcut lies in its simplicity and efficiency. Once I’ve obtained the desired information, I can easily dismiss the browser window with a simple tap on ‘done.’ This ensures that no tabs or orphan windows clutter my browser, making it perfect for quick lookups on the go.

During its initial implementation, a status light adorned every room in my home. However, with the passage of time, I observed a natural consolidation and refinement of the status light setup. While several applications cater to similar purposes, I encountered challenges with using light flicks for message transmission, primarily due to issues with consistency and reliability stemming from timing inaccuracies. Consequently, I opted to optimize the system by harnessing colors for communication. Initially, I rationalized the number of status lights, reducing them to a single unit strategically positioned in the living room–a decision driven by the recognition of the practicality of having a centralized hub. Acknowledging the primary functions of our bedrooms–sleeping and occasional activities–I deemed the installation of individual status lights unnecessary. Moreover, given the necessity for connected lightbulbs and the prevalence of LED ceiling lamps, minimizing outlet usage emerged as a priority. Thus, leveraging colors as a messaging tool afforded us a versatile array of options.

A comprehensive array of color-coded notifications was established to effectively convey various household statuses:

• Green: Indicates the activation of the alarm system.
• Flickering Red: Signals a potential break-in, triggered by a window or door being opened while the alarm is active.
• Dim Orange: Signifies the activation of sleeping lights, programmed to operate automatically from 11 pm to 7 am.
• Purple: Indicates that the laundry room door has remained closed for 1.5 hours, typically corresponding to the duration of a washing cycle.
• Flickering Orange: Signals a detected leak, with leak detectors installed under sinks, faucets, and in the laundry room.
• Flickering Yellow: Indicates the ringing of the doorbell.

As new scenarios arise, the list of status indications continues to expand, prompting efforts to streamline the updating process for improved efficiency.

A more pragmatic approach positions cloud services as a ‘glue’ for seamless integration across devices, not as the primary storage solution. Prioritize cloud use for bandwidth, ensuring data availability, while securely storing and backing up files within your control, avoiding recurring costs unless necessary.

Cloud subscriptions excel in providing online accessibility, device synchronization, and sharing capabilities. However, striking a balance between cloud convenience and the security of self-controlled storage is key. Recognizing that cloud services are supplementary, not the sole solution, is crucial for a sustainable and cost-effective strategy in managing digital assets. In essence, use cloud subscriptions to enhance connectivity, but prioritize self-controlled storage for the permanence and security of your files. It’s a delicate balance that defines a robust strategy in navigating the intricate landscape of cloud subscriptions.

This notification setup is in constant development and each iteration addresses a previous issue or improvement.

TLDR; We can use a switch to control the delivery of home assistant notifications to individual devices.

This setup allows for a multiple devices. Each device requires the creation of a virtual switch (input_boolean) that can be toggled from a dashboard widget, companion app action or iOS Shortcut.

There are 2 HA scripts, ‘regular_notification’ and ‘send_critical_notification’.

send_critical_notifications takes as arguments ‘title’ and ‘message’ and passes them along to ‘regular_notification’ script along the ‘critical’ and ‘volume’ parameters. Critical notifications are for Things that demand attention: Alarms, leaks, etc…

regular_notifications checks if the virtual switch for a device is on and it sends the notification defaulting to 0 if values are missing, does nothing if its off. This needs to be repeated for each device.

Triggers.
If an automation needs to send a notification, just calls the ‘regular_notification’ script with data parameters ‘title’ and ‘message’. if the device switch is on it will get the notifications.

It works in two levels, regular and critical notifications.

There’s 2 types of storage, hot storage and cold storage. Hot storage is the storage that has traffic. Party supplies, for example, or a pasta maker that may be used once every 3, 4 months. Cold storage is the stuff that nobody expects to use anytime soon.

For hot storage you want to use clear bins, so you can right away see what’s inside. For cold storage doesn’t matter as much, there’s a benefit on having only clear bins, but if that’s not the case, or even so, this might help.

TLDR; Each ‘storage container’ gets a document (photo/text), something that can be deep-linked. Make a QR of that link and stick it on a box. Months later just scan the QR code and see what’s inside.

There are different ways to implement this, each with different advantages and disadvantages. Grasping the concept should be enough to figure out a custom implementation for your needs.

Apple Notes: Its a process to get the url to deep link a note. So much so that’s not worth trying.

Obsidian: This is the easiest, get the url to a note, QR and you should be able to get to that note by scanning the code. With the note up should be super easy to see the content via a list or a photo, as well as updating the photo or list of content.
** The inconvenience is that’s difficult to share with the family members**

Doku Wiki: This is a bit convoluted to setup, and requires some skill and infrastructure, but is far the most useful, has editing tools, user access. This is running a wikipedia on the local network, so anybody with access to the network should be able to go to the link and edit and see what’s inside.

Depending on the implementation it could also be possible to search for things and get the location of where its stored, instead of the other way around.

The home intercom / PA is a great and easy things for the modern house. Can be as intricate as your budget allows. There are many many ways to do this, and this is one of them.

This system works using the homekit intercom action in shortcuts, does not work on mac, this needs to be triggered from a phone.

Usecases:

• Letting everybody know Dinner is ready
• Text message alert
• Informing the kids when its time to go to bed.

Ingredients

• homepod
• Ios phones
• shortcut
• Datajar

The heart of these is a shortcut that will push the action to read text outloud to a desired homepod. For convenience we use data jar to hold a list of standard messages. “Almost Home”, “Dinner Ready”, “Its Bedtime”, “Text Message”, and a “Custom”. On the shortcut we ask which we want. If its custom we then show a text capture field for custom input. Once the message is set, we ask to which homepod broadcast this message, can be single or different combinations of rooms. Once that is set, the shortcut action will sent the text to be read by the given homepods.