Pkm on ¬ just serendipity 🍀

pi: asynchronous exit summaries

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 27 Jul 2026 18:18:38 +0200

♠ Problem statement: ctrl+d in pi took several seconds to quit.

The culprit was pi-memory’s session_shutdown handler. It sent one last LLM request to summarize the session, wrote its answer to the daily log, then ran qmd update. Pi awaits all shutdown handlers, correctly, so quitting waited for everything:

pi.on("session_shutdown", async (event, ctx) => {
  const result = await generateExitSummary(ctx);
  fs.writeFileSync(filePath, entry, "utf-8");
  await runQmdUpdateNow();
});

Making that promise fire-and-forget would not work: Pi exits immediately after shutdown, and either the in-flight request keeps Node alive or gets killed before it can write anything.

Instead, I made the shutdown path write a durable job, synchronously:

const job: ExitSummaryJob = {
  version: 1,
  id: randomUUID(),
  createdAt: new Date().toISOString(),
  date: todayStr(),
  reason,
  sessionId: shortSessionId(ctx.sessionManager.getSessionId()),
  conversationText: truncated.text,
  truncated: truncated.truncated,
  totalChars: truncated.totalChars,
};

const jobPath = path.join(
  EXIT_SUMMARY_JOBS_DIR,
  `${job.createdAt.replace(/[:.]/g, "-")}-${job.id}.json`,
);
fs.writeFileSync(jobPath, `${JSON.stringify(job)}\n`, { encoding: "utf-8", flag: "wx" });

The next interactive session starts an unref’ed worker. It atomically renames one job to claim it, generates summary with active model, writes it back to original day’s daily log, and deletes job. Failed jobs return to queue. A stale claimed job retries after ten minutes.

I kept upstream package intact by replacing it with a local package, effectively forking it:

% pi remove npm:pi-memory
Removed npm:pi-memory
% pi install ~/.pi/agent/local/pi-memory-async
Installed /Users/thiago.perrotta/.pi/agent/local/pi-memory-async
% pi list
User packages:
  local/pi-memory-async
    /Users/thiago.perrotta/.pi/agent/local/pi-memory-async

Jobs live in ~/.pi/agent/memory/exit-summary-jobs/. ctrl+d only writes one JSON file now; summary happens during next session, without blocking exits.

Source code: pi-memory-async.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pkm

Anki: archive a deck

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 27 Jul 2026 10:49:00 +0200

♠ Previously.

The Anki official docs do not provide explicit instructions about the archival of decks that are no longer needed.

Archiving is better than deleting because you never know when you may need a deck again.

One way to archive a deck is to simply export it as a backup and save it elsewhere. But then you collection becomes scattered. I’d really like to manage all my decks in a single place.

So I came up with a simple workaround.

First, create an Archive:: subdeck. A subdeck creates a parent-child relationship which, for our purposes, bundles all archived decks within an umbrella parent. It’s visually easier to manage and organize, effectively hiding archived decks from the deck list view.

Second, move the desired deck(s) within Archive::.

Third, one by one, open the cards/notes list (“Browse”) of a deck, select all cards/notes (Cmd-A), then suspend them all (Cmd-J or right click, “Toggle suspend”).

Side effect: cards/notes from the deck will no longer show up for review. At the same time, your past progress is kept, should you ever want to unarchive them.

— § —

Reply via email

#dev #pkm

obsidian: type * for a bullet point, not ** bold

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 24 Jul 2026 10:04:46 +0200

♠ Problem statement: in Obsidian, out-of-the-box, typing * at the start of a new line emits *|* (an empty bold pair, cursor in the middle) instead of starting a bullet point.

The culprit is Settings → Editor → Auto pair Markdown syntax. With it on, every * auto-inserts its closing *, so a * followed by a space never gets the chance to become a list marker. In fact, we get a bullet point followed by a plain *, which we then have to delete.

To turn this setting off: set Settings → Editor → Auto pair Markdown syntax to off.

Now: * followed by a space at the start of a line converts it to a bullet¹, exactly like - does.

Surely inserting bullet points in Obsidian is a muscle memory artifact from migrating from LogSeq. ↩︎

— § —

Reply via email

#dev #pkm

★ logseq → obsidian

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 20 Jul 2026 18:26:33 +0200

♠ Previously.

Problem statement: LogSeq v2 is moving its graph format from markdown files to a sqlite database:

This is not OK for my workflow.

The whole point of adopting LogSeq was, just like Obsidian, the promise of managing my notes in plain markdown files.

Even though this migration is supposed to improve the performance of the app, it ends up breaking a fundamental reason why I decided to use it in the first place.

Furthermore, the Second Brain app of my choice is supposed to be boring. It is a big deal to wake up one day and find that I can no longer open my notes graph with the new version of the app. This is a no-go.

Well, classic LogSeq (dubbed “Logseq OG”) will be kept around, but I can only assume that from this point on it will become poorly maintained — it will never get the same amount of resources and attention as the new version.

Also, even if I really wanted to use the new version, it turns out it does not work on mobile (iOS), which is a dealbreaker, therefore I would be forced to stay stuck with OG for a while. Heck, the iOS app hasn’t been updated in 2y anyway, and it shows.

There will be no hard feelings, this is a peaceful breakup; I enjoyed LogSeq, it’s simpler and more streamlined than Obsidian; as such, I will keep recommending it to most people.

That said, I’ve always been pondering whether to switch back to Obsidian. There’s no doubt that Obsidian is more actively maintained and better suited for Gen AI / LLM workflows these days (see Obsidian CLI for starters).

Why did I switch to LogSeq from Obsidian in the first place? Because Obsidian was too much for me. It was more complicated (in terms of its feature set) than warranted for my purposes. It offered more than I needed. That’s not necessarily a bad thing. It’s like saying (hypothetically) “I prefer nano instead of vim”, or that I prefer to live in a studio apartment than in a 3-bedroom house.

Obsidian won’t let me down in terms of changing its file format: file over app is one of their core promises:

File over app is a philosophy: if you want to create digital artifacts that last, they must be files you can control, in formats that are easy to retrieve and read. Use tools that give you this freedom.

File over app is an appeal to tool makers: accept that all software is ephemeral, and give people ownership over their data.

This is very important. My Second Brain app must not lock me in. LogSeq, upon the switch to a sqlite database, breaks this invariant. I want — I need — boring markdown files. Do not break the beauty and simplicity of this setup.

Migration #

LogSeq and Obsidian are similar but not identical.

In order to bridge the gap, a small python script (drafted by Claude Fable 5, reviewed by me) walked the existing LogSeq Graph and wrote to a fresh Obsidian Vault, leaving the source untouched, should I decide to roll back.

These are some mappings (LogSeq → Obsidian):

journals/2024_03_04.md         ->  journals/2024-03-04.md
pages/Foo___Bar.md             ->  Foo/Bar.md          (namespaces)
- TODO buy milk                ->  - [ ] buy milk
- DOING ...                    ->  - [/] ...
- DONE ...                     ->  - [x] ...
[[Feb 9th, 2026]]              ->  [[2026-02-09]]
((67ea7dba-3200-...))          ->  [[2025-03-31#^67ea7dba]]
{{embed ((67ea7dba-3200-...))}} -> ![[2025-03-31#^67ea7dba]]
{{video https://...}}          ->  plain URL
id:: 67ea7dba-3200-...         ->  ^67ea7dba block anchor (when referenced)
collapsed:: true, :LOGBOOK:    ->  dropped

Plus one line of config so that the LogSeq journals become Obsidian daily notes:

{
    "folder": "journals",
    "format": "YYYY-MM-DD"
}

…and then I spent some time trying to dumb down Obsidian, disabling core plug-ins I do not need at this time. There’s no need for community plug-ins for now (if ever).

So far, I only migrated my corp (work) notes. I’ll need to migrate my personal PKM as well, but I am happy to simply pilot this migration at work first, so that I don’t get to regret twice.

The migration script:

#!/usr/bin/env python3
"""Migrate LogSeq graph -> Obsidian vault. Source is never modified."""
import re
import shutil
from pathlib import Path

SRC = Path("/Users/thiago.perrotta/Library/Mobile Documents/iCloud~com~logseq~logseq/{redacted}")
DST = Path("/Users/thiago.perrotta/Library/Mobile Documents/iCloud~md~obsidian/{redacted}")

UUID = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
MONTHS = {m: i + 1 for i, m in enumerate(
    ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"])}

MARKER_MAP = {
    "TODO": "[ ]", "LATER": "[ ]", "WAITING": "[ ]",
    "DOING": "[/]", "NOW": "[/]", "IN-PROGRESS": "[/]",
    "DONE": "[x]",
    "CANCELED": "[-]", "CANCELLED": "[-]",
}


def journal_name(stem: str) -> str:
    return stem.replace("_", "-")


def dest_rel(src_file: Path) -> Path:
    """Map a source md file to its vault-relative destination path."""
    if src_file.parent.name == "journals":
        return Path("journals") / (journal_name(src_file.stem) + ".md")
    # namespace pages: A___B.md -> A/B.md; everything else under pages/
    parts = src_file.stem.split("___")
    return Path(*parts[:-1]) / (parts[-1] + ".md") if len(parts) > 1 else Path("pages") / src_file.name


def page_ref(src_file: Path) -> str:
    """Wiki-link target for a source file (what goes inside [[...]])."""
    if src_file.parent.name == "journals":
        return journal_name(src_file.stem)
    return "/".join(src_file.stem.split("___"))


def collect_ids():
    """uuid -> (link target, anchor) for every id:: definition; also which uuids are referenced."""
    defined, referenced = {}, set()
    for f in sorted(SRC.glob("pages/*.md")) + sorted(SRC.glob("journals/*.md")):
        text = f.read_text(encoding="utf-8")
        for m in re.finditer(rf"^\s*id:: ({UUID})\s*$", text, re.M):
            defined[m.group(1)] = (page_ref(f), m.group(1)[:8])
        for m in re.finditer(rf"\(\(({UUID})\)\)", text):
            referenced.add(m.group(1))
    return defined, referenced


def convert(text: str, defined, referenced) -> str:
    lines = text.split("\n")
    out = []
    in_fence = False
    in_logbook = False

    def resolve_ref(m):
        uuid = m.group(1)
        if uuid in defined:
            target, anchor = defined[uuid]
            return f"[[{target}#^{anchor}]]"
        return m.group(0)

    def resolve_embed(m):
        uuid = m.group(1)
        if uuid in defined:
            target, anchor = defined[uuid]
            return f"![[{target}#^{anchor}]]"
        return m.group(0)

    def date_link(m):
        mon, day, year = m.group(1), int(m.group(2)), int(m.group(4))
        return f"[[{year:04d}-{MONTHS[mon]:02d}-{day:02d}]]"

    pending_merge_indent = None  # indent of an empty bullet awaiting its continuation line

    for line in lines:
        stripped = line.strip()

        # merge continuation text into a bullet whose first line was a property
        if pending_merge_indent is not None:
            m = re.match(rf"^{re.escape(pending_merge_indent)}\s\s?(\S.*)$", line)
            pending_merge_indent = None
            if m and out:
                out[-1] = out[-1] + m.group(1)
                continue

        # LogSeq opens fences on bullet lines ("- ```lang"), closes with bare "```"
        if re.match(r"^\s*(?:[-*+]\s+)?```", line):
            in_fence = not in_fence
            out.append(line)
            continue
        if in_fence:
            out.append(line)
            continue

        # LOGBOOK drawers
        if stripped == ":LOGBOOK:":
            in_logbook = True
            continue
        if in_logbook:
            if stripped == ":END:":
                in_logbook = False
            continue

        # bullet-form property lines: block whose first line is the property itself
        # ("- collapsed:: true" with real content on the continuation line below)
        m = re.match(rf"^(\s*)- (collapsed:: (?:true|false)|logseq\.order-list-type:: number|id:: ({UUID}))\s*$", line)
        if m:
            indent = m.group(1)
            uuid = m.group(3)
            if uuid and uuid in referenced:
                out.append(f"{indent}- ^{uuid[:8]}")
            else:
                out.append(f"{indent}- ")
                pending_merge_indent = indent
            continue

        # property lines
        m = re.match(rf"^\s*id:: ({UUID})\s*$", line)
        if m:
            uuid = m.group(1)
            if uuid in referenced and out:
                # anchor goes at end of the block's first line
                for i in range(len(out) - 1, -1, -1):
                    if out[i].strip():
                        out[i] = out[i].rstrip() + f" ^{uuid[:8]}"
                        break
            continue
        if re.match(r"^\s*collapsed:: (true|false)\s*$", line):
            continue
        if re.match(r"^\s*logseq\.order-list-type:: number\s*$", line):
            # convert the previous bullet line to a numbered item; number it by
            # walking back past deeper lines to the previous same-indent sibling
            for i in range(len(out) - 1, -1, -1):
                bm = re.match(r"^(\s*)- (.*)$", out[i])
                if bm:
                    indent = bm.group(1)
                    n = 1
                    for j in range(i - 1, -1, -1):
                        if not out[j].strip():
                            continue
                        lead = out[j][: len(out[j]) - len(out[j].lstrip())]
                        if len(lead) > len(indent):
                            continue  # child or continuation line
                        if lead == indent:
                            nm = re.match(rf"^{re.escape(indent)}(\d+)\. ", out[j])
                            n = int(nm.group(1)) + 1 if nm else 1
                        break
                    out[i] = f"{indent}{n}. {bm.group(2)}"
                    break
            continue

        # task markers on bullet lines (not headings)
        line = re.sub(
            r"^(\s*)- (TODO|LATER|WAITING|DOING|NOW|IN-PROGRESS|DONE|CANCELED|CANCELLED)\s+",
            lambda m: f"{m.group(1)}- {MARKER_MAP[m.group(2)]} ",
            line,
        )

        # drop LogSeq priority markers
        line = re.sub(r"\[#[A-C]\]\s*", "", line)

        # embeds and block refs
        line = re.sub(rf"\{{\{{embed \(\(({UUID})\)\)\}}\}}", resolve_embed, line)
        line = re.sub(r"\{\{embed \[\[([^]]+)\]\]\}\}", r"![[\1]]", line)
        line = re.sub(rf"\(\(({UUID})\)\)", resolve_ref, line)
        line = re.sub(r"\{\{video ([^}]+)\}\}", r"\1", line)

        # date links: [[Feb 9th, 2026]] -> [[2026-02-09]]
        line = re.sub(
            r"\[\[(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{1,2})(st|nd|rd|th), (\d{4})\]\]",
            date_link, line)

        # asset paths
        line = line.replace("](../assets/", "](assets/")

        out.append(line)

    result = "\n".join(out)
    if result.strip() == "-":  # LogSeq empty-page placeholder
        result = ""
    return result


def main():
    defined, referenced = collect_ids()
    orphans = referenced - set(defined)
    if orphans:
        print(f"WARNING: refs without target: {orphans}")

    written = 0
    for f in sorted(SRC.glob("pages/*.md")) + sorted(SRC.glob("journals/*.md")):
        rel = dest_rel(f)
        dst = DST / rel
        dst.parent.mkdir(parents=True, exist_ok=True)
        dst.write_text(convert(f.read_text(encoding="utf-8"), defined, referenced),
                       encoding="utf-8")
        written += 1

    assets_dst = DST / "assets"
    assets_dst.mkdir(exist_ok=True)
    copied = 0
    for a in SRC.glob("assets/*"):
        if a.name == ".DS_Store":
            continue
        shutil.copy2(a, assets_dst / a.name)
        copied += 1

    print(f"wrote {written} notes, copied {copied} assets")


if __name__ == "__main__":
    main()

— § —

Reply via email

#ai #bestof #dev #pkm #serenity

brew pin

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 18 Jul 2026 14:53:04 +0200

♠ TIL: brew pin.

For reasons to be elaborated in another post, I am currently prevented from upgrading LogSeq to its latest version in homebrew:

% brew outdated
[...]
logseq (0.10.14) != 2.0.1
[...]

LogSeq v2 introduces breaking changes to my workflow. I found this out the hard way. As put by Valodim in HN:

And now after several years of complete stagnation, the supposed improvement is a database format to fix their technical issues, so I can no longer keep all my data as markdown files? At a time when half the edits are done by Claude and tracked with jujustu, this is just not useful for me.

All I wanted was the original vision, but with less bugs and more quality of life features.

As such, I would like to settle in the current version for now. Pinning to the rescue!

% brew pin logseq
Warning: logseq has `auto_updates true` and may update itself outside Homebrew despite being pinned.

% brew list --pinned
logseq

% brew outdated
[...]
logseq (0.10.14) != 2.0.1 [pinned at 0.10.14]
[...]

That’s all.

To unpin it in the future:

% brew unpin logseq

— § —

Reply via email

#dev #macos #pkm

Idleness, redux

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 26 May 2026 22:22:00 +0200

♠ It’s 2026.

Whenever I’m idle in the gym, or in public transit, or in a queue, or waiting for GitHub to become available again (boooo!), I can simply open Claude Code on my phone and unleash my ~~boredom~~ creativity. I can open my corporate ~~clanker~~ claw assistant and do on-the-fly recon, troubleshooting & prototyping.

What a time to be alive!

Should I feel guilty to enjoy it? Guilty of the pleasure? Of the planet burning? Of the soci(et)al implications it yields? I was always very productive since my teens. I was always a fan of the Hitchhiker’s Guide to the Galaxy. And then, all of a sudden, it feels like my childhood fantasies have materialized, all at once, and they’re almost universally available, at my fingertips, literally.

— § —

Reply via email

#ai #dev #pkm #serenity

atuin: global search

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 26 May 2026 10:40:39 +0200

♠ Previously.

Scenario:

machine 1, day 1: run a bunch of commands
machine 2, day 2: I’d like to run a subset of the commands I ran yesterday. If only I could remember them! I do not have access to machine 1 at the moment.

Enter atuin global search!

Assuming that you set up atuin sync in both machines, all you have to do is this:

enter machine 2, run atuin sync once, manually¹:

thiago.perrotta ~
% atuin sync
Uploading 102 records to 0198c192{redacted}d30370fad/history
  [00:00:00] [##########################] 102/102 (0.0s)3/0 up/down to record store
Sync complete! 105855 items in history database, force: false

press Cmd-R (or Ctrl-R), ensure the filter mode is set to global:

global (default): Search from the full history

grep for the desired commands in the interactive TUI that will follow
profit!

This is peak PKM! It just works™.

Or simply wait until it happens in the background automatically. ↩︎

— § —

Reply via email

#dev #pkm

★ fast-resume: search coding agent sessions

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 25 May 2026 15:23:20 +0200

♠ fast-resume (fr), via Stanislas:

I use many coding agents these days: Claude Code, Codex, OpenCode, Copilot, and more. Sometimes I remember that I, or the agent, mentioned something specific in a previous session, and I want to go back to it.

Most coding agents have a /resume feature now, which allows a session to be reopened with all the state back. While the resume feature works great, finding which session to resume is harder.

[…]

Let’s say I have a few sessions about building a TUI program. I remember that in one of the sessions, the agent mentioned textual. I can’t search for textual in the resume view! Also, if I don’t remember the folder and which agent I used, I’m screwed. And some agents don’t have that feature at all.

I’ve been longing for a solution to this problem. fast-resume nails it! It reminds me of fpp, but for agent sessions instead of disk files. In other words, it’s like a ripgrep on steroids designed specifically for coding agent sessions.

It supports various agents (including Claude Code, OpenAI Codex and Open Code), among others.

Installation #

brew tap angristan/tap
brew install fast-resume
% brew ls fast-resume
/opt/homebrew/Cellar/fast-resume/1.16.2/bin/fast-resume
/opt/homebrew/Cellar/fast-resume/1.16.2/bin/fr
/opt/homebrew/Cellar/fast-resume/1.16.2/libexec/_internal/ (140 files)
/opt/homebrew/Cellar/fast-resume/1.16.2/libexec/fr
/opt/homebrew/Cellar/fast-resume/1.16.2/sbom.spdx.json

Usage #

fr is all you need to remember.

The program is a TUI, and it is very intuitive to use. Here are a few handy terms for the search bar:

dir:foo
agent:claude
date:today, date:yesterday

Upon selecting an entry you drop into its corresponding coding agent session.

“YOLO” mode is transparently supported, respecting the original session settings.

The TUI mode is optional:

fr "agent:claude date:<7d api bug"

A local search index is created at ~/.cache/fast-resume by default. If you need to re-create it for whatever reason, run fr --rebuild.

In case you’re wondering (not that it should matter), it’s implemented in Python.

★ Worktrunk

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 25 May 2026 10:57:00 +0200

♠ Worktrunk:

Git worktree management for parallel AI agent workflows

I stumbled upon worktrunk (wt) due to a fortunate coincidence, serendipity at its best. I was pitching my own pancake wt to someone, and this person asked if I hadn’t heard of worktrunk.

If you look at its git star history¹, you’ll notice that it became popular only at the beginning of 2026, whereas I wrote my wt back in November 2025. I did proper diligence at the time but couldn’t find anything resembling my vision. Normally I prefer to reuse rather than writing from scratch.

“AI agent workflows” is a tagline that does not convince me. If anything, it actually worsens my appeal to try out the software. Seriously. Riding the wave is not helpful.

What really sold me was its usage examples. I was able to immediately tell that it had very similar goals to my own wt (sans AI).

Setup #

First, install worktrunk:

brew install worktrunk

It is as simple (and rusty!) as it could be:

% brew ls worktrunk
/opt/homebrew/Cellar/worktrunk/0.53.0/.crates.toml
/opt/homebrew/Cellar/worktrunk/0.53.0/.crates2.json
/opt/homebrew/Cellar/worktrunk/0.53.0/bin/wt
/opt/homebrew/Cellar/worktrunk/0.53.0/etc/bash_completion.d/wt
/opt/homebrew/Cellar/worktrunk/0.53.0/sbom.spdx.json
/opt/homebrew/Cellar/worktrunk/0.53.0/share/fish/vendor_completions.d/wt.fish
/opt/homebrew/Cellar/worktrunk/0.53.0/share/zsh/site-functions/_wt

Shell completion is a bonus that you’ll definitely want, as noted in a previous post:

# worktrunk: https://worktrunk.dev/
(( $+commands[wt] )) && eval "$(wt config shell init zsh)"

The snippet above integrates well with my own dotfiles; a vanilla setup that most people should follow is, instead, wt config shell install, which will populate your .bashrc / .zshrc accordingly with wt config shell init.

The shell integration alone makes it compelling enough to switch to wt, but we’re not done yet.

Workflow #

It is possible to customize wt. I value muscle memory and the ability to easily recall commands, therefore I crafted this basic configuration to facilitate the migration from my own wt:

worktree-path = "{{ repo_path }}/.worktrees/{{ branch | sanitize }}"

[aliases]
add = "wt switch --create {{ args }}"
bd = "wt remove -D {{ args }}"
cd = "wt switch {{ args }}"
checkout = "wt switch {{ args }}"
cleanup = "wt step prune {{ args }}"
co = "wt switch {{ args }}"
commit = "wt step commit {{ args }}"
create = "wt switch --create {{ args }}"
del = "wt remove {{ args }}"
delete = "wt remove {{ args }}"
goto = "wt switch --no-cd {{ args }}"
ls = "wt list {{ args }}"
new = "wt switch --create {{ args }}"
prune = "wt step prune {{ args }}"
rm = "wt remove {{ args }}"
tui = "wt switch {{ args }}"
world = "wt step prune {{ args }}"
xl = "wt list {{ args }}"

[pre-start]
prek = "test -f .pre-commit-config.yaml && prek install --install-hooks || true"

[pre-merge]
prek = "test -f .pre-commit-config.yaml && prek run --from-ref \"$(git symbolic-ref --short refs/remotes/origin/HEAD)\" --to-ref HEAD || true"

You can start by running wt config create and then iterating upon the newly generated config file, which is very well documented. What a great developer experience!

Let’s break it down.

We start with wt add <feature> (upstream: wt switch --create). This will create a worktree:

tperrotta ~/Workspace/perrotta.dev git:master!?
% wt add myfeature
◎ Running pre-start user:prek
  test -f .pre-commit-config.yaml && prek install --install-hooks || true
prek installed at `/Users/tperrotta/Workspace/perrotta.dev/.git/hooks/pre-commit`
✓ Created branch myfeature from master and worktree @ ~/Workspace/perrotta.dev/.worktrees/myfeature
  39.06s user 6.26s system 251% cpu 17.984 total

tperrotta ~/Workspace/perrotta.dev/.worktrees/myfeature git:myfeature ⎇ myfeature
% git st
## myfeature...master

At any time, we can check the current status with wt xl (upstream: wt list):

tperrotta ~/Workspace/perrotta.dev/.worktrees/myfeature git:myfeature ⎇ myfeature
% wt xl
  Branch     Status        HEAD±    main↕  Remote⇅  Path                    Commit    Age   Message
@ myfeature      _                                  ./.worktrees/myfeature  23df7c41  50m   name author explicitly
^ master      !? ^|      +5   -6              |     .                       23df7c41  50m   name author explicitly

○ Showing 2 worktrees, 1 with changes

When opening a new shell, we can easily switch to the newly created worktree from the repo root with wt cd (upstream: wt switch):

tperrotta ~/Workspace/perrotta.dev git:master!?
% wt cd myfeature
○ Switched to worktree for myfeature @ ~/Workspace/perrotta.dev/.worktrees/myfeature

tperrotta ~/Workspace/perrotta.dev/.worktrees/myfeature git:myfeature ⎇ myfeature
%

Once we are done (e.g. created/merged a pull request), we can delete the worktree with wt bd or wt del (upstream: wt remove -D).

That’s all! The core workflow steps are quite easy to assimilate.

You’ll notice that my worktrees are created in a .worktrees directory within the git repository root. This is due to my setting worktree-path in the config file. The default behavior of worktrunk is to use sibling directories (e.g. ../myrepo.myfeature from the git root).

As you can see from my config file, I have also integrated prek (pre-commit) to it:

the creation of a worktree yields prek install
the merge of a worktree (not covered in this post) yields prek run on the affected commits

wt has many other features; this is just the tip of the iceberg.

GitHub stars are a vanity metric but they are occasionally useful. ↩︎

— § —

Reply via email

#ai #bestof #dev #git #pkm #pre-commit

★ Personal CLAUDE.md

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 20 May 2026 14:20:44 +0200

♠ I asked Claude Opus 4.7 to generate a global CLAUDE.md for my tone & style based on historical usage for 12+ months. The result¹ was added to my thiagowfx/.dotfiles repo, cross-posted here for ease of reference and future preservation.

I expect this file to evolve over time. Updates won’t be republished here; the dotfiles repo is the source of truth.

# Global CLAUDE.md

Personal preferences that apply across every project. Project-specific facts live in each repo's own CLAUDE.md.

## Tone

- Terse. Action-oriented. No lectures, no preamble, no trailing summaries, no
  political correctness.
- Don't invent sections, headings, or boilerplate I didn't request. Match the
  shape of what I asked for.
- Number multi-part questions (1/2/3) so I can answer inline.
- When disambiguating, focus on one topic at a time.
- If I reply "yes", "go on", "a)", "do it", or similar — that's full
  authorization. Don't re-confirm.

## Keep moving

- If my reply is "hello?", "so?", "are you still there?" — you stalled. Don't
  wait for trivial confirmation; pick the reasonable default and continue.
- After a sandbox lift ("try again", "I lifted your sandbox") — retry the exact
  same command. Don't restart reasoning.
- Don't pause to summarize what you just did before doing the next step.

## Don't over-engineer

- Bug fixes don't need surrounding refactors. One-shot operations don't need
  helpers.
- If you add a flag (`--force`, `--recursive`, etc.), be ready to justify it.
  Don't cargo-cult.
- Prefer the simplest thing that works. I'll ask for more if I want more. Keep
  it simple.

## Destructive ops

- Never `rm`. Use `trash` (or the equivalent move-to-trash).
- For destructive ops on shared state (S3 objects, branches, DB rows): make a
  backup first, then delete only what matches, then confirm. Phrase:
  *backup → filter → delete*.
- Never force-push to `master`/`main`. Never skip hooks (`--no-verify`) unless I
  explicitly ask.

## Tooling defaults

- **Pre-commit**: prefer `prek` over `pre-commit`. Run
  `prek run --all-files`. When configuring hooks, prefer self-contained/pinned
  deps over relying on system binaries.
- **Polling**: never `sleep` in a loop. Use the `Monitor` tool with an `until`
  condition, or `run_in_background` and wait for the notification.
- **`gh pr checks`**: `--watch` and `--json` are mutually exclusive. Don't
  combine them.
- **Editor**: vim (preferred) and Zed. Don't suggest VSCode-specific workflows.

## Worktrees and PRs

- Default to worktrees for parallel work. Path convention:
  `~/<org>/<repo>/.worktrees/<topic>/`. If I say "work here please: `<path>`",
  `cd` there and proceed. Use the `wt` tool to manage worktrees.
- Branch prefix: `thiagowfx/<topic>`.
- Slash commands I lean on: `/commit`, `/commit-and-send-pr`, `/send-pr`,
  `/pr-pass`, `/gha`, `/grill-me`. If I chain a task with one of these ("do X,
  then /commit-and-send-pr foo"), treat the slash command as the final step —
  invoke it, don't paraphrase.
- "commit what you changed (only). DO NOT push" means exactly that: stage only
  the files you touched this turn, commit, stop.
- For non-trivial PRs, include a Mermaid diagram in the description when it
  helps. Beware of string escaping issues.
- After any meaningful change to an open PR, update the PR description
  (`gh pr edit`) so it reflects the current state. Don't let the title/body
  drift from what the branch actually does.

## Drift and reconciliation

- When code and live state disagree, the default is **update the code to match
  the live state**, not the reverse. Don't propose `terraform import`
  reshuffles unless I ask.

Colophon #

How did I do this?

% cd ~/.claude && claude
% help me craft my (global) CLAUDE.md, based on past interactions

That’s it! No fancy prompt. Direct and succinct.

I performed a few manual tweaks. The end result was quite decent (to my taste). ↩︎

— § —

Reply via email

#ai #bestof #dev #meta #pkm #serenity

atuin: delete account

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 18 May 2026 17:49:39 +0200

♠ Previously.

I’ve been self-hosting atuin for quite a while now. As such, I no longer need an account in the official server (created a long time ago).

Problem statement: delete that account.

Note that I am currently logged into my self-hosted server.

As such, the first step is to switch back to the official server:

% $EDITOR ~/.config/atuin/config.toml

Then ensure that sync_address is either commented out or set to https://api.atuin.sh.

Now log in to it:

% atuin login --username {username}
>> insert password, insert key

And, finally:

% atuin account delete

Afterwards, switch back to the self-hosted server and run atuin login again.

— § —

Reply via email

#dev #pkm #privacy #security #selfhosted

★ anki: flashcard generation with claude code

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 15 Apr 2026 16:09:12 +0200

♠ Previously.

I started to use Claude Code to generate flashcards for my (new) Tech Deck via AnkiConnect, covering books and topics I’m studying for to consolidate my SWE-SRE knowledge.

The workflow: I tell Claude which book or topic to cover, it researches their key concepts, checks my existing cards (notes) for potential overlap, and batch-adds new ones via the AnkiConnect HTTP API:

def anki_request(action, **params):
    payload = json.dumps({"action": action, "version": 6, "params": params})
    req = urllib.request.Request("http://localhost:8765", data=payload.encode(), method="POST")
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())["result"]

notes = [
    {
        "deckName": "Tech 💻",
        "modelName": "Basic",
        "fields": {
            "Front": "DDIA: <b>LSM-Trees vs B-Trees</b> — how do they differ?",
            "Back": "..."  # HTML-formatted answer
        },
        "tags": ["ddia"],
    },
    # ... more notes
]

anki_request("addNotes", notes=notes)

In a sample session, topics covered:

Topic	Cards	Tag
SRE (Google)	50	`sre`
System Design	40	`system-design`
LeetCode / Python	41	`python`
Kubernetes	20	`kubernetes`
Production-Ready Microservices (Susan Fowler)	28	`microservices`
DDIA (Martin Kleppmann)	25	`ddia`
Building Microservices (Newman)	16	`microservices`
Fundamentals of Software Architecture (Richards & Ford)	25	`software-architecture`
Kubernetes advanced	25	`kubernetes`
Networking	17	`networking`
Linux / Systems Performance	16	`linux`
Python stdlib	23	`python`
Total	~326

For each book, Claude searched the web for chapter summaries and key concepts, cross-referenced my existing cards to avoid duplication, then created a Python script to push cards through AnkiConnect’s addNotes action.

Cards match the existing format: Basic note type, HTML formatting (<b>, <br>, <code>, •), one tag per topic.

Example card (front):

DDIA: Sloppy quorums and hinted handoff — what are they?

Example card (back):

In a standard quorum (w + r > n), writes/reads must reach specific replicas. Problem: during a network partition, the designated replicas may be unreachable. Strict quorum would reject the write → reduced availability. Sloppy quorum: Accept writes on any reachable nodes, even if they aren’t the designated replicas (…)

The whole process took about an hour. Doing it by hand would have taken days.

I am excited to evolve this workflow. The next step is going to be to refactor my thousands of language cards and notes.

— § —

Reply via email

#ai #bestof #dev #pkm

Anki: API access

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 13 Apr 2026 02:15:10 +0200

♠ Previously.

Install AnkiConnect:

AnkiConnect enables external applications such as Yomichan to communicate with Anki over a simple HTTP API. Its capabilities include executing queries against the user’s card deck, automatically creating new cards, and more. AnkiConnect is compatible with the latest stable (2.1.x) releases of Anki; older versions (2.0.x and below) are no longer supported.

…to be able to do incantations such as:

% curl -s localhost:8765 -X POST -d '{"action": "deckNames", "version": 6}' | python3 -m json.tool

{
    "result": [
        "Default",
        "Languages",
        "Languages::English \ud83c\uddec\ud83c\udde7",
        "Languages::German \ud83c\udde9\ud83c\uddea",
        "Languages::Italian \ud83c\uddee\ud83c\uddf9",
        "Languages::Portuguese \ud83c\udde7\ud83c\uddf7",
        "Tech \ud83d\udcbb"
    ],
    "error": null
}

% curl -s localhost:8765 -X POST -d '{"action": "modelNames", "version": 6}' | python3 -m json.tool

{
    "result": [
        "Basic",
        "Basic (and reversed card)",
        "Cloze",
        "Deutsch Grammatik Cloze \ud83c\udde9\ud83c\uddea",
        "Deutsch Language Card \ud83c\udde9\ud83c\uddea",
        "Image Occlusion",
        "Italian Grammatik Cloze \ud83c\uddee\ud83c\uddf9",
        "Italian Language Card \ud83c\uddee\ud83c\uddf9"
    ],
    "error": null
}

Why is this useful?

It allows me to connect my LLM to Anki via HTTP¹.

Prompt: create flashcards based on the Site Reliability Engineer book by Google, published by O’Reilly, in the Tech deck.

⏺ I’ll use the Basic note type (Front/Back). The Google SRE book is substantial — it covers topics like SLOs, error budgets, monitoring, incident response, automation, release engineering, etc.

How many flashcards would you like roughly? And should I cover the whole book broadly or focus on specific chapters/topics?

The traditional option is to import an existing shared deck, like this one.

⏺ Done! I’ve created 50 flashcards in the Tech 💻 deck, all tagged with sre and google-sre-book. They cover the most relevant topics:

Core concepts: SRE definition, SLI/SLO/SLA, error budgets, toil, 50% rule

Monitoring: four golden signals, black-box vs white-box, symptom-based alerting

Incident management: roles, mitigation vs root cause, postmortems, blameless culture

Reliability patterns: graceful degradation, load shedding, circuit breaking, retry budgets, exponential backoff

Cascading failures: causes, defenses, deadline propagation

Operations: on-call best practices, change management, canarying, capacity planning

Distributed systems: CAP theorem, consensus, Paxos/Raft

Culture: simplicity, automation hierarchy, PRR, Wheel of Misfortune

Wait until I start to refactor my language notes².

Alternatively you can use MCP if you really want to. ↩︎
Anki concepts: a note is typically a pair of cards (back and front, front and back). ↩︎

— § —

Reply via email

#ai #dev #pkm

anki: auto-sync

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 12 Apr 2026 10:38:15 +0200

♠ Previously.

Problem statement: enable auto-sync to AnkiWeb.

First layer: enable sync on open/close: Preferences > Syncing > Automatically sync on profile open/close

Second layer: for manual syncs, press y (source).

Third layer: install and enable an auto sync add-on such as this one:

This addon will automatically synchronize your collection with AnkiWeb at time intervals you can choose. It will never interrupt you while you are using Anki.

By default, the first sync will start 1 minute after your last activity. While Anki is sitting idle in the background, it will sync every 10 minutes. You can change those settings in the options dialog.

Someone forked that add-on to improve upon it, enabling background auto sync.

Should I trust a random add-on though? Even if the Anki community is generally decent and well-intentioned, these days we can’t trust anyone.

I asked Opus 4.6 (Claude) to analyze it for potential malware:

⏺ I've now read every single source file in the addon. Here's my analysis:

  ---
  Malware Analysis: Background Auto Sync (226796325)

  Addon: Background Auto Sync for Anki
  Author: athulkrishna2015
  Source: GitHub
  Fork of: Auto-Sync-Anki-Addon by Robin-Haupt-1
  License: GPL-3.0
  Files reviewed: All 8 Python source files + manifest.json

  Verdict: No malware detected. Appears safe.

  What the code actually does

  1. sync_routine.py (core logic) — Sets up timers to periodically call Anki's built-in
  mw.col.sync_collection(). Saves/restores window state so sync doesn't steal focus. All sync goes
  through Anki's native sync infrastructure (AnkiWeb auth, mw.pm.sync_auth()).
  2. utils.py — Single function: has_internet_connection() which opens a TCP socket to 8.8.8.8:53
  (Google DNS) to check connectivity. This is a standard, benign connectivity check. No data is
  sent.
  3. config.py — Reads/writes config to Anki's own config storage (mw.col.set_config/get_config). No
   external communication.
  4. main.py — Wires up hooks (profile_did_open, profile_will_close, sync_will_start,
  sync_did_finish) and adds a menu item. Standard Anki addon boilerplate.
  5. log_window.py — Simple in-memory log viewer (QDialog + QTextEdit). No file I/O, no network.
  6. options_dialog.py — Qt settings dialog with spinboxes/checkboxes. The support tab loads a Ko-fi
   widget (https://storage.ko-fi.com/cdn/widget/Widget_2.js) via an embedded AnkiWebView. Also
  displays crypto donation QR codes (BTC, ETH, UPI). These are static images bundled in the addon.
  7. constants.py — Config key names and defaults. Pure data.
  8. bump.py / make_ankiaddon.py — Developer build tooling only; not shipped in the .ankiaddon
  package.

  Specific things I checked for

  ┌────────────────┬────────────────────────────────────────────────────────────────────────────┐
  │    Concern     │                                  Finding                                   │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │                │ Only socket.create_connection("8.8.8.8", 53) for connectivity check +      │
  │ Network calls  │ Anki's own sync API. No external HTTP requests, no telemetry, no phoning   │
  │                │ home.                                                                      │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │ File system    │ Only os.path.dirname(__file__) and os.path.join to load bundled QR code    │
  │ access         │ images. No reading/writing arbitrary files.                                │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │ Code execution │ None. No exec(), eval(), subprocess, os.system, importlib, or dynamic code │
  │  / eval        │  loading.                                                                  │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │ Data           │ No access to deck content, card data, or personal information beyond what  │
  │ exfiltration   │ Anki's sync already handles.                                               │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │ Obfuscation    │ None. Code is clean, readable, well-structured Python.                     │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │ Suspicious     │ Only standard library (socket, datetime, os, json) and Anki's own APIs     │
  │ imports        │ (aqt, aqt.qt).                                                             │
  ├────────────────┼────────────────────────────────────────────────────────────────────────────┤
  │                │ Loads JavaScript from storage.ko-fi.com in the support tab — this is a     │
  │ Ko-fi widget   │ standard donation button, not a concern, and only loads when you open the  │
  │                │ options dialog's "Support" tab.                                            │
  └────────────────┴────────────────────────────────────────────────────────────────────────────┘

  Minor notes (not security concerns)

  - The author has 18 other shared items on AnkiWeb, suggesting an active community member rather
  than a throwaway account.
  - The addon is relatively new (updated 2026-03-27) with 0 ratings so far, so there's limited
  community vetting.
  - The code is a clean, well-documented fork of the established Robin-Haupt Auto-Sync addon.

  Bottom line: The code does exactly what it claims — periodic background sync using Anki's native
  sync mechanism. No signs of malicious intent, data exfiltration, backdoors, or obfuscated code.

✻ Cooked for 2m 36s

I am not installing it though, I am happy with the second layer for now.

— § —

Reply via email

#dev #pkm

Anki: corrupted database

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 08 Apr 2026 00:14:11 +0200

♠ Life is hard. Today, when opening Anki on macOS:

DbError { info: "SqliteFailure(Error { code: DatabaseCorrupt, extended_code: 11 }, Some(\"database disk image is malformed\"))", kind: Other }

Database corrupt? What is this, are we in the 2000s? Goodness.

I have automatic backups enabled. For 4 years I haven’t needed them. Today is the day. Never say never!

% ls -lt "$HOME/Library/Application Support/Anki2/Thiago/backups/"
total 234496
-rw-r--r--@ 1 tperrotta  staff  3911921 Apr  8 00:12 backup-2026-04-08-00.12.17.colpkg
-rw-r--r--@ 1 tperrotta  staff  3911921 Apr  7 00:16 backup-2026-04-07-00.16.26.colpkg

I try:

open "$HOME/Library/Application Support/Anki2/Thiago/backups/backup-2026-04-07-00.16.26.colpkg"

…but apparently that file is corrupt as well.

I am not particularly worried because I sync my notes to AnkiWeb. Even if the entire local collection were corrupt, my flashcards are in the cloud.

So I decided to simply start from scratch¹.

mv ~/Library/Application\ Support/Anki2/Thiago/collection.anki2 ~/Library/Application\ Support/Anki2/Thiago/collection.anki2.corrupt
rm -f ~/Library/Application\ Support/Anki2/Thiago/collection.anki2-shm ~/Library/Application\ Support/Anki2/Thiago/collection.anki2-wal

Then I open Anki.

It prompts me to download my decks from AnkiWeb.

And now everything works as usual! Last cleanup:

trash ~/Library/Application\ Support/Anki2/Thiago/collection.anki2.corrupt

No idea why this has happened. First time. Life goes on.

!next

Previously.

The idea was mine. The decision was mine. The LLM suggested the command on how to do so. I can still self-troubleshoot, mmmkay? ↩︎

— § —

Reply via email

#ai #dev #pkm #serenity

LogSeq: slowness on macOS

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 03 Jan 2026 23:53:13 -0300

♠ Last week LogSeq was super slow on my Mac, it was pretty much unusable. I had to manually kill its process multiple times as it kept freezing.

Eventually I figured out the issue:

Then iCloud is the cause for the slowness. This is a known issue and is the reason why the developers have built Logseq Sync. Other options for syncing that don’t impact performance are Git and SyncThing.

I would like to keep using iCloud at this time as it’s (i) free and (ii) convenient to access from iOS.

The following mitigation seemed to work:

Locate the LogSeq directory in iCloud (~/Library/Mobile Documents/iCloud~com~logseq~logseq/Documents)
Right click the directory in Finder
Click ‘Keep Downloaded’

Keep Downloaded means the file stays on the device, and even if space is needed the file will not be removed […]

— § —

Reply via email

#dev #macos #pkm

Reordering mobile editing icons in logseq

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 06 Dec 2025 00:42:32 -0300

♠ Reordering mobile editing icons in logseq by Colin Bate:

I found a way to avoid needing to constantly scroll sideways to access the icons I need.

This is why I love the indie web.

I was looking for how to do exactly the same operation, for exactly the same icon.

Isn’t it so amazing when a person documents their solutions publicly online, in the open? Colin, you are my hero.

Update custom.css in LogSeq settings:

/* Move icons 3+ to order 2 */
#mobile-editor-toolbar .toolbar-commands > div:nth-child(n+3) {
  order: 2;
  color: var(--cyan);
}

/* Insert icon 11 (brackets) at order 1 */
#mobile-editor-toolbar .toolbar-commands > div:nth-child(11) {
  order: 1;
  color: var(--orange);
}

Side effect: The [] wikilink button will be moved to be the third one in the editor toolbar.

— § —

Reply via email

#dev #pkm #serenity

Snippets manager

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 11:52:39 -0300

♠ Humans are terrible at remembering complex command lines.

This issue compounds whenever there is a myriad of commands to remember.

I’ve been thinking for ages on how to address this gap efficiently. I finally got a decent workflow.

Unlimited + synchronized shell history: atuin.
Text expander: espanso.

And now, the missing piece: a snippets manager.

There are three good options:

MassCode
Snippets Lab
pet: command-line

I am piloting Snippets Lab¹. It has integration with Raycast, and also a system tray icon.

These three solutions are enough to manage anything I may ever want to recall. Commands at my fingertips.

We can finish with the cherry on top: LogSeq entries to archive deprecated or potentially useful commands.

From 2026 onwards, no command shall ever be lost.

Note: The aforementioned programs are intended for macOS. Atuin, Espanso, MassCode, pet and LogSeq are cross-platform. Snippets Lab is macOS only.

It is very comparable to MassCode. This choice was a bit arbitrary. ↩︎

— § —

Reply via email

#dev #pkm

Anki: find all suspended flashcards

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 08 Oct 2025 19:14:48 +0200

♠ The following queries are useful to find flashcards (notes or cards) in Anki that you’re struggling with.

is:suspended
tag:leech

The action item for each should be one of the following:

do nothing for now
delete the note / card if it’s no longer relevant e.g. perhaps it is barely used
enhance or rewrite the note / card for better retention and then unsuspend it

It’s a slow process.

— § —

Reply via email

#dev #pkm #serenity

Daily log

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 13 Aug 2025 12:02:03 +0200

♠ It’s easy to get distracted when using computers connected to the internet. Like, errhmm, when you are doing your job.

I tend to minimize some distractions by reducing notifications and by turning on do not disturb on my phone. Having / using less social media also helps.

What about Internet distractions in my work laptop though?

Lately I’ve been trying out a new habit that appears to keep me more focused throughout the day.

First, I open my note-taking / second brain app (LogSeq).

Next, create a new journal page for it (Aug 13th, 2025 or 2025-08-13).

One reason I like LogSeq is that it does it automatically for me, every day.

Then I create a heading called “Daily log”¹.

I think about what to work on next, typically based on ticket prioritization or sprint planning or dealing with whatever fire is going on at the moment or a “20%” project to improve overall code health.

Then I type in /time<ENTER>. LogSeq helpfully inserts the current time e.g. 13:14. Afterwards, I write a single sentence about what I’m going to do. For example:

14:18 Sync docker images for bitnamilegacy
14:45 Experiment with pruning in Argo

This is not intended to be a meticulous report, as it doesn’t impact me in any way (e.g. for performance reviews).

I merely observed that jotting one slice of idea down makes my intent concrete, clear(er), and helps me stay focused on it, instead of thinking on the next procrastination browser tab to open to get distracted with.

There’s also a psychological effect wherein observing my accomplishments at the end of the day simply feels good.

And last but not least, it becomes easier for me to remember what I worked on during the day, making my stand-up meetings more comprehensive.

Or “Daily”. The name is not important. ↩︎

— § —

Reply via email

#dev #pkm #serenity #socialmedia

★ Logseq template for working out

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 22 Jun 2025 02:19:09 +0200

♠ Lately I’ve been tracking my gym sessions in Logseq.

This workflow has been in place for at least three months, therefore it’s stable enough by now. Here’s the rough idea.

First, create a [[Templates]] page.

How to remember whether it’s Templates or Template? Simple: add an alias::template attribute to the page. It should be the first bullet point. Now there’s no need to remember: any of them will do.

Then add a [[Gym 💪]] bullet point¹ with alias::gym. In it, add a template::gym attribute. Within it, add the template content. This is the part where you should adapt it to your own desires and goals, but I’ll share mine:

- Location
	- [[mygym]] (mylocation1 | mylocation2)
- Defaults
	- 3-4x 8-12
- Warm-up
	- XX min what
- Upper
	- Exercise: 25 -> 30
- Lower
	-
- Cooldown
	- XX min what
- Protein recovery
	- XX g (what)
- Body weight
	- XX kg (gym | home)

A brief explanation:

location: links to the page of each gym, where I can add details such as its Wi-Fi password, how much drinks cost there, etc.
defaults: the baseline for the session – how many sets, how many repetitions in each?
warm-up: what did I do, for how many minutes?
upper: a bucket to group upper-body exercises: arms, chest, abs, etc.
lower: a bucket to group lower-body exercises: legs, calves, glutes, etc.
cooldown: what did I do, for how many minutes?
protein recovery: in grams, what did I drink or eat?
body weight: in kilos, and where did I measure it?²

This template has served me well. The most important part is the one that contains the exercises (upper and lower).

Now, let’s say I am going to the gym today.

First, I open the journal page ([[2025-06-22]]). Then I type in /template gym. This inserts the template above.

Now I click [[Gym 💪]] to open up the gym page.

The gym page contains a detailed explanation of my current goals and workflows. In particular, it has an exercises reference section that looks like this (the numbers are made up):

* # Exercises
* Upper
  * Biceps: 10 -> 12
  * Triceps: 18 -> 20
  * Butterfly normal: 20 -> 25
  * Butterfly reverse: 20 -> 25
  [...]
* Lower
  * Hip addiction: 17 -> 20
  * Hip abduction: 15 -> 20

Each entry tracks the latest weight and the one before it, which makes the progression explicit (and doubles-down as a motivation factor!).

Now, because this is an advanced PKM, the backlink we inserted earlier with the template shows up under “linked references” at the bottom. And this is the magic that makes Logseq useful for this kind of tracking: all gym entries are accessible at a glance, connected to the main [[Gym 💪]] page.

During the workout, I use the appropriate weight from the gym page as an input to the corresponding daily note entry, and slowly increase it in-between sets.

For example, let’s say that for biceps the reference entry is Biceps: 10 -> 12. Then, for today’s workout, I will add an entry like Biceps: 12 -> 13 -> 14, starting with 12, the latest reference value.

Repeat for each exercise.

At the end of the workout, I update the reference entries with the progress of the day. For example, the updated entry for biceps becomes * Biceps: 12 -> 14.

I never liked to go to the gym, but now I am starting to enjoy it, because I feel this approach brings many self-motivating benefits:

there’s a detailed record of every single workout that I do, down to the day and the exercise / weight in each set. These entries are psychologically powerful, they motivate me more than smartwatches and/or gym / workouts apps
the progression ensures I am consistent and pick up where I left off in the previous session. There’s no need to guess any longer which weight to use, I know exactly which one to use, and whether it was difficult or easy last time (as I also track this information in the reference).
reduced risk of injury as I am increasing the weights slowly, and being mindful of the ones that incur a lot of stress and/or strain on my muscles
ability to track goals and be realistic about them, and even estimate when I’ll be able to reach them, based on historical progression.

I tried to use gym apps before, but they were never effective. They are often complicated and bloated. The advantage of keeping the format plain and flexible in the PKM is that it can suit all my needs. In fact, I could even bring pen and paper to the gym instead of my smartphone if needed, as there’s absolutely no need for internet access when updating these entries, and no lock-in whatsoever.

There’s nothing revolutionary in my approach. Its core is merely: (i) (annotated!) consistency and (ii) ability to shape the system to the format that suits/fits my needs.

Consistency is very important. Before adopting this system, I would always guess which weight to use for each exercise. But there are too many of them, and as such it’s quite difficult to keep track of them all in my head.

The format flexibility is also important. The key is to shape a system to your needs, not the other way around. With smartphone and smartwatch apps, I always felt that I had to adapt myself to the input format the app expects, which is painful from an UX perspective.

And now it is time to work out again 💪

Yes, including the emoji. Life is short to skip having fun. ↩︎
There are tiny differences, therefore I like to note down whether I used the scale from the gym or the one at home. ↩︎

— § —

Reply via email

#bestof #pkm #serenity

Logseq: open page in sidebar

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 14 May 2025 00:31:30 +0200

♠ To open a page in the sidebar in Logseq, hold Shift + click the [[page]] / #page link.

Pages can be stacked in the sidebar, à la dwm.

— § —

Reply via email

#dev #pkm

Logseq: list all pages of a tag

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 04 May 2025 13:24:52 +0200

♠ Problem statement: Given a couple of pages in Logseq tagged with a given content tag:

tags:: content

…dynamically list all of them.

We can do so with the following logseq query¹:

#+BEGIN_QUERY
{
  :title "Ideas 💡 (->)"
  :query (property :tags "idea")
}
#+END_QUERY

This is a static query, not meant to be changed.

Alternatively it’s possible to create a live query, which allows one to tweak it on-the-fly:

{{query (property :tags "idea")}}

The query syntax is somewhat a blend of orgmode + emacs lisp from emacs. ↩︎

— § —

Reply via email

#dev #pkm

Logseq: aliases

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 01 Mar 2025 15:55:20 +0100

♠ In Logseq, I have an entry called “Trips”.

In a topic in my daily note, I want to use the #trip tag to link to it.

However, #trip links to a distinct page, called “Trip”.

Problem statement: How can we “merge” the two entries, effectively treating them as one?

Use aliases: In “Trips”, in the very first bullet point, type ::alias. The auto-completion pops up. Type in “trip”.

That’s all. Linking with [[trip]] or #trip now points out to “Trips”.

— § —

Reply via email

#dev #pkm

Anki: insert emoji on macOS

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 11 Jan 2025 00:28:48 -0300

♠ There’s a longstanding bug in Anki on macOS: it’s not possible to insert an emoji in the editor view via the system emoji picker.

Whenever you click an emoji, the emoji picker closes whilst nothing is inserted.

This has always annoyed me.

Today I found a workaround (thanks Luc!):

For anyone who comes across this. I figured out a quick workaround. You have to open the Emoji-Picker-Keyboard on your Mac and then select the Emoji and pull it into the editor window with your mouse.

It works indeed!

My previous alternative was to use the emoji picker to insert an emoji in another application (e.g. the Notes.app), and then manually cut and paste it.

— § —

Reply via email

#dev #macos #pkm

Logseq: linking and backlinking

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 06 Jan 2025 22:49:44 -0300

♠ This is the first post about LogSeq / PKM. Run before it’s too late!

Expect more of these as I find myself slowly migrating from Obsidian to Logseq. More on that later.

When creating pages in logseq, there are two basic forms to link to other pages, and they are essentially equivalent.

The first one is to use a #hashtag (or simply ’tag’). For example:

Books to read in 2010:

- The Hitchhiker's Guide to the Galaxy by Douglas Adams #book #fiction
- Harry Potter and the Prisoner of Azkaban by J.K. Rowling #book #fiction
- Elite da Tropa by André Batista, Rodrigo Pimentel & Luiz Eduardo Soares #book #nonfiction

^alpha

Under the hood it creates 3 pages: Book, Fiction and Nonfiction. Clicking any of these hashtags opens up the corresponding page. In the page it’s possible to find a backlink to the original page / block that links to it.

The second one is to use double brackets. For example:

- Elite da Tropa is a Brazilian [[book]] written by the ex-police officers André
  Batista and Rodrigo Pimentel together with Luiz Eduardo Soares. It was first
  published in 2006. The book originated the film Elite Squad.
  - Source: https://en.wikipedia.org/wiki/Elite_da_Tropa

^bravo

Clicking [[book]] goes to the same page as #book.

Why are there two forms? I don’t know. But here’s what I learned: it doesn’t matter which one you choose to use, as they are effectively equivalent. For example, you could have written instead:

- Elite da Tropa is a Brazilian #book written by the ex-police officers André
  Batista and Rodrigo Pimentel together with Luiz Eduardo Soares. It was first
  published in 2006. The book originated the film Elite Squad.
  - Source: https://en.wikipedia.org/wiki/Elite_da_Tropa

^charlie

…the effect would have been the same.

The idiomatic style seems to favour the use of double brackets when writing prose (i.e. bravo), and the use of hashtags when “tagging” or qualifying sentences (i.e. alpha). That said, intermixing them is harmless.

— § —

Reply via email

#dev #pkm

★ Anki workflow

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 23 Dec 2024 00:12:52 -0300

♠ I’ve been using Anki since 2-3 years ago to keep up with German vocabulary and grammar. I had originally started with Duolingo.

In the beginning my workflow was quite basic. Then I created custom language cards:

After you install Anki, you need to set up a Note Type to keep your flashcards formatted as you like. Anki comes with a few basic Note Types, but they aren’t suited for learning Japanese.

(via). The advantage of creating a custom note type (language card) is that I can format it the way I want.

On top of it I tweaked my Anki deck settings to optimize it for language learning.

I adopted the Low-Key Anki setup:

The Low-Key Anki setup is a series of counterintuitive simplifications one can make to Anki’s algorithm that result in a significant boost in efficiency, as well as a considerable reduction in the stress associated with reviewing cards

Furthermore, Soren Bjornstad has helpfully written some tips about designing flashcards effectively, some of which I gladly adopted.

And last but not least, Refold provided me with a step-by-step breakdown on how to configure Anki for language learning.

References #

— § —

Reply via email

#bestof #dev #pkm

★ Default apps 2024

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 21 Dec 2024 16:02:54 -0300

♠ The list of my default apps for this year.

In the past I would maintain an “uses” page in my blog, but I no longer believe in it. User needs change all the time, and it’s a chore to keep them up-to-date. People shouldn’t be defined by the software they use.

That said, having a clean snapshot of the software I use at a fixed point in time isn’t a bad proposition. It doesn’t need to be maintained. I will probably look back at it within 5 years and laugh at myself for how many things changed. And also for how many didn’t.

Browser: Google Chrome on macOS, Chromium on Linux, Safari on iOS.
Search: A combination of Google and DuckDuckGo (mostly for their !bangs).
Writing: A combination of VSCode, vim and MarkEdit (macOS markdown editor app). I never got around to long-form writing in Obsidian or Logseq, however it’s something I strive to.
Cloud File Storage: There’s no need to share this. Basic OpSec. Why would people share it?
Chat: WhatsApp remains king in terms of popularity, despite Telegram being superior from an architectural and usability perspective for power users. Facebook Messenger is officially dead at this point. And I’m too much of a millennial for all other apps (Discord, Matrix, etc). Disappearing messages exist in all of these, except Instagram.
Scheduling: There’s no real choice here. You use the platform your employer uses. Otherwise, Google Calendar is the most sensible choice other than self-hosting.
Video Calls: Ditto. I am way too used to Google Meet to justify switching to an alternative at this point.
Music: Spotify, hands down. YouTube Music is a good fallback. There’s no need to pay for YouTube Premium for music, do your research.
Podcasts: Overcast on iOS.
Password Management: Once again, why would you share this?
Code Editor: VScode and vim. Maybe I’ll switch to neovim at some point. I refrain from using IDEs in general but, when I need to, JetBrains is the answer. I tried zed this year but wasn’t convinced, and their core team is quite small. The flurry of “AI”¹ editors should be ignored, as none of them are likely to stick long-term. Instead, it’s better to invest in “AI” tooling that is editor agnostic; for example, Simon Willison’s llm, or GitHub Copilot.
Terminal: iTerm2 on macOS. I haven’t used desktop linux in a while (:sad:), but I’d probably still stick to Tilix and/or Alacritty there. I no longer use hterm (ChromeOS).
VPN: Unless you’re rolling your own, it doesn’t matter too much. Avoid the big players if you can afford to.
Bookmarks: None. Absolutely none. When I need to store transient link lists, I use my Second Brain app to do so.
Read It Later: Ditto as above. Otherwise: starring articles on Miniflux, or keeping Safari tabs open until I get to them, or parking a handful of items in an “inbox” browser bookmarks folder.
Mail Client: The official clients of my email providers. No agnostic app at this time. It’s especially inconvenient to do so on iOS.
Mail Server: N/A.
Launcher: Cmd-Space on macOS a.k.a. Spotlight. I keep Raycast around but I rarely use it. On Linux i3-dmenu-desktop is still my favorite.
Screenshots: Cmd-Shift-4 on macOS, or scrot on Linux.
Menu Bar: Hidden Bar. It’s free, and available as a cask on homebrew.
Containers: Rancher Desktop.
Automation: None. I tried Hammerspoon this year but found no use for it.
Second Brain: A mixture of Obsidian and Logseq. Which I’d really like to end, it would be easier to have a single app to rule them all, as they both support multiple vaults / graphs anyway (e.g. to partition personal vs work notes).
Operating System: Alpine Linux is my current favorite for servers, and I’m biased anyway because I maintain a couple of aports (packages) there. For desktop, it’s awfully hard to use anything other than macOS ever since M1 processors got released. I miss Linux desktop from time to time but realistically it’s no longer an intrinsic goal of mine; that said, I’d likely go back to my beloved Arch Linux should that ever reoccur.
Shell: zsh + grml-zsh-config, no change here. Sometimes I think of migrating to fish, but the POSIX incompability always discourages me to do so.
Terminal Multiplexer: tmux, but only for remote sessions (ssh). Locally I tend to just open new terminal tabs on VSCode and/or iTerm2. Alas, tmux + VSCode do not play well together anyway (citation needed, for another day).

This post was inspired by https://micro.webology.dev/2024/12/19/default-apps.html.

For the correct way to refer to them, pick one of: LLMs, Gen AI, or “AI”. Never drop the quotes when using the plain term! Otherwise you fall into the same trap for using the term “crypto” to distinguish between cryptography and cryptocurrency. ↩︎

— § —

Reply via email

#bestof #dev #macos #pkm

logseq: backlog

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 26 Nov 2024 18:53:22 +0100

♠ Assume you use TODO and DOING for workflow tracking in Logseq.

Assume you use an #instrospect tag.

Problem statement: how to define a single page / live query that aggregates all of the above?

{{query (OR (task TODO DOING) [[introspect]])}}

Unraveling:

[[introspect]] refers to the #introspect tag
A live query can be added with /query, which is represented as {{query }} under the hood.

More information: check out the logseq hub.

— § —

Reply via email

#dev #pkm

★ Anki: custom language card (cont.)

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 22 Sep 2024 13:02:39 +0200

♠ This post builds upon the previous Anki: custom language card.

Searching word boundaries #

When searching for a word such as Mann, results such as Mannschaft come up.

To search accounting for the word boundary, like a typical \bMann\b regex, use w:. In this example: w:Mann.

Searching ignoring accents #

When searching for a word with Umlauts such as Über, you should type it exactly as is.

If you are lazy or do not recall where the umlaut falls, perhaps you would think of searching for uber, however that does not work.

To make it work, prepend nc: to the word. In this case: nc:uber will properly match über. NC stands for non-combining.

Searching word boundaries whilst ignoring accents #

Is it possible to combine the two aforementioned operators? For example, to match für. Unfortunately, it is not. Anki does not support w:nc:fur nor nc:w:fur, which is unfortunate. Schade!

In this case the best compromise would be to search for w:für.

Adding images to flashcards #

It is pretty straightforward: Right click the image in your favorite web browser, copy it, and then paste it (Ctrl/Cmd + V) into Anki. The image is automatically imported.

No-brainer image sources:

Nowadays it would also be natural¹ to use “AI” to generate images.

Providing examples: style #

To illustrate with a concrete example:

1: Ja, genau.

2: Das ist ja komisch.

Affirmative

The structure:

Bold numbers to disambiguate
Underscore the word in question to emphasize it
Italicize everything that is meta or an explanation about the word

To highlight substrings, e.g. Mann in Mannschaft, use underscores².

Tags #

I seldom tag notes because there is no need for categorization, all cards are treated the same way. Tagging is only useful in two scenarios:

for grouping / retrieval: for example, if you want to make custom study sessions for a specific domain / area (e.g. animals, programming, trips)
for provenance annotations: to make it easier to remember where a given note came from (e.g. “textbook”, “my german teacher”, “blog”, “podcast”, “work”)

Adding tags creates the burden of managing and standardizing them. You do not want to spend valuable mental effort derailing from your main task.

Sources #

https://docs.ankiweb.net/searching.html

Albeit deeply unnecessary and wasteful (energy-wise). ↩︎
This principle is not strict. I often interchange bold and underscore. Choose whichever feels more natural in the appropriate context. ↩︎

— § —

Reply via email

#bestof #dev #pkm

★ Anki: custom language card

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 03 Feb 2024 13:02:21 -0300

♠ The more time you spent playing with Anki, the more opinionated you become.

Upon reading Fluent Forever by Gabriel Wyner, I got an itch to create my own Anki note template for learning languages.

The template #

There’s no point explaining how to create a new template; the excellent Anki documentation already does so. Instead, I’ll just list and explain the template I created.

The template is called “Deutsch Language Card 🇩🇪”. It has four fields:

Front
Front Example
Back
Striked

Front and Back come from the built-in template. There’s nothing special about them. I use “Front” for the canonical term in the foreign language I’m learning, and “Back” for the explanation in the base / native language I’m mostly familiar with¹.

Here’s an example:

Front: das Buch
Back: book 📚

Whenever possible I include one or more emojis 😃 in the “Back” field.

The canonicalization of the “Front” field is important, and one of the best (key, even!) features of Anki. It will smartly detect (and prevent!) duplicates from being created. It is case sensitive, therefore it’s important to create one convention and stick to it.

“Front Example” is used to complement the “Front” field. It consists of one or both of the following:

A phrase or sentence containing the Front term.
A picture representing the Front term.

To increase overall retention, it’s always best to add cues familiar to your context.

Add phrases that resonate with you or that you find in textbooks or blog posts that resonate with you. In my experience, adding random phrases is not effective.

Add images that represent well that you’re describing and that resonate with you. Photos that you take yourself are also fair game!

“Striked” is to disambiguate synonyms or false cognates. For example:

Front: der Sturm
Back: storm ⛈️
Striked: das Gewitter, das Unwetter

When I am reviewing the Back card, I want to cue myself not to think about the striked terms.

The source code #

The Front card #

{{Front}} {{tts de_DE:Front}}

{{#Front Example}}
<br>
<i>{{Front Example}}</i> {{tts de_DE:Front Example}}
{{/Front Example}}

The front card includes a text-to-speech sample that is generated on-the-fly. It works very well on macOS and iOS. In fact, that’s main reason why the template is called “Deutsch Language Card” instead of just “Language Card”. The text-to-speech engine is customized to have an accent in the given language. For (High) German, that is de_DE.

The Back card #

{{Back}}

{{#Striked}}
<br><br>
<s>{{Striked}}</s>
{{/Striked}}

The striked terms are ~~striked~~, as you would expect.

Interestingly I prefer to use English most of the time, even though it is not my mother tongue. ↩︎

— § —

Reply via email

#bestof #dev #pkm

Anki: find all notes with an empty field

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 29 Jan 2024 00:06:49 -0300

♠ Gabriel Wyner recommends, in its Fluent Forever book, that each Anki note (card) has at least one image associated to it. This is intended to improve overall retention.

Back when I started my German Anki deck for language learning, I did not add any images. Now I find myself slowly backfilling my already existing notes with images. However, the more images I add, the harder it becomes to find notes without images.

Upon reading the Anki manual I figured out a way to find out which notes are still missing images:

Open Anki.
Open the deck you want to modify – in my case, Languages::German.
Click “Browse”.
Type in deck:current "Front Example:".

“Front Example” is the name of the field of my note template wherein I add images; you should replace it with the corresponding one you use. This syntax isn’t intuitive at all. Initially I was trying something like -"Front Example:*".

— § —

Reply via email

#dev #pkm