Posts – Decoding

2025.08.26.

Solving Token Waste with Claude Code Personas

The 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?

Creating Focused Personas

Instead of one bloated agent trying to do everything, I created three specialized personas:

Main 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.

The implementation lives in my dotfiles as simple shell functions:

# Main persona - clean and fast
cc() {
  claude ${*} --dangerously-skip-permissions
}

# Research persona with specialized tools
ccr() {
  claude ${*} --dangerously-skip-permissions \
    --model opus \
    --mcp-config ~/.claude/mcp-research.json \
    --append-system-prompt "You are a code research and analysis specialist \
focused on deep technical investigation, multi-model reasoning, and \
comprehensive code review. Your expertise includes security auditing, \
architecture analysis, debugging complex issues, and researching best \
practices across codebases. You leverage multiple AI models for consensus \
building, use Context7 to fetch up-to-date library documentation, analyze \
GitHub repositories for patterns with Octocode, and generate thorough \
technical documentation."
}

# GTD persona with productivity tools
ccg() {
  claude ${*} --dangerously-skip-permissions \
    --model opus \
    --mcp-config ~/.claude/mcp-gtd.json \
    --append-system-prompt "You are a GTD specialist orchestrating a \
multi-layered knowledge system where OmniFocus drives project execution, \
Obsidian captures notes and knowledge, and DEVONthink archives reference \
materials. You excel at processing inboxes across all three systems, \
organizing projects with proper next actions, capturing meeting notes \
with task extraction, and maintaining a trusted system for all personal \
and professional information. Your expertise includes creating bidirectional \
links between systems using Hook and maintaining clear separation between \
active project work and archived reference materials."
}

Each 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 Delegation Pattern

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.

When 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.

The delegation always runs in the background using the Bash tool:

// How the main persona actually delegates
Bash({
  command: 'ccr -p "Analyze this Rails controller for N+1 queries and performance issues"',
  description: "Ask research persona to analyze Rails performance",
  run_in_background: true
})

This pattern works both ways. I can also delegate GTD tasks with a simple OmniFocus link:

# Ask GTD persona for comprehensive project review
ccg -p "/gtd:project-review omnifocus:///task/jP9S4CFgPin"

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.

The 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.

What Changed

The 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.

2025.07.17.

Pezeta Progress Log

Spent today designing the Rails controller layer for Pezeta.

I analyzed Capito, an envelope budgeting prototype I built seven years ago. Standard approach – 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.

For the controller architecture I designed five main tasks:

Authentication & Ledger Foundation – 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.

Budget Controller – 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.

Categories Controller – Standard CRUD for user-defined categories. Goals are implemented as special categories with allocation rules that determine how they get funded each month.

Monthly Allocations – This is where goal-driven allocations get applied, but users can override them when needed.

Test Infrastructure – Rails conventions with fixtures that include the system categories.

I’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.

This foundation should make the goal system feel automatic rather than manual.

2025.07.15.

Pezeta Progress Log: Day 9

I 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.

I’ve laid the foundation for four distinct goal types:

Someday Goals – For big purchases. Save until you hit your target amount, then stop allocating.
Monthly Goals – For recurring commitments. Allocate a fixed amount every month, like subscriptions or regular savings habits.
Deadline Goals – For time-bound expenses. Spread the target amount evenly across the remaining months until your due date.
Reserve Goals – For emergency funds. Maintain a buffer of N months of average expenses based on your actual spending patterns.

I 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.

Next 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.

2025.07.13.

On Deleting Second Brains

Joan Westenberg:

Two nights ago, I deleted everything.

Every note in Obsidian. Every half-baked atomic thought, every Zettelkasten slip, every carefully linked concept map. I deleted every Apple Note I’d synced since 2015. Every quote I’d ever highlighted. Every to-do list from every productivity system I’d ever borrowed, broken, or bastardized. Gone. Erased in seconds.

What followed: Relief.

Sometimes it’s good to delete things, but a second brain isn’t 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.

The problem with output is that we often don’t know what it will look like when we start. What a Zettelkasten (and GTD too) acknowledges is that you’ll have an outcome of some kind and you need a framework to manage it. That’s all.

People 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’s fast.

But as soon as I’m working on anything that requires more thinking capacity than I currently have, I reach for PKMs and task managers to handle it.

I usually split my long-term project-specific Zettelkastens off from my main one, though.

Previously:

2025.07.11.

Pezeta Progress Log: Day 5

Today 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.

The 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.

The 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.

Planning Through Test Cases

The bulk of the work went into defining test specifications:

7 test cases for SomedayGoal
15 for MonthlyGoal (including top-up logic)
17 for DeadlineGoal (with auto-advance scenarios)
17 for ReserveGoal

Each 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.

All 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.

The 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.

Tomorrow I’m letting Claude Code implement these tasks.

2025.07.10.

Pezeta Progress Log: Day 4

Had 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.

I expanded all four goal types with detailed logic and edge cases:

Someday goals are your classic piggy bank. You want $3,000 for a new laptop someday. The system suggests funding it until you hit that target, then stops.
- Edge case: what happens if you change the target from $3,000 to $4,000? Only future months use the new target.
Monthly goals keep a set amount available each month. You want $200 available for groceries each month. If you spend $150, you need $50 to top back up. If you somehow end up with $300, that’s fine – surplus is allowed.
- Edge case: what happens if you never spend anything? The surplus just sits there – no more funding needed.
Deadline goals add time pressure. $2,000 for a vacation by next summer. The system calculates: you need $200 per month to hit that target.
- Edge case: what happens if you miss a month? The next month’s allocation jumps to catch up.
Reserve goals are your safety nets. Keep at least $2,000 in emergency savings. If it dips to $1,500, fund $500 immediately.
- Edge case: what happens if you never touch it? No allocation needed – it’s already above the reserve.

So 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.

The 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?

I 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.

2025.07.09.

Pezeta Progress Log: Day 3

Today 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.

The aggregation layer

The 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.

This is just pure Ruby class that takes the foundational models and presents them in a way that makes sense to users.

Goal allocation rules

The bigger breakthrough today was finalizing the goal allocation rules. This is what’ll set Pezeta apart from traditional envelope budgeting.

Instead of managing dozens of budget categories, users define their financial goals—things 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.

I want to implement four goal types:

Someday: Save for something with no deadline—like a new laptop or vacation fund. Allocates the difference between target and current balance until you hit the goal.
Monthly: Keep a certain amount available each month—like rent or groceries. Tops up to the monthly amount, and any surplus stays there.
Deadline: Gather a lump sum by a specific date—like saving $3000 for a trip by July. Calculates how much to save each month based on time remaining.
Reserve: Maintain a minimum balance at all times—like an emergency fund. Only allocates money when the balance dips below the reserve amount.

Each follows different allocation formulas, but the key insight is the engine just calculates expected allocations—it never moves money automatically. That stays under your control.

The vision coming together

I’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.

2025.07.08.

Pezeta Progress Log: Day 2

Day two of building Pezeta. Yesterday was all planning and starting. Today was about getting my hands dirty with actual Rails models.

Completed the three core models today:

Category 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’m spending about 1–2 hours a day to build this), but I want to get the models right, that’s the whole point of why I’m writing the first MVP in Rails, I know Rails the best.

I’m 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.

The workflow experiment

Here’s something weird I’m trying: I started a new zettelkasten in Obsidian yesterday to drive this whole project.

The 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.

I’m using a modified version of Ian Nuttal’s 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’m still reviewing everything.

My 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.

We’ll see if this scales. but for now, it’s working.

2025.07.07.

Starting Pezeta

Finally 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.

What’s Pezeta?

Simple: a budgeting app that tells you one number – how much you can spend right now.

That’s it.

No 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.

The features (keeping it minimal)

The One Number – Your daily spending limit. Updated in real-time. Factors in your bills, savings, everything.

Goals – Want to save $2000 by December? Cool. The app adjusts your daily number automatically. No spreadsheets required.

That’s basically it. If budgeting were simpler, maybe more people would actually do it.

Starting with Rails

I’m not jumping straight into building native apps. Starting with a Rails MVP instead.

Few reasons:

Rails 8 has some new stuff I want to try
Need a reference implementation anyway for the iOS/macOS versions
I can actually use it myself while building

This Rails version won’t go public. It’s just for me to validate the idea and work out the kinks.

Building in public (might regret this)

I’m putting it all out there because watching someone figure things out might be more useful than another perfect tutorial.

Partly for feedback – maybe someone will tell me this is a terrible idea before I waste six months on it.

Partly for accountability – harder to quit when people are watching.

Partly because I’m curious what happens when you share the messy process instead of just the polished result.

The plan

Starting with Rails 8 setup, basic models, authentication. The boring foundation stuff that nobody talks about but takes forever.

After that, we’ll see. Building software is weird.

2025.02.08.

Using tags to create threads in WordPress

Continuing 3380:

Maybe I should use tags as a thread title in a way that group posts together. I’m 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’s an example page for a thread.

It 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.

As an icing on the cake, a post could belong to multiple threads.

Continuing 3378:

If you visit the front page of my blog, you’ll notice that I organize posts by day, inspired by the daily notes feature from Roam Research.

I typically enjoy this wall of text style more than having separate posts highlighted individually (perhaps that’s why I like threading on Mastodon).

The 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.

Maybe I should create something that allows me to link posts together, with backlink support.

Previously:

I sometimes think we might need different ways to share ideas instead of long articles—it’s important to mention that I’m talking about ideas, not stories.

Looking 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’re correct.

I’m not sure what might happen if I started using formats closer to the raw idea then heavily edited posts.

Exploring Real-Time Voice-to-Text Transcription Options

I’ve 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—I’ve definitely experienced this.

So, I’m experimenting with various voice-based input options for my Mac (and possibly iOS/iPadOS as well).

I recently acquired VoicePen as a tool to take voice notes. It’s 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’s a decent tool, but it’s not designed for real-time voice input.

I looked at Inbox AI too, but it’s more of an automation app and I don’t want to invest time learning it right now. I’m sure it can do this.

Bolt.AI offers something different – it has an inline dictation feature. I’m currently trying out its dictation with chat assistants—being able to talk naturally to AIs instead of typing.

I’m also experimenting with macOS’s built-in dictation. It integrates well with text editing and shows what I’m typing in real-time. Sure, it sometimes types the wrong stuff, but these can be fixed quickly with the built-in writing tools.

I’m noticing there’s a difference between thinking out loud and just dictation—I’ll need more time to figure out what works best for each case. For now, I think each input method—typing, voice, even Apple Pencil—probably has its place. I’ll likely end up using a mix of them depending on what I’m trying to do.

2025.01.31.

How to clean a MacBook keyboard

After today’s 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.

Press and hold the left Control and Command buttons with right Shift button for a total of 7 seconds.

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.

For your next startup, your Mac can only be powered on by using the Power button or closing and opening the lid.

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.

Update: I tested this on an M3 MacBook Air too, and it didn’t work.

2025.01.24.

I’m just playing around with Muse for Mac, and I just found this picture in their macOS version announcement post.

Creative process.

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.

I’ll use this distinction between the different apps that I use for idea development.

Previously:

2025.01.19.

2025.01.16.

Using Mastodon’s threads for thinking out loud

A few days ago I wrote about getting back to Mastodon, and it’s 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’t anticipate.

Remember how I loved Gibberish’s chat-like UI for drafting ideas? Well, Mastodon’s 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:

Mastodon is completely open, so I can:
- Run my own instance
- Control my data
- Build whatever I want on top of it
The clients are surprisingly good
- Mona
  - Highly customizable
  - The sliding panes UI reminds me of the old Tweetie for iPad
  - Perfect for browsing through connected thoughts
- Ivory
  - Clean, focused interface, but I prefer Mona’s sliding pane UI

What 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’s like a poor man’s Zettelkasten, but the thread format adds this natural, conversational flow to my thinking process.

The best part? Mona’s 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 – 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.

I’m finding myself using Mastodon more and more for drafting ideas, alongside Gibberish. Not what I expected when I set up my instance, but it’s becoming a nice addition to my workflow.

2025.01.14.

CES: We made a tablet that you can fold up like paper.

Me: Ohh cool, when can I buy it?

CES: What do you mean? 🤨

2025.01.13.

Wow, my new “Edit in MarsEdit” button and the corresponding shortcut are such a quality-of-life improvement in my blogging workflow.

I 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.

Looks like 37signals is building a new editor called House (MD). The code is already available in the Writebook project which I haven’t tried yet.

This new editor is based on Markdown, which I like, since their current Trix editor is WYSIWYG, although it works pretty well in my experience.

2025.01.07.

Drafts alternatives

I 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 the new version of Funnel, I thought I would share some quick thought-capture apps.

Funnel

It captures text, transcribes voice, and even uses Shazam, which is pretty nice. Unfortunately, it is available only on iPhones.

Bebop

It is optimized for text file capturing, but it can be a pretty nice tool if you have a file-based system with The Archive. Again, iPhone only.

Capture

This seems to be the most interesting alternative to Drafts since it works on most Apple platforms (no Watch, though) and can capture stuff into a timeline-like format.

Retiring Script Debugger

I ran into this post the other day about Script Debugger getting retired.

January 2025 marks Script Debugger’s 30th anniversary. It’s been a very long run for a two-person effort. Script Debugger began as a Classic MacOS product, survived Apple’s near-death experience, transitioned to macOS X and migrated across 4 CPU processor types. We are so grateful for the support we’ve received over these years. This support allowed us to keep working on Script Debugger much longer than we ever imagined.

Shane and I are retiring and the effort and costs associated with continuing Script Debugger’s development are too great for us to bear any longer.

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’s awesome live inspection feature.

Since then, I have used this app to build many scripts that I use in my everyday workflow.

I don’t 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.

In June 2025, Script Debugger will no longer be offered for sale and all support and maintenance will cease.

At 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.

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’s not like 1Password 7, which, after years, I still keep around because I’m not going to migrate to their stupid Electron app. Script Debugger is a complex beast, so any new Windows Vista-style “security” dialog could kill it in an upcoming version. And boy, Apple has been really into “Cancel or Allow” lately.

Will 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.

I’m 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 “contractors.”

I don’t know yet, but it’ll be pretty sad the day when Script Debugger stops working.

Just an aside: it makes me wonder why we have Emacs and Vim still around alive and well…

2025.01.06.

I just love the Gibberish UI for drafting ideas

I 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.

Why that’s great? The messaging UI somehow triggers me to spit ideas into a chat thread, which I can revise later. Well, the “revise later” part is not the strongest suit of Gibberish, but creating the first draft is the best I found for me.

I just love this chat UI for capturing ideas. It’s not coincidental that people text themselves a lot. Also, it just makes sense how the app calls drafts “thoughts” and published stuff “posts.” I love small touches like this.

Though these are not posts, and I’m not writing a blog here, since I have to publish a post to get the “Copy Post Text” menu working, I figured, why the hell not? I’m not going to share the URL of my Gibberish “blog” since it is just a side effect of using the app “wrong,” but because I love this way of drafting things, I’m going to keep it around. I don’t care if people find it.

Since I’m using the app just kinda right (I don’t 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 “thoughts” into other apps like Drafts. As mentioned, I only publish my posts there to get the “Copy Text” option working.

So, 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.

2025.01.05.

Nice, I can have a custom Bluesky handle using my own domain. Updated the links on my blog to @zsolt.decoding.io.

2025.01.04.

Why do I have so many posts today?

Well, I was reading Simon Willison’s 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.

Some of these things are available publicly on my Zettelkasten as notes or annotations, but not here. I think I’m going to change this habit.

While I don’t always have interesting content to blog about, I shouldn’t keep these thoughts to myself either. Most of these ideas are just ramblings, but if you visit any blog or social media platform, you’ll realize that it’s mostly people rambling about random stuff.

On 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.

So, I’m going to publish more of these fragmented ideas that I’ve kept private until now.

2024.09.03.

Trying out Strflow for project-related status updates

I 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.

I made two shortcuts, which work on the selected action’s project:

Journal About Selected OmniFocus Project: ask for a quick status update, then it automatically tags the note with the project name converted to a hashtag.
Open Selected OmniFocus Project Timeline: opens the timeline based on the project name.

I created a journaling shortcut for OmniFocus a couple of months ago, but it is built on top of DEVONthink. It doesn’t automatically get the project, and storing these entries in DEVONthink will make my status updates get mixed with project-related assets, which I don’t like.

By the way, I can also add pictures to Strflow entries, which is kind of hard to do in DEVONthink.

I used to do interstitial journaling in TaskPaper, and I’m not sure yet if Strflow is better or worse than TaskPaper, but at least it is available on iOS, too.

These days, I’m using TaskPaper for “brainstorming,” 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… I’m using TaskPaper as a temporary thinking tool.

I 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.

Also, 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.

2024.09.01.

Maybe 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.

From 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…

I assume on Setapp, it works as long as I pay for the subscription.

I would also have access to Ulysses, since it is also available on Setapp.

I’m unsure how Setapp works on iOS, though. I should look into that.

Older