![Liquid Glass](\"https://static.decoding.io/media/share/Screenshot%202025-12-26%20at%2015.20.33.png\"){kind=link}
![new app icon](\"https://static.decoding.io/media/share/Screenshot%202025-12-26%20at%2016.43.09.png\"){kind=link}
![has a small UI issue](\"https://static.decoding.io/media/share/Screenshot%202025-12-26%20at%2015.21.04.png\"){kind=link}
![touching each other](\"https://static.decoding.io/media/share/Screenshot%202025-12-26%20at%2015.21.59.png\"){kind=link}
I just realized that the ActivityPub plugin for WordPress does Fediverse replies inline too. Pretty nice!
\n![\"\"](\"https://decoding.io/wp-content/uploads/2025/01/image_db89a4bf-565d-488b-8eab-d8397b8a8498-1024x400.jpg\")
I keep a Zettelkasten, a personal knowledge base where I write notes and connect them over time. I\u2019m trying out writing about what\u2019s happening there, we\u2019ll see if it sticks.
\nI watched a video about M-shaped careers. People with too many interests (\u201cscanners\u201d) building deep expertise in multiple areas instead of forcing specialization. The Zettelkasten fits here as external memory that lets you switch topics without losing everything.
\nMy job is thinking, then AI executes. I don\u2019t write code anymore, I review it while Claude writes and I direct. My work runs on two tracks: notes and feature plans for AI to implement, and infrastructure that makes AI execution reliable.
\nClarify by prototyping, not planning. My old core value was \u201cMeasure twice, cut once\u201d, which assumed execution was expensive. These days prototyping is cheaper than planning, so I just build stuff and figure it out as I go.
\nAI reframes depth from execution to directing. The M-shaped career model assumes depth means doing the work, but with AI handling execution, depth becomes about understanding enough to see patterns and direct the AI.
\nThese three became permanent notes in my outline, and they\u2019re all connected to each other.
\nAs I use more AI tools these days, my old PKM setup started to feel off, so I ran an audit. The result was Each PKM tool should have one role. Tools work better when they do one thing, and my old setup had overlap everywhere.
\nCurrent pipeline:
\nI also wrote about GTD having a gap. Refinement is a missing stage between Process and Organize. GTD assumes everything captured can be immediately classified as actionable, reference, or trash, but some ideas don\u2019t fit any of these. They\u2019re not procrastinated or blocked, they\u2019re just unformed and still searching for shape. Someday/Maybe gets treated as a parking lot, but refinement is active, not passive. It needs systems for repeated contact with incomplete ideas until they\u2019re ready to become either a Zettelkasten note or a project plan.
\nMost of these notes come back to the same thing: AI made execution cheap, so I\u2019m rethinking how I work and how my tools support that. Three notes became permanent zettels, two are about my PKM setup, and one came from a video. That\u2019s the last two weeks.
\nI can safely say that Liquid Glass is the Butterfly Keyboard of software design. The basic idea is great, but the execution sucks.
\nI just hope it won’t take years to fix it.
\nI had my two previous post in the wrong format, so outgoing links didn’t work. Fixed it.
\nI don\u2019t usually do New Year\u2019s resolutions, but this year I made an exception. It\u2019s not a goal but a boundary, and it\u2019s that I want to stop spending thinking capacity on problems AI can handle well enough.
\nThings like passport renewals, car maintenance, and health insurance paperwork aren\u2019t intellectually hard problems for me. They\u2019re high-friction re-entries into suspended projects that steal the same executive function I need for creative work. So I\u2019m experimenting with an approach where Claude Code does the thinking and I become the hands and feet that execute.
\nYou might be wondering why I\u2019d give up that much control, but the thing is that I\u2019m not giving up control over outcomes, just over the tedious context-reconstruction that precedes every action.
\nThe standard productivity narrative says \u201cdo things faster.\u201d But I\u2019ve realized that for life admin, speed isn\u2019t the bottleneck. The bottleneck is cognitive re-entry.
\nEvery time I return to a bureaucratic project (health insurance setup, car inspection scheduling, government ID renewal), I pay a tax, and it\u2019s not a time tax but a thinking tax. I have to reload the entire context: What did I do last time? Where\u2019s that document? What\u2019s the phone number? What did the person say?
\nThis context reconstruction drains the exact same mental resource I need for interesting problems like creative work and engineering challenges, the stuff that actually benefits from my personal attention.
\nThe insight is simple, which is that most life admin problems are not hard. They\u2019re just high-friction re-entries. The thinking required isn\u2019t creative; it\u2019s reconstructive. And in my experience, Claude Code handles reconstructive thinking reasonably well (though I still verify critical details).
\nFor knowledge work, everyone talks about AI as a copilot where the human captain does the thinking and the AI assistant helps with execution.
\nFor life admin, I flipped this around so that Claude does the thinking while I handle the execution.
\nIn my early experiments, this architecture shows promise:
\nIt might sound like I\u2019m demoting myself to grunt work, but for me the hard part of life admin was never the physical execution. It was always the mental overhead of figuring out where I left off and what to do next. Once I know what to say and have my documents ready, making the call is easy (though I still need to think on my feet when conversations go sideways).
\nNow let\u2019s talk about how this actually works. For Claude to be useful, it needs context. It can\u2019t just be a chatbot I explain things to each time. It needs to temporarily inhabit the project\u2019s accumulated knowledge.
\nI call this approach \u201cGhost in the Shell\u201d (borrowing from the anime, where consciousness can inhabit different bodies). In my version, the \u201cshell\u201d is the project\u2019s accumulated data and the \u201cghost\u201d is Claude\u2019s reasoning capability that temporarily inhabits it.
\nEach project has a brain: notes, meeting transcripts, task history, linked documents. When I trigger a task, Claude loads this brain and reasons from that context.
\nI should mention the technical setup, which is that I use Claude with MCP integrations that can read from my document database and task manager. I use Mac-specific tools (DEVONthink for documents, OmniFocus for tasks, Hookmark for cross-app links), but the principle should be tool-agnostic since any setup that can aggregate project context and feed it to an LLM would work.
\nWhen I select a task in OmniFocus, Claude follows the project hierarchy upward to find the parent project, then loads all linked documents and notes. It builds a timeline of what happened. Then it can act with full context, not just respond to isolated prompts. Sure, Claude doesn\u2019t truly \u201cunderstand\u201d the project, but it synthesizes the available information well enough for bureaucratic tasks.
\nYou might ask whether managing AI becomes its own overhead, and yes, it can. I\u2019ve found that AI assistants can become another attention sink through clarifications, follow-ups, and re-prompts, and before you know it, managing the AI becomes a new kind of bureaucracy.
\nSo I built in what I call the \u201cone question rule.\u201d If Claude is missing information, it can ask one question maximum. Then it has to provide a best-effort plan with assumptions stated. If it\u2019s still stuck, it downgrades by first moving from doing the task to proposing a plan, and then to explaining how this type of problem generally works so I can handle it myself.
\nThis prevents Claude from becoming needy. It forces decisive action with explicit assumptions rather than endless clarification loops.
\nI also added risk-based escalation. \u201cAutopilot\u201d here means Claude proceeds without asking for confirmation:
\nThis doesn\u2019t prevent all errors. I still need to review what Claude produces, and I\u2019ve caught it confidently stating wrong details. But the guardrails prevent the worst-case scenarios while keeping friction low for routine tasks.
\nClaude doesn\u2019t just prep and disappear but waits for me to come back with results.
\nHere\u2019s a typical flow:
\nClaude: "Here's your call script for the mechanic. Key points to cover:\n timing, parts availability, price estimate. Come back when done."\n\n[I make the call]\n\nMe: "Done. He said Tuesday at 10am works, and the part needs to be ordered."\n\nClaude: Creates follow-up task that surfaces on the appointment date,\n logs the outcome to project notes (so next time I have this\n context), links everything together.This conversational loop keeps Claude as the orchestrator throughout. Every interaction gets logged back to the project\u2019s brain, so next time the context is even richer.
\nThe action types fall into three modes based on how much autonomy Claude gets:
\nAutopilot (Claude does the work, I review results): Research tasks where Claude queries Perplexity or analyzes code. Processing tasks where it extracts key points from articles or documents. Documentation tasks where it saves findings to DEVONthink and creates links between related items.
\nPropose (Claude preps, I decide and act): Phone calls where Claude loads my last conversation with someone, generates a script, and tells me what questions to ask. Emails where it drafts messages based on project context. Setup tasks where it researches best practices and generates step-by-step guides. Decisions where it builds comparison matrices and recommends options.
\nTeach (Claude explains, I learn): Learning tasks where Claude curates resources, creates a study plan, and suggests hands-on exercises, but I do the actual learning.
\nThe key insight is that even when Claude can\u2019t do the task, it can reduce my cognitive load significantly. For a phone call, I usually don\u2019t have to remember anything because Claude already looked up my last interaction with that person and what we discussed. I just read the script (though I still need to adapt when the conversation goes sideways).
\nI built a library of action types as markdown files that Claude reads when working on a task. Each type (research, review, process, draft, analyze, document, setup, learn, coordinate, execute, spec) defines a prep pattern for what Claude should do before I act, a capture pattern for logging results afterward, and which tools to use. For example, the \u201cdraft\u201d type handles phone calls and emails by loading contact details and past conversations, then generating a script or message draft.
\nThe process of building this library is ongoing. I pay attention to what types of actions I do repeatedly, then figure out how Claude could help with each one. Some actions start in Propose mode and graduate to Autopilot once I trust the pattern. The goal is to keep expanding what can be delegated as I discover new friction points.
\nClaude generates plans fresh each time using these patterns plus the project\u2019s accumulated context. In theory, this gets smarter with each use because the context compounds. I haven\u2019t measured this rigorously, but I\u2019ve noticed Claude\u2019s prep work improving as project histories grow richer.
\nWhat I\u2019ve found is that the real risk of AI assistants isn\u2019t that they make you lazy but that they make you a manager of an intern that asks infinite questions.
\nI prevent that by design through a kind of contract with Claude that includes clear modes of operation, risk-based guardrails, explicit definitions of done, and a hard cap on questions, so it behaves like a capable assistant rather than a needy one.
\nIs this worth the setup time? I spent a day building the infrastructure. Whether it pays off depends on how many bureaucratic projects I run through it. Ask me in six months.
\nFor now, I\u2019m experimenting with reserving my thinking capacity for interesting problems. Everything else gets delegated to the ghost in the shell.
\nI\u2019m writing on my blog from Bike today, which I still love.
\nAlso related but in a different way
\nThinking in Threads with Bike Outliner
\nNote: sometimes I wonder why do I keep a separate Zettelkasten around, since WordPress and my blog could solve that problem easily.
\nWriting in an outliner and publishing directly kinda works for me, since I’m not editing posts in some weird CMS (even if MarsEdit is awesome).
\nI like how easy it is to move rows around.
\nIt’s freeform text, but on the other hand, it’s still pretty structured.
\nI should write more posts from here. It would make sense for quick posts like this, no hard editing, even spelling errors.
\nNobody cares, the main idea is to push content which can be interesting.
\nThere is a new beta of DEVONthink in Liquid Glass.
\nLooks pretty nice.
\nThere\u2019s a new app icon, which is similar to DEVONthink To Go 4.
\nSome smaller UI issues
\nThe magnification glass on the right has a small UI issue.
\nGeneral settings drop-downs are touching each other.
\nThe Archive (native)
\nPlain-text Zettelkasten app with wiki-links, fast search, and minimal UI. File-based (markdown), local-first. The primary tool for this zettelkasten. (Workflow context)
\nMy current or previous usage of the app.
\nPrimary zettelkasten tool – all permanent notes live here. Main journaling and thought capture. Search and browse the knowledge network. Private notes hidden from published site. (Content pipeline)
\nPart of three-tool thinking system: Zettelkasten (The Archive) for journaling and permanent notes, TaskPaper for planning/brainstorming, Emacs for code experiments. (Different thinking modes)
\nArticles and websites
\nSummary of this article.
\nManan Khattar’s case for The Archive: 1,330 notes (350K words) in plain text. Speed and keyboard-centric design minimize cognitive friction. Search-driven workflow enables queries like #literature #inbox (productivity OR writing) (202407 OR 202408). Native Zettelkasten support from zettelkasten.de’s creator.
Trade-offs acknowledged: unique identifier requirement makes wikilinks less readable than Obsidian. No plugin system\u2014requires Alfred workflows for full functionality. No mobile app (uses 1Writer as workaround).
\nCore thesis: tool choice matters less than sustaining writing-focused thinking habit. The Archive’s speed accelerated his adoption.
\nI got to know kindaVim from this article.
\nActually, I already wrote about this before: Bookmarked \u201ckindaVim\u201d
\nThere are videos about kindaVim: kindaVim – YouTube
\nMost of them just ramblings.
\nThis is another app from the same guy for keyboard based UI navigation: Wooshy
\niA Writer (native)
\nDistraction-free markdown editor with focus mode, syntax highlighting, and publishing integrations. Typography-first design from Information Architects.
\nMy current or previous usage of the app.
\nDrafting and linking workflow via smart folders. #Drafting folder shows notes being written, #Linking folder shows notes ready for outline placement. The final drafting step before zettelkasten integration. (Content pipeline)
\nArticles and websites
\nWriting Workflow – Stuart Lennon
\nSummary of the article, focusing on the question \u201cWhat am I writing?\u201d section.
\nStuart Lennon’s framework: three writing categories.
\nLongform (2000+ words) in Scrivener for novels/non-fiction.
\nShortform drafts in iA Writer for blog posts and reports.
\nNotes ideas in Obsidian for thoughts not yet publication-ready.
\nThe “What am I writing?” question determines tool selection. Plain text everywhere for portability. DEVONthink as archive. Open question: whether Drafts could serve as unified entry point with automated routing.
\nBike (native)
\nNative macOS outliner with fast keyboard navigation, collapsible hierarchy, and scripting support. Version 2 adds extensions API and custom attributes. The app running this outline.
\nMy current or previous usage of the app.
\nCore organizing tool for the content pipeline. Ideas get arranged in Bike outlines before export to zettelkasten via Drafts. Also manages the folgezettel outline structure. (Content pipeline)
\nDecoding files are raw Bike outlines for blog posts. All content ready for publishing; private things go to interstitial journal instead. (Journal-type apps)
\nNow used as AI-integrated thinking space with thread-watch and MCP server. Reactive prompting via @question attributes. (Bike thinking tool exploration)
\nArticles and websites
\n\nTaskPaper (native)
\nPlain-text task management using indentation and tags. Same developer as Bike. Good for project brainstorming and task breakdown. (Workflow context)
\nMy current or previous usage of the app.
\nTaskPaper role: plain-text planning and brainstorming for project-specific thinking and task breakdown. OmniFocus shortcut triggers “project brainstorming” in TaskPaper. (Different tools for different thinking modes)
\nHistorical use: interstitial journaling. Deprecated that role, moved journaling back to zettelkasten. Brainstorm sessions now live in the journal rather than separate files. (Plans for TaskPaper changes)
\nWorkflow: Bike for initial outlining, switch to TaskPaper once plan solidifies. Part of the plain-text system alongside The Archive and Bike. (Text-based system)
\nArticles and websites
\n\nDrafts (native)
\nQuick capture app with powerful actions system for routing text to other apps. Automation-first design. Inbox for thoughts, not storage.
\nMy current or previous usage of the app.
\nExport gateway from Bike to zettelkasten. Ideas organized in Bike get exported through Drafts into new notes. Also used for quick capture on Apple Watch at night. (Content pipeline)
\nMCP server spec exists for automation integration. AppleScript-based CRUD operations planned but automation permissions need resolution first. (Drafts MCP spec)
\nArticles and websites
\n\nCraft (native)
\nBlock-based document editor with rich formatting, folder structure, and cross-device sync. Apple Design Award winner, positioned between Notion and traditional notes.
\nMy current or previous usage of the app.
\nPrimary reading queue manager via Readwise-Craft syncer integration. Articles flow in, get processed with highlights, then export to zettelkasten. MCP server enables AI automation. (Readwise-Craft syncer)
\nDaily notes workflow for session logging and project tracking. Block-based structure good for moving content between documents. (Content pipeline)
\nArticles and websites
\n\nDEVONthink (native)
\nDocument/knowledge management database with AI classification, OCR, and smart groups. Stores anything, indexes everything. Research-grade organization.
\nMy current or previous usage of the app.
\nDEVONthink role: document archive and reference storage. Articles, PDFs, web archives, receipts. AI classification and OCR. Research-grade organization with smart groups. (Incremental reading system)
\nReading queue integration: documents captured to DEVONthink appear in OmniFocus @Read/Review perspective. The queue is in OmniFocus, content stays in DEVONthink.
\nMCP access via mcporter enables AI agents to search and retrieve DEVONthink content. Source references in older zettelkasten notes use x-devonthink-item:// links.
\nArticles and websites
\n\nObsidian (Electron)
\nPlugin-extensible markdown vault with graph view, backlinks, and community ecosystem. Electron-based, local files. Power-user PKM tool.
\nMy current or previous usage of the app.
\nLimited use currently. Explored for AI integration with Cursor but zettelkasten workflow remains in The Archive. Considered for consolidating Planning folder but not active. (Obsidian exploration)
\nArticles and websites
\n\nOmniOutliner (native)
\nProfessional outliner from OmniGroup with styling, columns, and export options. More structured than Bike, less nimble. AppleScript support.
\nArticles and websites
\n\nMindNode (native)
\nVisual mind mapping with clean design and focus mode. Exports to various formats. Good for brainstorming spatial relationships, less for linear text.
\nMy current or previous usage of the app.
\nUsed for preparing content before processing. Ideas get connected to mindmaps with tags and links before moving to notes. Public mindmaps shared online (e.g., Japanese Design and Aesthetics). (Processing workflow)
\nArticles and websites
\n\nScapple (native)
\nFreeform note board from Literature and Latte (Scrivener makers). Spatial arrangement of text snippets with connection lines. Idea exploration before structure.
\nArticles and websites
\n\nNotePlan (native)
\nMarkdown notes with calendar integration and task management. Daily notes workflow with backlinks. Hybrid of journaling and task app.
\nArticles and websites
\nMy Ultimate Productivity Tool Workflow for 2024: Plan with Me in NotePlan
\nMy Productivity Workflow 2025: Task Management + Apple Shortcuts + Gmail
\nMy NotePlan Workflow \u2014 Everything I Need to Plan and Execute my Day
\nNotePlan: Your Notes, Tasks, and Calendar in One Place – MacSparky
\nDistill (Tauri)
\nAI-native thinking tool with append-only threads and contextual awareness. Local-first with cloud sync. Discussed earlier in this document.
\nMy current or previous usage of the app.
\nExplored briefly – app installed, bug filed about quick capture window positioning with right-side Dock. Append-only threading concept influenced thread-watch development. (Reactive prompting)
\nRemoved from active toolchain – no current use case. Keep app installed for existing content. (Journal-type apps conclusion)
\nExplored briefly – app installed, bug filed about quick capture window positioning with right-side Dock. Append-only threading concept influenced thread-watch development. (Reactive prompting)
\nRemoved from active toolchain – no current use case. Keep app installed for existing content. (Journal-type apps conclusion)
\nArticles and websites
\n\nBear (native)
\nMarkdown notes with tags, nested tags, and backlinks. Clean native UI. Simpler than Obsidian, more polished than most.
\nArticles and websites
\n\nUlysses (native)
\nLong-form writing app with library management and publishing targets. Markdown-based but hides syntax. For writers shipping manuscripts.
\nArticles and websites
\n\nNoteship (native)
\nMinimal sticky-note style capture app. Menu bar access, quick entry. Capture-focused, not organization-focused.
\nArticles and websites
\nNotebooks 3 (native)
\nHierarchical notebook app with nested books and markdown support. Cross-platform sync. Traditional notebook metaphor with modern features.
\nArticles and websites
\n\nScrivener (native)
\nLong-form writing IDE with binder, corkboard, and compile system. For novels, screenplays, research papers. Structure-first drafting.
\nArticles and websites
\n\nTinderbox (native)
\nHyper-customizable note database with agents, attributes, and visual maps. Steep learning curve, extreme power. For complex knowledge work and research.
\nMy current or previous usage of the app.
\nHigher-level life management – dreams, someday/maybe ideas, things above projects. Scripts connect OmniFocus to Tinderbox for two-way sync. Ideas and goals live here; projects get managed in OmniFocus. (Tinderbox for life management)
\nIncremental Reading document watches Readwise chunks folder. Considered skipping from general chunk processing due to workflow friction getting content in. (Tinderbox workflow friction)
\nArticles and websites
\n\nBBEdit (native)
\nProfessional text editor with grep, syntax coloring, and scripting. Not a note app per se – a text tool that handles notes. 30+ years of macOS development.
\nArticles and websites
\n\nOrg-mode with Emacs (native)
\nPlain-text outliner inside Emacs with TODO states, scheduling, and literate programming. Keyboard-driven, infinitely extensible. Used for programming experiments. (Workflow context)
\nMy current or previous usage of the app.
\nCurrent Emacs usage: Org Mode for programming experiments and literate programming. Still exploratory – set up OmniFocus shortcut for “programming docs” but workflow not fully established. (Different Tools for Different Thinking Modes)
\nOrg Agenda navigation shortcuts documented separately – day/week views, date jumping, standard Emacs keybindings. (Org Agenda Shortcuts)
\nPosition in tool ecosystem: Zettelkasten (The Archive) for journaling and permanent notes, TaskPaper for planning/brainstorming, Emacs for code experiments. Three tools, three thinking modes.
\nArticles and websites
\n\nStrflow (native)
\nStream-of-consciousness capture app with AI integration. Continuous text flow rather than discrete notes. Early-stage product.
\nMy current or previous usage of the app.
\nShort idea dumps when thinking about something – ideas then move to OmniFocus/Bike. Removed from active toolchain; no current use case. App kept installed for existing content. (Journal-type apps conclusion)
\nShort idea dumps when thinking about something – ideas then move to OmniFocus/Bike. Removed from active toolchain; no current use case. App kept installed for existing content. (Journal-type apps conclusion)
\nArticles and websites
\n\nNotePlus (native)
\nNative macOS LLM client (~10MB). Supports OpenAI, Gemini, Anthropic, Ollama, DeepSeek, Copilot. Different category than Bike\u2014this is a chat interface with note-taking features, not an outliner. The “True Native” claim positions it against Electron apps.
\nI’ve been looking for a tool that supports threaded thinking. Distill nails the concept: you think out loud into threads, and AI agents respond inline without breaking the flow. But it’s pricey, hosted, and not native. I want local files so I can use git.
\nSo I built something similar with Bike.
\nThe core concept is append-only threading. New thoughts go at the end. No reorganizing, no inserting between existing ideas. The thread keeps expanding.
\nThis preserves how ideas actually develop. When I capture thoughts in a traditional outline, I’m constantly deciding where things go. That decision-making interrupts the thinking. With append-only, there’s no decision. New thought? Add it at the end. Want to go deeper? Indent.
\nI’ve written about this before in Reviewing append-only workflows. The pattern keeps showing up: Mastodon threads, chat-based note apps like Gibberish, and now Bike.
\nBike is a macOS outliner (think Workflowy, but native and scriptable). What makes it work for threading:
\nThe structure emerges from the content. I start typing, indent when going deeper, and the hierarchy forms naturally.
\nDistill’s insight is that AI agents can watch threads and respond without being addressed directly. I wanted that for Bike.
\nSo I built thread-watch. It watches my outlines for rows tagged with @question and adds responses as indented blockquotes. The workflow:
@questionThe responses stay in the thread. They’re part of the thinking record, not a separate conversation.
\nHere’s what it looks like in practice:
\n\n\nThe technique I use for AI responses is what I call reactive prompting. The agent isn’t addressed directly. It responds to the thought stream.
\nThe system prompt tells Claude to write like margin notes in a book: factual, terse, no “I found that\u2026” discovery narrative. This matters because conversational AI responses feel like interruptions. Reactive responses integrate with the thinking instead.
\nThe agent has access to my Zettelkasten folder. Before answering, it searches for relevant existing knowledge and links back. I was outlining something about capture workflows, tagged it @question, and the agent found a note I’d written two years ago. The response linked back, and I restructured my outline based on what past-me had already figured out.
Bike becomes the staging area for fast thinking. When something crystallizes, I copy it to the zettelkasten as a permanent note.
\nAppend-only limits restructuring. If the structure is wrong, I can add cross-references and synthesis rows, but I can’t reorganize without losing the thinking record.
\nTagging @question and running the tool is still an interruption. It’s smaller than switching to a chat window, but not invisible.
Standard outlining is about organization. Threading is about capture. I’m not building a perfect structure. I’m externalizing thinking fast enough that I don’t lose it, and the AI assists inline when I need context.
\nThe structure emerges. The thread keeps expanding.
\nI’ve been running macOS Tahoe‘s new Liquid Glass design on my MacBook Air for a couple of days. Parts work, parts don’t, but most people will adapt quickly enough.
\nThe smart thing Apple did was leave 3rd-party apps alone. They run with the previous design intact, giving you familiar anchors while you adapt to the new interface. Electron apps will probably never update, which might be a blessing.
\nThe dynamic background adaptation is broken. Buttons shift from black to white as the background changes, and it’s jarring every single time. Toolbar consistency is all over the place too. Photos and Mail use progressive blur with gradients while Safari keeps the old blurred rectangle, with no apparent logic to which apps get which treatment. Scrolling through Photos is particularly painful as the interface flips from black to white and back again as you move through your library. This isn’t a minor polish issue. It’s a fundamental problem with how the adaptive system responds to content, and Apple should fix it.
\n\n\n\n
\nWhen the general public gets their hands on Liquid Glass, I’m sure people will complaint. The current state is too buggy to survive contact with millions of users. I expect iterative improvements throughout the OS 26 cycle as the design gets tweaked based on user feedback.
\nThe foundation has potential, but the background adaptation logic needs fixing. Until then, it’s a work in progress.
\nThe new /context command in Claude Code revealed how I’m wasting tokens by having all MCP (Model Context Protocol) tools loaded into one session for every conversation. When I’m in the middle of development, I don’t need OmniFocus task management or DEVONthink database tools.
Based on subagents I had the following idea: what if I split Claude into specialized personas, each loading only the tools it actually needs?
\nInstead of one bloated agent trying to do everything, I created three specialized personas:
\nMain Persona (cc): The clean, focused default. Just filesystem, bash, and macOS automation via one MCP server. This handles most of my daily coding tasks with minimal tool overhead.
Research Persona (ccr): The deep investigation specialist. Loads Zen for multi-model reasoning (GPT-5, O3, Gemini Pro), Context7 for library docs, Octocode for code search and analysis, and Codex for deep code research. When I need to debug something complex or review architecture, this persona has the tools.
GTD Persona (ccg): The productivity workflow expert. Connects to OmniFocus for tasks, Obsidian for notes, DEVONthink for documents, and HyperContext for calendar management. This persona focuses on productivity workflows and task management.
Each persona also has access to subagents for specialized tasks, adding another layer of capability without wasting more tokens.
\nThe implementation lives in my dotfiles as simple shell functions:
# Main persona - clean and fast\ncc() {\n claude ${*} --dangerously-skip-permissions\n}\n\n# Research persona with specialized tools\nccr() {\n claude ${*} --dangerously-skip-permissions \\\n --model opus \\\n --mcp-config ~/.claude/mcp-research.json \\\n --append-system-prompt \"You are a code research and analysis specialist \\\nfocused on deep technical investigation, multi-model reasoning, and \\\ncomprehensive code review. Your expertise includes security auditing, \\\narchitecture analysis, debugging complex issues, and researching best \\\npractices across codebases. You leverage multiple AI models for consensus \\\nbuilding, use Context7 to fetch up-to-date library documentation, analyze \\\nGitHub repositories for patterns with Octocode, and generate thorough \\\ntechnical documentation.\"\n}\n\n# GTD persona with productivity tools\nccg() {\n claude ${*} --dangerously-skip-permissions \\\n --model opus \\\n --mcp-config ~/.claude/mcp-gtd.json \\\n --append-system-prompt \"You are a GTD specialist orchestrating a \\\nmulti-layered knowledge system where OmniFocus drives project execution, \\\nObsidian captures notes and knowledge, and DEVONthink archives reference \\\nmaterials. You excel at processing inboxes across all three systems, \\\norganizing projects with proper next actions, capturing meeting notes \\\nwith task extraction, and maintaining a trusted system for all personal \\\nand professional information. Your expertise includes creating bidirectional \\\nlinks between systems using Hook and maintaining clear separation between \\\nactive project work and archived reference materials.\"\n}\nEach persona loads its own MCP configuration file, containing only the relevant tool servers. The --append-system-prompt flag gives each persona a specialized identity and deep expertise in their domain.
The most powerful aspect isn’t just the separation. It’s the ability for personas to delegate to each other. This creates a network of specialized expertise without loading unnecessary tools.
\nWhen delegation happens, I must approve it first. The main persona will say something like: “I’d like to ask the research persona to analyze this Rails controller for N+1 queries using its specialized tools.” Once I type “approved” or “go”, the delegation proceeds.
\nThe delegation always runs in the background using the Bash tool:
\n// How the main persona actually delegates\nBash({\n command: 'ccr -p \"Analyze this Rails controller for N+1 queries and performance issues\"',\n description: \"Ask research persona to analyze Rails performance\",\n run_in_background: true\n})\nThis pattern works both ways. I can also delegate GTD tasks with a simple OmniFocus link:
\n# Ask GTD persona for comprehensive project review\nccg -p \"/gtd:project-review omnifocus:///task/jP9S4CFgPin\"\n
The GTD persona doesn’t just fetch tasks. It discovers linked resources through Hookmark, pulls references and meeting notes from DEVONthink, reads project plans from Obsidian, builds a complete timeline, and suggests concrete next actions based on the full project context. All while the main persona continues with development work.
\nThe background execution is key. The delegating persona doesn’t block waiting for results. It can continue working on other aspects while the specialized persona handles its domain-specific task.
\nThe token savings are significant, but the real benefit is focus. Each persona does one thing well with the right tools for that job. The system prompts shaped distinct behaviors. The main persona stays lean and fast. The research persona leverages multiple AI models for deep analysis. The GTD persona navigates my entire productivity stack.
\nSpent today designing the Rails controller layer for Pezeta.
\nI analyzed Capito, an envelope budgeting prototype I built seven years ago. Standard approach \u2013 categories as envelopes, track balances, show what’s left to spend, like YNAB. But Pezeta takes a different angle. Instead of manually managing category balances, I’m building a goal-oriented system where users define financial objectives and the system calculates the monthly allocations needed to achieve them.
\nFor the controller architecture I designed five main tasks:
\nAuthentication & Ledger Foundation \u2013 Auto-create ledgers with system categories when users sign in the first time. System categories like Income and Safe to Spend get created automatically, so no manual setup required.
\nBudget Controller \u2013 Returns a single JSON endpoint for now, focused on Safe to Spend calculation and future goal balances. This is what the UI will display prominently, not a list of category balances.
\nCategories Controller \u2013 Standard CRUD for user-defined categories. Goals are implemented as special categories with allocation rules that determine how they get funded each month.
\nMonthly Allocations \u2013 This is where goal-driven allocations get applied, but users can override them when needed.
\nTest Infrastructure \u2013 Rails conventions with fixtures that include the system categories.
\nI’m sticking with pure Rails MVC patterns, so no service objects, no complex abstractions. Business logic lives in models, controllers stay thin, everything renders JSON for now since we don’t have a Turbo-based UI yet.
\nThis foundation should make the goal system feel automatic rather than manual.
\nI built the model layer for goal-oriented budgeting in Pezeta today. This is the implementation of the goal system I’ve been designing over the past week.
\nI’ve laid the foundation for four distinct goal types:
\nI still need to test all of this thoroughly, but the models are in place and the calculations are working. What I like about this approach is how it will turn vague financial intentions into concrete monthly actions. Want to save $5,000 for a vacation by next December? The system can calculate exactly how much to set aside each month. Need three months of expenses in your emergency fund? It’ll figure out what that means based on your actual spending patterns. The system tracks progress over time, adjusts recommendations based on current balances, and integrates smoothly with the existing budget structure.
\nNext up is building the UI layer. The foundation is solid, but there’s still work to do before I can actually use these goal features in my own budgeting workflow.
\n\nTwo nights ago, I deleted everything.
\nEvery note in Obsidian. Every half-baked atomic thought, every\nZettelkasten slip, every carefully linked concept map. I deleted every Apple\nNote I\u2019d synced since 2015. Every quote I\u2019d ever highlighted. Every to-do\nlist from every productivity system I\u2019d ever borrowed, broken, or\nbastardized. Gone. Erased in seconds.
\nWhat followed: Relief.
\n
Sometimes it\u2019s good to delete things, but a second brain isn\u2019t an end goal. The sole purpose of a second brain is to help achieve some form of output. It serves as a tool to organize thinking for the future.
\nThe problem with output is that we often don\u2019t know what it will look like when we start. What a Zettelkasten (and GTD too) acknowledges is that you\u2019ll have an outcome of some kind and you need a framework to manage it. That\u2019s all.
\nPeople who capture their ideas then leave them there are still doing the same thing, but can probably think through their output in their head. I do that sometimes too, and it\u2019s fast.
\nBut as soon as I\u2019m working on anything that requires more thinking capacity than I currently have, I reach for PKMs and task managers to handle it.
\nI usually split my long-term project-specific Zettelkastens off from my main one, though.
\nPreviously:
\nToday I worked on planning Pezeta’s goal system. I experimented with using two AI agents to collaborate on breaking down the work: Claude Opus 4 as the coordinating agent with read/write access, and ChatGPT o3 through Repo Prompt for implementation planning.
\nThe idea was to leverage each model’s strengths. Claude handles the file operations and manages the task structure, while ChatGPT analyzes the codebase and suggests implementation approaches. They literally chat with each other using the Repo Prompt MCP tool, with Claude asking questions and ChatGPT providing analysis. Sometimes I had to intervene to guide them back on track or stop them to wait for my approval on design decisions. It’s like having two developers pair programming, each bringing their own expertise to the planning session.
\nThe approach surfaced some important design decisions. Instead of service objects, we’re going with Rails-idiomatic patterns: model methods, class methods on MonthlyAllocation, and callbacks for snapshots. Everything through ActiveRecord.
The bulk of the work went into defining test specifications:
\nEach test case addresses specific edge cases. What happens when a monthly goal already has surplus funds? How does a deadline goal behave when it’s past due? Getting these details right upfront matters.
\nAll calculations will use “opening balance,” the balance at the start of the month, not the current balance. This prevents allocation amounts from changing as transactions flow through during the month, which matches how people think about budgets.
\nThe session produced seven detailed task files ready for implementation. Each includes exact specifications, test cases, and implementation notes. The tasks cover Single Table Inheritance strategy, historical snapshots through callbacks, and model-driven allocation suggestions.
\nTomorrow I’m letting Claude Code implement these tasks.
\nHad a focused session today expanding the goal system design for Pezeta. Yesterday I started with the basic concept, today I dove deeper into the details.
\nI expanded all four goal types with detailed logic and edge cases:
\nSo this session was used to think about these and take a deep dive in the goal rule engine inner workings. I still have questions but it will be iterated when I start using the MVP. I have goal examples in my current budget for all of these.
\nThe technical challenge was handling goal changes over time. What happens if you change your vacation target from $2,000 to $3,000 in March? Should January’s allocation be recalculated as if you always wanted $3,000?
\nI went with a snapshot approach. Each month gets its own snapshot of goal parameters. Past months never change retroactively. January’s allocation was based on January’s goal settings, period. This preserves the audit trail of what you were thinking at the time.
\nToday wrapped up the core data foundation with the Budget view model and spent time planning the goal allocation rules that’ll make this budgeting app different.
\nThe Budget model pulls everything together. Give it a ledger and a month, and it calculates the current state of all categories, their allocated amounts, actual spending, and remaining balances.
\nThis is just pure Ruby class that takes the foundational models and presents them in a way that makes sense to users.
\nThe bigger breakthrough today was finalizing the goal allocation rules. This is what’ll set Pezeta apart from traditional envelope budgeting.
\nInstead of managing dozens of budget categories, users define their financial goals\u2014things they actually care about saving for. The app figures out how much to allocate to each goal and shows one simple number: how much is safe to spend on everything else. Goals run in the background while you focus on that single “Safe to Spend” amount.
\nI want to implement four goal types:
\nEach follows different allocation formulas, but the key insight is the engine just calculates expected allocations\u2014it never moves money automatically. That stays under your control.
\nI’ve got a React prototype artifact built with Claude that demonstrates how this will look. We have a simple “Safe to Spend” number on top, goals running quietly in the background. I just created this to validate the UX approach, but it shows the vision clearly.
\nDay two of building Pezeta. Yesterday was all planning and starting. Today was about getting my hands dirty with actual Rails models.
\nCompleted the three core models today:
\nCategory model (with proper enums and validations)MonthlyAllocation model (with decimal precision for money)Transaction model (income/expense tracking)Not the most exicting part for people to see (and I\u2019m spending about 1\u20132 hours a day to build this), but I want to get the models right, that\u2019s the whole point of why I\u2019m writing the first MVP in Rails, I know Rails the best.
\nI\u2019m trying to stick to test-driven development. Write the test first, make it pass, move on. Feels slower at first, but every time I change something, I know immediately if I broke anything.
\nHere\u2019s something weird I\u2019m trying: I started a new zettelkasten in Obsidian yesterday to drive this whole project.
\nThe idea: use notes as the driving force to guide Claude Code through writing the actual code. I think in the zettelkasten, then I let AI collect that context and draft the output: code, blog posts, status updates etc. At the end I still manually review and adjust.
\nI\u2019m using a modified version of Ian Nuttal\u2019s Task Magic system to drive the development. Break big plans into smaller tasks, then automate the output generation. Not just code generation though. Claude Code helps with everything like documentation, tests, even these blog posts, but I\u2019m still reviewing everything.
\nMy theory is that this might be the fastest way to do solo development today. Capitalize on what AI is actually good at – turning clear thinking into working artifacts.
\nWe\u2019ll see if this scales. but for now, it\u2019s working.
\nFinally decided to start building Pezeta today. It’s been in my mind for years – since we started Agyvihar, our Hungarian podcast about personal finance and productivity.
\nSimple: a budgeting app that tells you one number – how much you can spend right now.
\nThat’s it.
\nNo charts. No categories. No endless reports. Just open the app and see: $47. Or $134. Or whatever you can actually spend without screwing up your budget.
\nThe One Number – Your daily spending limit. Updated in real-time. Factors in your bills, savings, everything.
\nGoals – Want to save $2000 by December? Cool. The app adjusts your daily number automatically. No spreadsheets required.
\nThat’s basically it. If budgeting were simpler, maybe more people would actually do it.
\nI’m not jumping straight into building native apps. Starting with a Rails MVP instead.
\nFew reasons:
\nThis Rails version won’t go public. It’s just for me to validate the idea and work out the kinks.
\nI’m putting it all out there because watching someone figure things out might be more useful than another perfect tutorial.
\nPartly for feedback – maybe someone will tell me this is a terrible idea before I waste six months on it.
\nPartly for accountability – harder to quit when people are watching.
\nPartly because I’m curious what happens when you share the messy process instead of just the polished result.
\nStarting with Rails 8 setup, basic models, authentication. The boring foundation stuff that nobody talks about but takes forever.
\nAfter that, we’ll see. Building software is weird.
\nContinuing 3380:
\nMaybe I should use tags as a thread title in a way that group posts together. I\u2019m using pretty general tags currently, which is fine, but a tag page is just another filtered wall of text. This way, each post could be part of an ongoing conversation. Here\u2019s an example page for a thread.
\nIt means that I could have more precise tags which can be displayed in the sidebar, or even better, I can link to a thread which kind of acts like an article on its own. It was just written in a chronological order.
\nAs an icing on the cake, a post could belong to multiple threads.
\nContinuing 3378:
\nIf you visit the front page of my blog, you\u2019ll notice that I organize posts by day, inspired by the daily notes feature from Roam Research.
\nI typically enjoy this wall of text style more than having separate posts highlighted individually (perhaps that\u2019s why I like threading on Mastodon).
\nThe issue is that WordPress lacks a similar feature, but I would love to have threading on my blog too. My Zettelkasten can stack connected notes, which aligns with this concept.
\nMaybe I should create something that allows me to link posts together, with backlink support.
\nPreviously:
\n\nI sometimes think we might need different ways to share ideas instead of long articles\u2014it\u2019s important to mention that I’m talking about ideas, not stories.
\nLooking at how I read, I see that I usually skim content instead of reading it all at once. Then, I go back to the interesting parts later. If you think this is like Incremental reading, then you\u2019re correct.
\nI\u2019m not sure what might happen if I started using formats closer to the raw idea then heavily edited posts.
\nI\u2019ve been thinking about using voice input more in my workflow after watching Chris from DailyTekk talk about quitting typing. He made some interesting points about how speaking (120-150 words per minute) is naturally faster than typing (40-60 words per minute). What was interesting is his observation about typing disrupting the flow with constant self-editing\u2014I\u2019ve definitely experienced this.
\nSo, I\u2019m experimenting with various voice-based input options for my Mac (and possibly iOS/iPadOS as well).
\nI recently acquired VoicePen as a tool to take voice notes. It\u2019s not a direct dictation app, though. Instead, it works by recording voice in a separate app and then allowing you to copy the cleaned transcription back to your note-taking app. It maintains a history of transformations (such as fixing grammar and cleaning the text) alongside the original transcription. I can revisit and reapply these transformations or copy different versions of the text. It\u2019s a decent tool, but it\u2019s not designed for real-time voice input.
\nI looked at Inbox AI too, but it\u2019s more of an automation app and I don\u2019t want to invest time learning it right now. I\u2019m sure it can do this.
\nBolt.AI offers something different – it has an inline dictation feature. I\u2019m currently trying out its dictation with chat assistants\u2014being able to talk naturally to AIs instead of typing.
\nI\u2019m also experimenting with macOS\u2019s built-in dictation. It integrates well with text editing and shows what I\u2019m typing in real-time. Sure, it sometimes types the wrong stuff, but these can be fixed quickly with the built-in writing tools.
\nI\u2019m noticing there\u2019s a difference between thinking out loud and just dictation\u2014I\u2019ll need more time to figure out what works best for each case. For now, I think each input method\u2014typing, voice, even Apple Pencil\u2014probably has its place. I\u2019ll likely end up using a mix of them depending on what I\u2019m trying to do.
\nAfter today\u2019s post on disabling the wake on lid open, I got a comment from smarthieef on how we can switch off this behavior for the keyboard too, so we can only turn on the MacBook using the Touch ID button, making the keyboard cleaning process way easier.
\n\n\n\n
\n- Press and hold the left Control and Command buttons with right Shift button for a total of 7 seconds.
\n- Without releasing them, press the Power button and hold together for an additional 7 seconds until your laptop shuts down. The login screen may flash for a second so don’t prematurely release the keys until the machine is off.
\n- For your next startup, your Mac can only be powered on by using the Power button or closing and opening the lid.
\n
I tested this on a 16-inch M1 MacBook Pro, and it works indeed. It is also a one-time thing, so on the next boot, it resets this behavior to the default one, so we can get the best of both worlds.
\nUpdate: I tested this on an M3 MacBook Air too, and it didn\u2019t work.
\nI just realized that the ActivityPub plugin for WordPress does Fediverse replies inline too. Pretty nice!
\nI\u2019m just playing around with Muse for Mac, and I just found this picture in their macOS version announcement post.
\n![\"Creative](\"https://decoding.io/wp-content/uploads/2025/01/creative-process.png\" "\\"creative-process.png\\"")
I love this analogy. Every idea we execute should have some form of artifact at the end: a blog post, a Zettelkasten note, a presentation, an email, etc.
\nI\u2019ll use this distinction between the different apps that I use for idea development.
\nPreviously:
\nSince I started to thinker with private Mastodon threading, I’ve been experimenting with using Mona as a private note-taking app.
\nHiding the Home tab from Mona makes the app feel more private. I only left the following tabs available because I want to optimize it only for my posts.
\n![\"\"](\"https://decoding.io/wp-content/uploads/2025/01/2025-01-19_09-44_mona-tabs.png\")
I read other people’s posts in Reeder; I use Mona for threading and journaling about ideas privately (and keeping up with my notifications and mentions).
\nAnother thing I did is to replace the \u2318N keyboard shortcut with a custom Keyboard Maestro macro which creates private posts by default. This way, I can work on my threads in a private manner, but still see my notifications if I post something public.
\nThese changes make Mona a note-taking app with built-in discussion features. I don’t know if we have any other app like this.
\nThis is one of the things I love about the Fediverse. In essence, it is just a public place where we post things, but we can make weird mashups on top of it, like a note-taking app.![\"\"](\"https://decoding.io/wp-content/uploads/2025/01/mona-private-setup.png\" "\\"mona-private-setup.png\\"")
A few days ago I wrote about getting back to Mastodon, and it\u2019s becoming an unexpected part of my workflow. While I initially set up my instance just to syndicate my blog posts, I found myself using it in ways I didn\u2019t anticipate.
\nRemember how I loved Gibberish\u2019s chat-like UI for drafting ideas? Well, Mastodon\u2019s thread format accidentally became my new space for thinking out loud. I create private threads where I can ramble about stuff, just like I used to do in Gibberish, but with some nice advantages:
\nWhat I find fascinating is how this turned into a lightweight note-taking system. I write posts for myself, bookmark them, and can easily go back to review my thoughts. It\u2019s like a poor man\u2019s Zettelkasten, but the thread format adds this natural, conversational flow to my thinking process.
\nThe best part? Mona\u2019s sliding pane UI feels like it was accidentally designed for this kind of short-form note-taking. The way you can slide between connected thoughts makes it natural to build on ideas. I treat my posts as append-only \u2013 while I could edit them, I choose not to. Instead, I add new posts to clarify or expand on my thoughts. This self-imposed constraint helps in capturing the evolution of ideas.
\nI\u2019m finding myself using Mastodon more and more for drafting ideas, alongside Gibberish. Not what I expected when I set up my instance, but it\u2019s becoming a nice addition to my workflow.
\nCES: We made a tablet that you can fold up like paper.
\nMe: Ohh cool, when can I buy it?
\nCES: What do you mean? ![\"\ud83e\udd28\"](\"https://s.w.org/images/core/emoji/15.0.3/72x72/1f928.png\")
Wow, my new “Edit in MarsEdit” button and the corresponding shortcut are such a quality-of-life improvement in my blogging workflow.
\n\n\n
\nI always forgot that I have a global shortcut for microposting using MarsEdit. Although I’m not sure about what defaults it is using for the new post.
\nLooks like 37signals is building a new editor called House (MD). The code is already available in the Writebook project which I haven\u2019t tried yet.
\nThis new editor is based on Markdown, which I like, since their current Trix editor is WYSIWYG, although it works pretty well in my experience.
\nI still use Drafts and am not planning to switch, but in recent years, I’ve seen a couple of nice quick-capture app alternatives pop up. Since I just stumbled upon\u00a0the new version of Funnel, I thought I would share some quick thought-capture apps.
\nI ran into this post the other day about Script Debugger getting retired.
\n\nJanuary 2025 marks Script Debugger\u2019s 30th anniversary. It\u2019s been a very long run for a two-person effort. Script Debugger began as a Classic MacOS product, survived Apple\u2019s near-death experience, transitioned to macOS X and migrated across 4 CPU processor types. We are so grateful for the support we\u2019ve received over these years. This support allowed us to keep working on Script Debugger much longer than we ever imagined.
\n
\nShane and I are retiring and the effort and costs associated with continuing Script Debugger\u2019s development are too great for us to bear any longer.
\n
I bought this app about 2-3 years ago because I was getting serious about learning AppleScript, and in a short amount of time, it became an important part of my workflow. As I mentioned, I learned AppleScript with the help of Script Debugger\u2019s awesome live inspection feature.
\nSince then, I have used this app to build many scripts that I use in my everyday workflow.
\nI don\u2019t know the current state of AppleScript inside Apple, but I know that the difference between Script Debugger and Script Editor is night and day. Script Debugger should be part of the system, which is why I feel sad that another great Mac app, especially one with such a long history, is getting retired.
\n\nIn June 2025, Script Debugger will no longer be offered for sale and all support and maintenance will cease.
\n
\nAt this time, Script Debugger will become a free download. Links to all versions of Script Debugger back to 5.0 will be posted, along with registration numbers that can be used to activate the software. These free versions of Script Debugger will be provided as-is and without any maintenance or support.
\n
Currently, the developers plan to leave it as is. The problem with this approach is that any future macOS update could break Script Debugger. It\u2019s not like 1Password 7, which, after years, I still keep around because I\u2019m not going to migrate to their stupid Electron app. Script Debugger is a complex beast, so any new Windows Vista-style \u201csecurity\u201d dialog could kill it in an upcoming version. And boy, Apple has been really into \u201cCancel or Allow\u201d lately.
\n\nWill Script Debugger become an open-source project? No. Unfortunately, there are portions of the Script Debugger source code we do not have the right to release.
\n
I\u2019m not sure how the app could be saved. I created a topic on MPU to let people know about it. Open-sourcing will not work since there are licensing issues, so the last resort is for someone to buy it. Or maybe some people in the Macscripter.net community could take care of it as Late Night Software \u201ccontractors.\u201d
\nI don\u2019t know yet, but it\u2019ll be pretty sad the day when Script Debugger stops working.
\nJust an aside: it makes me wonder why we have Emacs and Vim still around alive and well\u2026
\nI subscribed to Gibberish again. It’s a pretty simple app with a weird idea: you can write blog posts by typing out your thoughts in a text messaging-style UI. Each message represents a paragraph.
\nWhy that\u2019s great? The messaging UI somehow triggers me to spit ideas into a chat thread, which I can revise later. Well, the \u201crevise later\u201d part is not the strongest suit of Gibberish, but creating the first draft is the best I found for me.
\nI just love this chat UI for capturing ideas. It\u2019s not coincidental that people text themselves a lot. Also, it just makes sense how the app calls drafts \u201cthoughts\u201d and published stuff \u201cposts.\u201d I love small touches like this.
\nThough these are not posts, and I\u2019m not writing a blog here, since I have to publish a post to get the \u201cCopy Post Text\u201d menu working, I figured, why the hell not? I\u2019m not going to share the URL of my Gibberish \u201cblog\u201d since it is just a side effect of using the app \u201cwrong,\u201d but because I love this way of drafting things, I\u2019m going to keep it around. I don\u2019t care if people find it.
\n![](\"https://decoding.io/wp-content/uploads/2025/01/screenshot-2025-01-05-at-23.53.21.jpg-1-1.png\")
Since I\u2019m using the app just kinda right (I don\u2019t care about the blogging part), I wish it was just a private thing that syncs over iCloud (or whatever) with better support for exporting my \u201cthoughts\u201d into other apps like Drafts. As mentioned, I only publish my posts there to get the \u201cCopy Text\u201d option working.
\nSo, essentially, I just want an app that I can use to ramble about stuff and then export to revise the content somewhere else. Gibberish would be an awesome app for collecting thoughts without having a blog behind it.
\nNice, I can have a custom Bluesky handle using my own domain. Updated the links on my blog to @zsolt.decoding.io.
\nAfter years of focusing on my blog and staying off social platforms like Mastodon and Bluesky, I\u2019ve decided to set up profiles there. Why now? Here\u2019s what\u2019s changed.
\nI\u2019ve mostly set up Mastodon and Bluesky profiles to publish my posts to social media platforms. This could also be a way to have conversations around my content. I might occasionally post short status updates, but the main way I\u2019ll share ideas will continue to be through my blog.
\nI also want to try out new iOS apps like Ivory, Croissant, and Reeder which are integrating with these services.
\nIf you\u2019d like to follow along, here are my profiles:
\nFeel free to follow me, say hi or share something interesting.
\nThe blog will remain my main hub for new posts, which are also shared to Mastodon and Bluesky via Micro.blog and replies to these posts should appear as comments here on the blog too.
\nWell, I was reading Simon Willison\u2019s post about his blogging process, and I realized that I often write about weird ideas, thoughts, and things I discover online, but I usually keep them in a private journal.
\nSome of these things are available publicly on my Zettelkasten as notes or annotations, but not here. I think I\u2019m going to change this habit.
\nWhile I don\u2019t always have interesting content to blog about, I shouldn\u2019t keep these thoughts to myself either. Most of these ideas are just ramblings, but if you visit any blog or social media platform, you\u2019ll realize that it\u2019s mostly people rambling about random stuff.
\nOn the other hand, you can find interesting sparks for ideas, peculiar thought chains, workflow tips, and bits and pieces that I actually enjoy more than coherent and lengthy blog posts.
\nSo, I\u2019m going to publish more of these fragmented ideas that I\u2019ve kept private until now.
\nI used Strflow today with OmniFocus, which is pretty good for an interstitial journal. I can quickly bring it up and leave a status update about projects. It is handy when making a phone call and logging what we discussed.
\nI made two shortcuts, which work on the selected action\u2019s project:
\nI created a journaling shortcut for OmniFocus a couple of months ago, but it is built on top of DEVONthink. It doesn\u2019t automatically get the project, and storing these entries in DEVONthink will make my status updates get mixed with project-related assets, which I don\u2019t like.
\nBy the way, I can also add pictures to Strflow entries, which is kind of hard to do in DEVONthink.
\nI used to do interstitial journaling in TaskPaper, and I\u2019m not sure yet if Strflow is better or worse than TaskPaper, but at least it is available on iOS, too.
\nThese days, I\u2019m using TaskPaper for \u201cbrainstorming,\u201d not journaling. TaskPaper is a pretty cool outliner, so I can quickly create session notes related to the selected OmniFocus action. But these are just fleeting notes\u2026 I\u2019m using TaskPaper as a temporary thinking tool.
\nI can also share Strflow notes with other apps, like Day One, or add them to Drafts, where I can process and export them to other places, transforming Drafts into a tool that migrates text-based information between apps.
\nAlso, I like how the Strflow timeline was made to look like a chat app. In a way, it feels like the old Twitter feed, where we posted random thoughts to get them out of our heads. It is a private version of that.
\nMaybe I should try Setapp. My Hookmark subscription is expiring soon, and it would be cheaper to use Setapp than just trying to subscribe to Hookmark directly.
\nFrom a UX point of view, Hookmark has this weird and confusing licensing behavior. I have to pick a specific license file, which I always mix up, and I don’t know… It’s just confusing…
\nI assume on Setapp, it works as long as I pay for the subscription.
\nI would also have access to Ulysses, since it is also available on Setapp.
\nI’m unsure how Setapp works on iOS, though. I should look into that.
\nA few years ago, I found a hidden video series about how David Allen does GTD. I instantly downloaded it and merged it into one video.
\nWhile browsing today on YouTube, I stumbled upon two existing videos from this series that are still available. The rest are removed or marked as private, I don\u2019t know\u2026 Edit: actually I checked the video and these in fact are the same ones. But I wanted to share them because they are pretty interesting.
Luckily, I saved the full video, although I can\u2019t share it here. If you are interested, maybe you can ping me via email. Otherwise, I embedded the two existing videos here as an introduction.
I looked into how Tailscale works behind the scenes, but I’m still not sure I need a 3rd-party tool to create a virtual network for my devices. There are a couple of cool uses of a network like this, like syncing DEVONthink and OmniFocus over WebDAV using my Mac mini. Still, I also have an Apple Watch, which doesn’t seem to work with Tailscale, so I can’t sync OmniFocus with my Mac mini there like I originally planned.
\nInitially, I was looking for something that could give me access to my Mac mini outside of my network to get to my file archive stored on my external drives connected to my Mac mini. But giving it a second thought, there is a good reason we have the distinction between Cold Storage and Active Storage.
\nFor me, Active Storage is iCloud Drive, which is synced to all my devices. Cold Storage is not something that I should have access to all the time (not to mention ransomware and other dangers). So, from a security point of view, it’s a good thing that I have a local Mac server and a remote Linux server used for different things. Each of them requires a different level of security, and Tailscale merges them all into one network, which I’m not sure I’m comfortable with.
\nI’m thinking about shelving this whole idea of reaching my Mac mini server outside of my network and making a distinction between private networks and public networks. A public network means it should be available anywhere, but it should be end-to-end encrypted. This is what DEVONthink and OmniFocus do: each uses my WebDAV server running on my public server as a syncing backend, but these apps store data encrypted.
\nOn the other hand, my private network should be guarded, and data stored there should have a good 3–2–1 backup plan instead.
\nSo, instead of using the network as a transport layer to access my file archive, I’m thinking about using an external drive to bring a copy of my archive with me when I’m away.
\nI\u2019m playing around with Tailscale, but I\u2019m not sure about the privacy aspect of being on a VPN all the time. I want to sync DEVONthink and OmniFocus using a WebDAV server on my Mac mini, but running Tailscale 24/7 raises some questions.
\nI love the idea of having my private network of devices available everywhere. But I don\u2019t trust random companies with my data, so I want to do my research before I start to use Tailscale with all my devices.
\nI write a lot every day, but I don’t publish a lot of it since I have this fear of being judged. But I have a lot of ideas and thoughts that can be boring for some people but maybe interesting for others.
\nI ramble about tools and workflows in Day One and my Zettelkasten. Those are private posts that are not necessarily useful to anyone, but I want to publish them anyway because I can see a history of my thoughts, which can give someone else an idea.
\nThat’s what #DigitalGarden is about, but it is still different. Sometimes, I want to write a journal entry and be done with it. I don’t need a full-fledged Zettelkasten all the time.
\nActually, I’m afraid of publishing these ideas, but as we have had success with open-source software in the last couple of decades, maybe open-source thinking can be a helpful thing to master, too.
\nWhat do I mean by that? Blogposts without much crafting and maybe even with a lot of grammar errors, but the idea is that I can write about something, then continue thinking about that idea in a new post, and so on. Maybe I’ll run into a conclusion and come up with something cool or ignore the whole thing at the end, but the critical point here is that I should flex my writing more, and my blog is still the best place for that.
\nInspired by More people should write
\nAfter the latest “iPad can’t do shit” meme popping up in the Apple community, I just unsubscribed from a bunch of Apple pundits.
\nI’m just tired of this negativity towards the iPad from people who sometimes have no idea how the device actually works or what it is capable of.
\nIf you want to get into the arguments, just read posts on Beardy Guy Musings with Denny’s awesome Macalope style reactions.
\nI’m not saying that having criticism toward a device is wrong. We should criticize something if it has issues.
\nBut because it works differently than the other device, or simply not knowing something then whining about it just for the sake of it is just trolling attitude at this point.
\nAs I said, I’m just ignoring these people at this point.
\nThe new version of the ActivityPub WordPress plugin lets me reply to comments coming from Mastodon and federate them back as standard replies. I just wanted to install an instance this morning to have a profile that I can use to reply to incoming comments, but this one is way better.
\nAgain, you can follow me on Mastodon by searching for my profile (zsbenke@decoding.io) from your instance.
\nI’m very disappointed after reading comments on this article: How Twitter\u2019s descent into chaos is paving the way for a new web
\nI don’t want to see this divided mentality (especially politics) under articles that are talking about cool indie projects. The mainstream web has gotten into a state where people just inject politics into everything. If I want to have a place that I like, I have to build my part of the web.
\nA Zettelkasten and a blog can help with that. I can make my blog cozy, write about what I like, and then browse that from time to time to rediscover things.
\nI can safely say that Emacs (with Org mode) is my new PKM app. It is really good (and I’m telling you as someone who loves Vim).
\nI started to mess around with Org mode about a week ago.
\nOrg mode is just an awesome way of organizing information and actually do something with it.
\nI added Hookmark integration for Org mode based on these scripts.
\nVideo \u2192 Using Emacs with Hookmark
\nI’m still going to use Vim for web development, but Emacs is my thinking space now (my home-grown Roam if you will).
\nOf course I’m using Evil mode in Emacs.
\nI don’t have time to learn a new way of editing text currently.
\nI\u2019m writing emails to myself. Seems like\nother people do this as well. It is yet another way of journaling, but I email is special since it\u2019s open, and I can never change it again (I mean I can change it, but you get the idea).
\nI just discovered that both Emacs and Vim nicely wrap text in a message-mode / mail file type. This is cool since properly formatted plain-text emails are a treat these days. On top of messing around with Org Mode, I\u2019m playing around with the idea of using Emacs for sending emails to myself. It has a bunch of macOS services built around creating new messages, so starting one from LaunchBar is easy. Emacs will open a new buffer and I can start writing a plain-text email. Then I can send the message over to Apple Mail with the keyboard shortcut of C-c C-c.
So why do I want to send letters to myself?
\nWell, it is a way to write about something interesting to me at the moment. Since both Emacs and Vim wrap the line as I write, it is a bit hard to edit these messages afterward, so I\u2019ll think a bit more about how I say things. This is a benefit since it slows me down.
\nEmailing myself is a way to reflect on things. It is a journal entry basically, and I have Day One for that, but I still like the aspect of sending something somewhere. I have feeling being done with it, so I don\u2019t have to deal with it anymore. I just like getting thoughts and feelings out of my head, and sending it to myself to park it later. If an email is sent, it can\u2019t be changed anymore.
\nAfter sending these emails, they reappear in my inbox, where I can just read them again, then move them to a folder called \u201cLetters to Myself\u201d. After a while, I\u2019ll have a bunch of cool letters that my past me sent to the future me.
\nI should read more about this habit\u2026
\nI guess I love them both now.
\n![\"\"](\"https://decoding.io/wp-content/uploads/2024/01/Screenshot-2024-01-19-at-20.54.13.png\" "\\"Screenshot")
A couple of months ago I started to use Messages for talking to myself.
\nWhy do I want to do that?
\nWhen I want to figure something out, I noticed that the best way to do it is to start writing in freeform text.
\nIt feels like talking to myself, which helps me to externalize my ideas, and find solutions quickly to problems. It’s like a pre-thinking phase for capturing ideas in a timeline format, then organizing them later in a mindmap or an outline.
\nSlack has a similar idea of why you should start to message yourself. When you open your profile and press the Direct Message button, the following message appears on the top.
\nThis is your space. Draft messages, list your to-dos, or keep links and files handy. You can also talk to yourself here, but please bear in mind you\u2019ll have to supply both sides of the conversation.
\nOthers also wrote about this idea in more detail. It is the modern version of emailing ourselves.
\n\nMessages is actually a pretty cool candidate for this workflow. It is available on all my devices, I can pin messages for reviewing them later, and it is still the best way to share information between my devices when AirDrop and Handoff farts themselves.
\nHow to set it up?
\nTexting with ourselves in Messages is a bit weird since every message will be sent back in the same thread duplicating everything. We can avoid that by registering a new iCloud account and sending messages to there.
\nI have a sparse iCloud sandbox account which I use for testing. I logged in from my old MacBook Air, then I started to write thoughts for myself over iMessage.
\nWe have to log into a separate iCloud account at least once, otherwise, Messages won’t pick up the account as a proper recipient.
\nThis is yet another version of the capture step in GTD
\nThis idea was cool, but for me it quickly fell apart. People get the idea of writing stuff down, but they forget that it needs to be processed later.
\nWhen I had to pull out data from Messages, it was hard to mark my processed position in the timeline.
\nI started to use a marker message by typing 5 equal signs which is similar to how I mark my processed position in my notebook using a double line.
\nThis is a very important note about something.
====== \u2190 This is my “processed” bookmark. Anything above this line is processed and I don’t need to see it again.
My Notebook System (part 3): Field Notes Pocket Notebook \u2013 Decoding
\nWhen I process, I usually reference information between apps, which means that I like to link to the source or at least copy the text out into a place that I can link to.
\nThere is a hidden URL scheme in Messages, but it is really hard to link to messages.
\nsms://open?message-guid=UUID
If there is a data detector visible in your message (like the text of “tomorrow 9:00am”), Messages will underline it, and you can create a new event or a reminder by clicking on it. Creating a new reminder will also add the link to the message which you can copy.
\nGetting links or text out of Messages is actually bit convoluted.
\nStrflow, an actual app made for texting yourself
\nI just found a unique new app today called Strflow, which mixes note-taking with a messaging interface. It works exactly like I wanted to use Messages.
\nWhy it is better than Messages?
\nThere is a “Copy Note Link” command for every note.
\nNotes can be edited after they are created.
\nThere is a minimal Markdown-like syntax available, which lets me have the right amount of formatting for quick notes like these.
\nI love unique apps like this one \u2013 that’s one the reasons I love the Mac, since you can always find interesting tools like this \u2013 although it still has some missing pieces.
\niOS version (the developer mentioned that he’s working on it).
\nSpotlight integration: it just feels right to index and search snippets of information in Spotlight.
\nBetter export: we get a JSON file on export, but since the app uses Markdown for formatting, why not export proper Markdown notes?
\nIt would be even better if I could define a date range for exporting, so processing information can be done outside of Strflow.
\nAlthough there are unique links for each note, getting them is a bit hard. I have to \u2303Click and choose the “Copy Link to Note” command from the context menu which is not available in the app’s menubar.
strflow://show-note?id=UUID
Selecting notes can be done using the trackpad, but having keyboard shortcuts for navigating up and down would be useful to select one or multiple notes.
\nRelated to the previous issue, I could use UI scripting and Hookmark to get the currently selected notes’ URL.
\nSo what am I using Strflow for?
\nAs I mentioned, I mostly use this app for talking with myself to figure out something by writing.
\nI started the draft of this post there.
\nI saved couple of links which I want to revisit later.
\nIt is like a private version of Mastodon.
\nIt is going to be another inbox/journal/status update tool next to my interstitial journal in TaskPaper.
\n\n