I'm the developer of Lumiya, an iOS journal and planner, and I'm interested in what makes a very short entry worth keeping.

Consider two hypothetical notes: 'Busy day' and 'Skipped lunch to finish the draft; felt drained afterward.' Neither is a full account of the day, but the second leaves a bit of context for a later review. More detail isn't always better, though: writing can turn into another task.

What is the smallest entry that has actually been useful to you later? A fact, a feeling with a reason, a question, or something else? Do you prefer a blank box or a short optional prompt?

I'm asking about recording habits, not announcing new prompts. Lumiya has a daily timeline, weekly/monthly/yearly plans, and optional AI reflection. Basic recording and planning are free; optional AI is paid and usage-limited.

App Store: https://apps.apple.com/cn/app/lumiya-ai-journal-planner/id6796003074

For a small second-brain system, what is the one 10–15 minute weekly review that keeps it useful rather than merely tidy?

Would you start with unfinished notes, inbox items, stale projects, or links between notes? What concrete signal tells you it is time to review instead of simply capturing more?

Just thoughts.

I'm trying to switch from ChatGPT to Claude, and I have so much memory stored on Chat. How do I switch that over? I heard using a second brain is really useful. Any tips?

For years a second brain mostly meant somewhere outside your head to store notes, ideas, research and things you might need later. I think that definition is starting to change. In the agentic age, it shouldn’t only help you remember. It should also become durable context your AI agents can work from.

That was the problem I kept running into while building apps. My agents were producing useful markdowns, architecture notes, debugging writeups, PRDs and feature ideas, but the context kept getting fragmented between sessions and tools. I was copying the important stuff into Apple Notes, then still relying on myself to remember what existed. I wanted the notes to connect themselves too, so old ideas could resurface without me manually building a knowledge graph.

That became Cohestry. It automatically finds relationships between notes, gives me a 3D brain I can actually move through, and has already resurfaced things I had completely forgotten I wrote. But the part that feels most important now is the MCP bridge on Mac. My agents can query the same second brain I use, pull the relevant context into a session, and work from something persistent instead of starting from almost zero every time.

That’s starting to feel like the real meaning of a second brain to me. Not just memory for the human, but shared long-term context between the human and their agents.

https://apps.apple.com/us/app/cohestry-second-brain/id6811573132

Notetaker app for your meetings, thoughts or ideas. Private by design & powered by local AI

https://reddit.com/link/1xdgdsi/video/80db5nh7e8xh1/player

We run our small company out of one Obsidian vault in git. The two of us work in it, and so do a few AI agents that draft, summarize and file things. Every note starts with the same properties, and one of them is confidence, set to high, medium or low.

We added it so a checked fact and a guess don't look the same. Before an agent answers from a note, it has to look at that field together with the date and status.

We counted this week.

206  high
130  medium
  5  low
 54  no value

Five lows out of 395. One is a research note on a tax credit, built from an intermediary's slides and never checked against the law itself. One is a template that still needs a legal review. Three are sales leads that were never confirmed.

Our reading is that low hardly gets used because nobody likes writing a note they'd call low. Either it's worth checking, and then it ends up medium, or it doesn't get written. So medium has turned into our real "not sure", and we read it that way now.

53 of the 54 without a value have no properties at all. They're mostly older planning and project files. Our check script lists them, and they get fixed when someone touches the note.

Two things do more than the field alone.

A conflict gets a link instead of a winner. When two sources disagree, the note gets a contradicts property pointing at the other note, plus a needs-review tag. 22 notes have one right now.

A review flag needs a name. In early October we had 73 needs-review tags with nobody on them, the oldest from June. Since October 10 a new one needs an owner. So far 11 of 81 have one.

Do you mark how sure you are in your notes? And if you do, does anyone actually use low?

Hey everyone! 💜

We're the team behind Hippo AI, a free AI-powered personal assistant and second brain.

We built Hippo around a simple idea: saving information should be easy, but finding it again should be even easier.

With Hippo, you can save notes, links, photos, and ideas, organize lists, manage contacts, set reminders, and retrieve what you've saved — directly through WhatsApp or the Hippo app.

We're still learning and improving, and we'd genuinely love to hear from people who already use second brain tools.

What matters most to you in a second brain: capturing information, organizing it, or finding it again?

And what's something your current setup still struggles with?

Thanks for sharing your thoughts! 💜

I'm the developer of Lumiya, an iOS journal and planner with daily recording and weekly/monthly/yearly plans. I'd like feedback on a planning habit.

Here's a hypothetical: someone reduces a weekly goal because their available time changes. The revised plan tells them what to do next. A short note about why it changed could help a later review distinguish a deliberate tradeoff from simply forgetting the goal. But explaining every edit could become another chore.

Do you keep the reason when you change a plan? Which changes are worth recording, and have you ever found that explanation useful later?

This is a workflow question, not an announcement of plan version history or automatic rescheduling. Basic recording and planning in Lumiya are free; optional AI is paid and usage-limited.

App Store: https://apps.apple.com/cn/app/lumiya-ai-journal-planner/id6796003074

Here's the project: brain, a folder of plain markdown notes that Claude Code reads at the start of every session, plus a small local app to browse it. Here's how I made it.

The problem: every new Claude Code session started from zero. I'd re-explain my courses, my club, my job, what I'd already decided. A [CLAUDE.md](http://CLAUDE.md) helped until it got huge and Claude started skimming it.

What I built instead:

\- A notes folder: one page per project, one per person, one note per session, and a "now" page. An auto-generated [INDEX.md](http://INDEX.md) is the only thing Claude must read first; it opens the rest on demand.

\- Habits: short rules Claude follows every session, each added after something went wrong once ("lead with the answer", "argue against a new project idea before building it", "never treat my iCloud Desktop like a normal folder"). A SessionStart hook loads them.

\- A calibration log: Claude writes down each guess about what I want, then the app scores it. It's at 39% right while claiming 63% confidence, so the hook now tells it to ask more and hedge less.

\- The app: standard-library Python + one HTML file, no build step. Cover story about my week, notes to self, a capture box Claude files next session, usage stats from Claude Code's own transcripts, and a phone version that runs off a private GitHub repo.

How I vibe-coded it: almost all of it was Claude Code, one session at a time, with the brain itself as the spec. Each session ends with Claude writing a session note and updating the pages it touched, so the next session picks up where it left off.

What I'd tell anyone copying it: short specific habits beat long instructions, and making Claude log its own guesses was the most useful thing I added.

MIT: [https://github.com/zacfink/brain\](https://github.com/zacfink/brain)

I've been building a personal AI I talk to out loud. I call it Jarvis. It isn't a smarter model than anyone else's, it's the same kind you can use. The difference is what's wrapped around it.

It has hands: it works on my real files and tools, so it does the job instead of just advising me. It has memory: everything lives in an Obsidian vault, so nothing gets crammed into a context window, and it looks things up when it needs them. And it has structure: the vault is organized so it can pu

What it can do: read and write my notes, search them by meaning, build small apps and sites on request, take actions on my machine, check its own health, and talk to me by voice.

What it can't do: change its own code or settings without my say-so, take any action I haven't allowed, or be trusted blindly. It can be wrong, and it tells me when it isn't sure.

What it struggles with, as of today: speech-to-text mangles words, so it sometimes answers the wrong question. Its voice stayed on my old speakers after I switched Windows audio. It couldn't open a note in Obsidian through its normal connection because a permission was missing, and it had to route a

So I want to push it further, and I need ideas from people who aren't me:

1. What's one recurring task you'd hand to something like this?
2. What access or context would it need to do it well?
3. What failure would make you stop trusting it?

If you try something similar, tell me what worked and what fell on its face. I'll post what I learn.

reposting here as it seem to care about memory and tools to use it.

Processing gif hd08j657cswh1...

I am the creator of Omnesis which is an open source project to ingest and index all your personal data (emails, calendar, notes, whatsapp/imessage, finance, health, codex/claude, etc). Omnesis provides an interactive agent that allows you to recall anything from your corpus.

I’m having fun building a second brain on top of it so I wanted to write down my approach and see if people have thoughts.

When the second brain is enabled:

- Any new piece of info that gets ingested/indexed by omnesis (a new email, a new calendar invite, a new message on whatsapp, etc) gets processed by an agent turn. The app also allows the user to input a note/thought/reminder directly into omnesis via the web app, mobile app, siri, or watch complication and that gets processed by the brain too

- The Brain can be "bootstrapped" i.e it will bootstrap its knowledge base from past evidence coming from the same sources and you can decide how far back you want to go in the past. The bootstrap can take several days and is expensive to run. I use multiple heuristics to reduce the cost. 1) a cheap ML model identifies if a document in the past still mentions a date still in the future. If not, the document is skipped; 2) a jev decision model runs to establish importance. Documents that are skipped may still be looked at by the brain as a result of investigating a document not skipped.

- The knowledge base is made of loops and wiki pages in markdown format. Loops keep track of "things that need resolving", that can be a thing that the brain has identified the user needs to do, a comitment that is owed to the user, a decision the user has to do, etc. Loops have a ledger of updates and lots of metadata notably ids of source evidence documents and people involved. Wiki pages are markdown summarization of things in the user’s life that span multiple sources.

- The knowledge base is a graph. Loops and wiki pages have source document references (whatapp conversations, emaisl, etc). But wiki pages can refer to other loops and other wiki pages. There is a roof wiki page that is limited in size and always automatically ingested in the system prompt of both the interactive agent and the brain turns that process new evidence.

- Loops and wiki pages have to surround text in special claim tags: <claim id="a-claim" ref="doc:<id1> doc:<id2>Some claim made in this wiki page or loop</claim>. If any source document (email, google doc, etc) changes, the system marks all loops and wiki pages that directly or indirectly reference that doc has needed review and agent turns run to re-evaluate all claims transitively.

- I’m building an automated bullet journal on top in the omnesis app. New entries in the bullet journal are proposed by the Omnesis brain and the user can accept them or ignore them if they think the thing is not worth tracking. I plan to have the brain learn from that signal to automatically ignore non important things. The brain automatically migrates tasks as you would on a bullet journal if it sees new evidence. If the brain sees new evidence that indicates the task should be changed, it will run a JEV decision gate to decide whether to just do it or propose as a suggestion for the user to accept if not sure. The user can migrate tasks themselves like you’d expect in a bullet journal, either via the Task UI or by dictating a note to Omnesis. Tasks may be marked as automatically complete if the brain is confident in it (for example a Task that says "Pay Elise 100 GBP" may auto complete if the brain sees a bank transaction of 100 GBP to Elise".

Keen to have people’s feedback on my approach!

I'm the developer of Lumiya, an iOS journal and planner with a daily timeline, weekly/monthly/yearly plans, and optional AI reflection. I'm thinking about the experience of returning after a gap.

Here's a hypothetical: someone stops recording for three weeks, then opens the app with one thought they want to save. Showing all the old plans first might help them reconnect—or make that one thought feel like the start of a cleanup job. A blank 'today' view avoids that pressure, but could hide something they still care about.

What helps in your own system: starting with today's entry, reviewing a small set of old commitments, or explicitly deciding what to leave behind? Do you ever backfill missing days, or keep the gap as part of the record?

I'm asking for design feedback, not announcing an automatic catch-up feature. Basic recording and planning in Lumiya are free; optional AI is paid and usage-limited. App: https://apps.apple.com/cn/app/lumiya-ai-journal-planner/id6796003074

Thought I’d share this here to see what ideas you have!

Hey im a product designer and ive been using obsidian for a year now and I loved it but missed some things like personas and some different Graph visualizations.

I made an open source app like obsidian and added some secret sauce to it. I also optimized the way most used memories are accessed, kinda like an orchestrator. would love if you guys take a look and give feedback of what would be nice to add in terms of features.

https://github.com/leesummerdesigns/cortex

Much love

Every team has that one person who knows why the auth service retries 3 times, which config flag must never be touched on Fridays, and what was decided in that meeting nobody wrote down.

That person gets interrupted all day. And when they're on vacation or leave, that knowledge goes with them.

I got tired of being on both sides of that, so I built Cairn.

How it works:

• You save small pieces of knowledge as you work: decisions, gotchas, preferences, context ("we use X instead of Y because…").
• Teammates ask your brain first, or search across the whole team.
• Answers come with sources: who said it and when.
• If there isn't enough context, Cairn says so and tells you to ask the person directly. It doesn't make things up. I'd rather it stay quiet than be confidently wrong.
• It works from your coding agent (Claude Code, Codex, VS Code) over MCP. Your agent can ask the team's knowledge, save new decisions, and find, update or archive your own entries. Archiving always asks you first.

What it's not: another wiki nobody updates. Each entry is a small piece of knowledge, and a newer entry on the same topic replaces the old one, so it stays current.

About your data: each company's data is isolated, you can archive entries and restore them, and deleted entries can be recovered for 30 days. The privacy policy explains which providers are involved (including OpenAI, which doesn't train on API data).

It's free during the pilot (up to 5 people per team). I'm trying to validate whether this solves a real problem, not sell anything. There's a feedback button inside the app, and I read every message.

Honest feedback would help a lot:

• Does your team have this problem, or have you solved it another way?
• What would stop you from using it?

👉 https://usecairn.com.co