How I Reduced Friction in My Studies Using AI, Rust, and Obsidian.

Source: Dev.to

The Problem: Documentation Friction

Every student knows that note‑taking is fundamental for retention, but the act of formatting notes often consumes more energy than the learning itself. I found myself stuck in a cycle where research flowed smoothly, yet documentation in Obsidian became a manual bottleneck.

When I had ten topics to study, the workflow “Copy from Chat → Open Obsidian → Create File → Paste” was still too slow, and I ended up abandoning the notes halfway through.

The Idea: Automate Note‑Taking

I decided to create an application that generates a complete Markdown note from just the name of a subject. The result is noteap, a three‑layer system that eliminates the manual steps.

Architecture Overview

Interface (React Native)

A minimal app where the user enters a topic. No distractions, just a single input field and a submit button.

Brain (Node.js + Gemini AI)

// Example: server endpoint handling a topic request
app.post('/generate', async (req, res) => {
  const { topic } = req.body;
  const prompt = `Create a detailed Markdown note about ${topic}, including code examples and sections.`;
  const markdown = await gemini.generate(prompt);
  const id = await db.notes.insert({ topic, markdown, status: 'pending' });
  res.json({ id });
});

• Uses Gemini AI to produce a well‑structured Markdown document.
• Saves the result in MongoDB with a pending status.

Synchronizer (Rust)

use std::fs;
use reqwest::blocking::Client;
use serde::Deserialize;

#[derive(Deserialize)]
struct Note {
    id: String,
    markdown: String,
}

fn main() {
    let client = Client::new();
    let resp = client.get("https://my-noteap-server.com/pending")
        .send()
        .unwrap()
        .json::>()
        .unwrap();

    for note in resp {
        let path = format!("/path/to/Obsidian/New Notes/{}.md", note.id);
        fs::write(path, note.markdown).expect("Failed to write note");
        // Optionally mark as processed on the server
    }
}

• Runs as a single binary that starts with the system.
• Retrieves pending notes, writes them directly into Obsidian’s folder, and ensures they are ready when the computer is opened.

Deployment

The Node.js server runs inside a Docker container on an AWS EC2 instance, providing a stable URL for the mobile app and the Rust client to communicate with.

Research Background

According to Annie Piolat et al. in “Cognitive effort during note taking” (Applied Cognitive Psychology, 2005), note‑taking is one of the most demanding mental tasks, consuming significant cognitive effort. The formatting and organization steps often create what I call documentation friction, draining energy that could be spent on learning.

“Note‑taking is a highly effortful activity; the act of formatting notes can consume more mental resources than the learning itself.” – Piolat, A., Olive, T., & Kellogg, R. T. (2005)

Benefits of Automation

• Energy preservation: By removing the formatting step, mental resources are saved for active review and application.
• Time savings: No more manual copy‑paste; notes appear automatically in Obsidian.
• Consistency: Every generated note follows the same structure, making it easier to navigate and study.

Conclusion & Call to Action

Automating the note‑taking workflow has given me back the time and mental energy that were previously lost to “documentation friction.” Instead of spending effort on bureaucracy, I can focus on review and practical application.

How do you manage your time and notes? Have you tried automating any part of your workflow?

Reference

PIOLAT, A.; OLIVE, T.; KELLOGG, R. T. Cognitive effort during note taking. Applied Cognitive Psychology, 2005.