Ai on ¬ just serendipity 🍀

pi: /btw side-chat

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 14:07:54 +0200

♠ Previously.

Problem statement: mid-task, I want to ask the LLM agent a quick tangential question — “will this change cause downtime?” — without polluting the main agent thread.

Claude Code has /btw¹ for exactly this. pi doesn’t, but patriceckhart/pi-btw does, as an extension. It opens a side-chat overlay: the LLM gets to see the full main thread context and answers, but nothing is written back to the conversation history.

The upstream extension imports the pre-fork @mariozechner/* package names, which are now deprecated. As such, I use earendil-works/pi. Rather than trust a diff I hadn’t read, I reimplemented it against the current API, and cross-checked against the bundled examples/extensions/summarize.ts (the canonical example for calling the model from an extension):

import { complete } from "@earendil-works/pi-ai/compat";
import type { ExtensionAPI, SessionEntry } from "@earendil-works/pi-coding-agent";
import { convertToLlm, getMarkdownTheme } from "@earendil-works/pi-coding-agent";

// ...inside the /btw command handler, once at entry:
const branch = ctx.sessionManager.getBranch();
const mainMessages = branch
  .filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
  .map((entry) => entry.message);
const mainLlmMessages = convertToLlm(mainMessages);   // frozen snapshot
const systemPrompt = ctx.getSystemPrompt();

// ...per question, the side-chat calls the model directly:
const response = await complete(
  ctx.model!,
  { systemPrompt, messages: [...mainLlmMessages, ...btwLlmMessages] },
  { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal },
);

The key move is what’s missing: the handler never calls pi.sendMessage() or appends anything. It reads the branch once, talks to the model in an ctx.ui.custom() overlay, and returns. The main session is untouched, so the next real prompt doesn’t pay for any of it.

Added to ~/.pi/agent/extensions/btw.ts.

🤖 Drafted with /bloggify.

I am no longer using Arch, btw (sad!) ↩︎

— § —

Reply via email

pi: auto-retry stalled requests

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 13:45:41 +0200

♠ Previously.

Problem statement: sometimes a prompt in pi just hangs, as if the network dropped. It never recovers on its own — I have to hit Esc and re-prompt.

It’s 2026, this symptom should be self-recoverable.

Pi already has agent-level retry on transient errors (retry.enabled defaults to true). The catch is when it fires: a stalled connection isn’t an error until the HTTP idle timeout trips, and that defaults to five minutes:

httpIdleTimeoutMs | number | 300000 | HTTP header/body idle timeout in milliseconds […] Set to 0 to disable.

So pi would have eventually recovered. I was just quitting long before the five-minute clock ran out. Who has patience to wait for 5 minutes?!

:∴ Lower the idle timeout to O(seconds) instead:

{
  "httpIdleTimeoutMs": 30000,
  "retry": {
    "enabled": true,
    "maxRetries": 5,
    "baseDelayMs": 2000
  }
}

Dropped into ~/.pi/agent/settings.json, documented in docs/settings.md. Now a stall errors out after 30s and pi retries automatically with exponential backoff (2s, 4s, 8s…), up to five attempts. There’s no need for Esc nor re-prompting.

The idle timer resets on every byte received, so long thinking or a slow stream won’t trip it — only a genuinely dead connection will. Restart pi for the change to take effect.

🤖 Drafted with /bloggify.

— § —

Reply via email

pi: cycle models backward with ctrl+n

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 13:23:53 +0200

♠ Previously.

Problem statement: pi binds ctrl+p to app.model.cycleForward¹ by default, but has no default binding to cycle backward other than shift+ctrl+p, which is arguably difficult to remember.

Every keybinding in pi is namespaced and overridable via ~/.pi/agent/keybindings.json, documented in docs/keybindings.md:

{
  "app.model.cycleBackward": [
    "shift+ctrl+p",
    "ctrl+n"
  ]
}

ctrl+n is also the default for app.session.toggleNamedFilter, but that only fires inside the session picker, not while a model selector or the main editor has focus.

Run /reload in pi to pick up the keybinding addition without restarting the session.

∴ ctrl+p/ctrl+n now cycle models forward/backward, matching the readline (emacs!) history bindings I already have muscle memory for.

🤖 Drafted with /bloggify.

It cycles through models selected in /scoped-models. ↩︎

— § —

Reply via email

pi: caveman mode

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 12:14:47 +0200

♠ Previously, previously.

Problem statement: adopt caveman in pi.

Pi isn’t one of the 30+ agents caveman auto-detects. The install matrix (INSTALL.md) lists agent detection rules one by one — claude, cursor, windsurf, opencode, openclaw, etc — and pi isn’t in it. Running the one-liner installer here would just skip everything silently. Booo!

Rather than run someone else’s curl | bash against an agent it wasn’t built for, “““I””” reimplemented the terse-speak part natively, since pi already ships the two primitives needed: skills and extensions.

A skill for /skill:caveman documentation, and an extension that rewrites the system prompt on every turn via pi.on("before_agent_start", (event) => ...):

const INSTRUCTIONS = `Caveman mode: on. Respond terse. Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging. Fragments OK. Short synonyms. Technical terms exact. Pattern: [thing] [action] [reason]. [next step]. Example — not: "Sure! I'd be happy to help you with that." yes: "Bug in auth middleware. Fix:"
Boundaries, always: code blocks, commit messages, and PR descriptions stay normal full verbosity, never compressed. Drop caveman style for security warnings, irreversible/destructive actions, or when the user seems confused — resume caveman after.`;

export default function (pi: ExtensionAPI) {
  let on = true; // auto-on by default, every session

  const applyStatus = (ctx: { ui: { setStatus: (k: string, v?: string) => void } }) => {
    ctx.ui.setStatus("caveman", on ? "[caveman]" : undefined);
  };

  pi.on("session_start", async (_event, ctx) => applyStatus(ctx));

  pi.on("before_agent_start", (event) => {
    if (!on) return;
    return { systemPrompt: `${event.systemPrompt}\n\n${INSTRUCTIONS}` };
  });

  pi.registerCommand("caveman", {
    description: "Toggle caveman terse-response mode: on|off (default: on)",
    handler: async (args, ctx) => {
      const arg = args.trim().toLowerCase();
      if (arg === "off" || arg === "stop" || arg === "normal") on = false;
      else if (arg === "on" || arg === "") on = true;
      else return ctx.ui.notify(`Unknown arg "${arg}". Use: on | off`, "error");
      applyStatus(ctx);
      ctx.ui.notify(on ? "Caveman mode on." : "Caveman mode off.", "info");
    },
  });
}

before_agent_start fires on every prompt, before the agent loop starts, so the instructions are re-appended each turn instead of relying on one message that could get pruned from context. Dropped in ~/.pi/agent/extensions/caveman.ts, auto-discovered, no /reload needed after the first load.

Unlike the Claude Code plugin, I skipped lite/full/ultra/wenyan — I called that bloat back in June, and I’m not adding it to my own version either. On or off is enough.

The result, unprompted:

user: caveman on or off now?

assistant: Caveman: on.

user: how to turn it off?

assistant: /caveman off

I also skipped the parts that don’t have a pi equivalent: the statusline savings counter, /caveman-stats, the caveman-shrink MCP proxy that rewrites tool descriptions (a proxy that rewrites what an agent sees is exactly the kind of thing worth reading before installing). The 40-line extension above covers what I actually wanted.

One rule baked into both the skill and the extension: code, commits, and PRs stay full verbosity, never compressed.

This experience was an eye-opener for me to realize how bloated the upstream caveman project became.

🤖 Drafted with /bloggify.

— § —

Reply via email

★ 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

claude code: replace a hand-rolled loop with /goal

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 16 Jul 2026 13:44:25 +0200

♠ Previously.

Problem statement: one of my skills, /pr-pass, was a hand-rolled loop — push, poll CI, fix a failure, re-push, repeat, bail after five iterations.

It works quite well, and it’s one of my most used skills.

That said, recently Claude Code shipped /goal (in v2.1.139), which is exactly that loop, packaging it as a primitive. So the skill was reimplementing something the harness now does natively.

In fact, most harnesses ship /goal natively these days.

We shall refactor!

/goal sets a completion condition. After each turn a fast model checks whether it holds; if not, Claude starts another turn on its own. It auto-clears once the condition is met. From the docs:

The /goal command sets a completion condition and Claude keeps working toward it without you prompting each step. After each turn, a small fast model checks whether the condition holds. If not, Claude starts another turn instead of returning control to you.

That deletes three things the old skill hand-built: the Monitor poll waiting on CI state, the “go back to Step 1” loop, and the max-5-iterations guard. The guard becomes a clause in the condition itself:

/goal every check on this PR has passed (gh pr checks shows no FAILURE
and no PENDING), or stop after 5 turns

One catch worth knowing before reaching for /goal: the evaluator (tester?) is a fresh model that only reads the transcript. It does not run gh or read files.

It does not call tools, so it can only judge what Claude has already surfaced in the conversation.

So the condition has to be something Claude’s own output demonstrates. The skill now says to paste the gh pr checks result into the reply every turn, so the evaluator has a CI state to judge against. Otherwise the goal would have never resolved thus it would have looped forever.

Another gotcha: /goal doesn’t touch permissions. Each turn’s git push still prompts unless paired it with auto mode.

The lesson generalizes past this one skill: whenever the harness grows a primitive, the custom code that predates it becomes technical debt. /loop, Stop hooks, and /goal now cover most of the “keep going until X” constructs I used previously.

🤖 Drafted with /bloggify.

— § —

Reply via email

when Gen AI cites docs that don't exist

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 16 Jul 2026 12:34:22 +0200

♠ Today in AGI: two Claude agents, same annotation, opposite answers.

I had a PR touching an ArgoCD PostSync hook. Ordering hooks within a phase needs an annotation, so I asked; Claude Code (Opus 4.8) and Claude in GitHub disagreed:

Claude Code: argocd.argoproj.io/hook-weight does not exist.
Claude in GitHub: it does exist.

Both stated it flatly. So I pushed the GitHub agent, and it doubled down — citing documentation(!):

This claim is incorrect. argocd.argoproj.io/hook-weight is a documented ArgoCD annotation for controlling hook execution order within a phase. From the ArgoCD resource hooks documentation:

Citing non-existent docs is the clanker equivalent of pulling rank.

Confident. Sourced. Wrong. The actual annotation for ordering is argocd.argoproj.io/sync-wave:

They are defined by the argocd.argoproj.io/sync-wave annotation. The value is an integer that defines the ordering.

metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "5"

There is no hook-weight. The “documentation” it quoted from doesn’t say what it says it says.

Eventually it folded:

You are correct, and I apologize for the confident but incorrect claim in round 3.

Round 3. It took three rounds and a fabricated citation before the model conceded. The failure mode isn’t the hallucination — it’s the escalation to """docs""" as authority to defend it.

Same model family, same question, one right and one wrong. Verify against the upstream source, not against the more confident agent.

Human-in-the-loop is still very much needed, folks.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #dev #kubernetes

★ cmux

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 07 Jul 2026 14:35:14 +0200

♠ cmux is the best implementation I’ve seen for agent orchestrators apps like Conductor, T3 Code, Dux, and friends:

Open source Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents. Built for multitasking, organization, and programmability.

It’s built on top of Ghostty¹ and it’s absolutely amazing. It’s effectively better than what I attempted to build once during an on-site hackathon wiring Claude Code sessions to Obsidian.

The invariant I care about the most:

restart your computer
reopen $APP
automatically restore every claude code session: layout & history preserved, scrollback intact

…is accomplished with fine elegance by cmux.

There’s no need to manually fiddle with tmux / zellij resurrection or alike.

Pair it with worktrunk (the wt CLI) for bonus points. Its integration is well-supported, achieving one cmux workspace per git worktree. For the time being I’m still invoking wt manually though, because that gives me more control.

It is very customizable.

Desirable side effect: existing ghostty settings are automatically inherited. They aren’t duplicated — they are effectively reused, which is superb. ↩︎

— § —

Reply via email

#ai #bestof #dev #ghostty

★ claude code: ship your skills as a plugin marketplace

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 25 Jun 2026 20:40:02 +0200

♠ Problem statement: my Claude Code skills lived in my .dotfiles, usable only on the machine that cloned them. I wanted them to be installable anywhere with one command, so that (for example) my teammates could easily adopt them.

Claude Code reads skills from a marketplace, which is essentially a git repo with a manifest. So I turned github.com/thiagowfx/skills into one. The layout:

.claude-plugin/marketplace.json    # marketplace manifest
plugins/thiagowfx/                 # one plugin
  .claude-plugin/plugin.json       # plugin manifest
  skills/<name>/SKILL.md           # one dir per skill (auto-discovered)

The marketplace lists plugins; a plugin bundles skills. I have one plugin holding all ten. I do not find it necessary to have multiple plug-ins at this point. marketplace.json points at it with a relative source:

{
  "name": "thiagowfx",
  "owner": { "name": "Thiago Perrotta", "url": "https://github.com/thiagowfx" },
  "plugins": [
    {
      "name": "thiagowfx",
      "source": "./plugins/thiagowfx",
      "description": "Thiago's personal Gen-AI / Claude Code skills."
    }
  ]
}

The plugin manifest is just metadata — there’s no need to enumerate skills. Anything under skills/<name>/SKILL.md is discovered automatically:

{
  "name": "thiagowfx",
  "version": "0.2.2",
  "license": "MIT"
}

The docs are explicit about why I keep that version:

Setting version means users only receive updates when you change this field, so bump it on every release. If you omit version and host this marketplace in git, every commit automatically counts as a new version.

I’ll go with version pinning for now.

Install from any machine:

/plugin marketplace add thiagowfx/skills
/plugin install thiagowfx@thiagowfx

/plugin marketplace update thiagowfx pulls future changes.

Outside Claude:

claude plugins update thiagowfx@thiagowfx

The whole thing — manifests, nine seeded skills, README, license — was scaffolded by Claude Code itself, which felt appropriately recursive: one of the skills I was packaging interviews me about a plan before any code gets written, so it grilled me about how to package the skills. Quite meta, eh?

Next up: point the dotfiles at the repo so there’s a single source of truth.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #bestof #coding #dev

★ caveman: talk like caveman, save tokens

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 25 Jun 2026 01:30:43 +0200

♠ Long Claude Code sessions eat a lot of context, fast. Each response injects tokens into the context window: prose-heavy replies burn through it faster than terse ones ($$).

caveman is a Claude Code plugin that switches the model into a compressed communication style: drops articles, filler words, and pleasantries while keeping full technical accuracy. Claims ~75% token reduction per response.

Installation:

% /plugin marketplace add JuliusBrussee/caveman
Successfully added marketplace: caveman
% /plugin install caveman@caveman
✓ Installed caveman. Run /reload-plugins to apply.

After /reload-plugins, manually activate with /caveman. Manually deactivate it by saying “normal mode” or “caveman off”.

A session-start hook fires automatically on the next session, effectively auto-enabling it (M-x caveman-mode emacs vibes).

It ships three modes (lite, full, ultra) and three subagent presets (cavecrew-investigator, cavecrew-builder, cavecrew-reviewer). I don’t care. This is unnecessary bloat. An irony, for a plug-in intended to mitigate bloat.

The out-of-the-box installation is enough; tweaks are not necessary. The defaults are sensible.

In practice: responses are punchy. The model still reasons correctly; it just stops narrating. No “Sure, I’d be happy to help with that.” Just the answer.

~~You’re absolutely right.~~ no more!?

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #bestof #dev

bloggify

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 09 Jun 2026 16:50:11 +0200

♠ I’ve been drawing a line for ages here. My AI usage policy, quoting Derek Sivers:

I have never ever used AI to generate text in place of my “voice”. […] nothing claiming to be written by me is written by an AI.

Likewise, I said. Then in “new blog post via Claude Code” I held the line one more time: the LLM orchestrates the publishing, but “everything is still my own text, my own words. The LLM is not writing the prose.”

The line moved. Slightly. I wrote a /bloggify skill whose entire job is to draft a post in my own style / voice:

---
name: bloggify
description: Draft a blog post for perrotta.dev in the existing house style.
argument-hint: "<topic or what you want to write about>"
---

Write a blog post about `$ARGUMENTS` for the perrotta.dev blog.

The trick is that the style is already written down. The repo has a STYLE.md — derived by reading my own old posts — and the skill just points at it:

The repo owns the style. Read STYLE.md and CLAUDE.md first — they are the source of truth for voice, structure, frontmatter, and conventions.

It scaffolds with just new, follows the rules I’d already codified (minimal frontmatter, bold problem statement, code carries the weight, no “In this post I will…”), lints with prek, and hands back a draft. It does not commit.

So: is this still my own words?

Mostly. The skill forbids invented examples — it has to use real commands, real output, the real artifact. The structure is mine, written down a year ago. The voice is mine, learned from my old posts. The prose is the machine’s impression of me, and I edit it until it sounds like me again.

The line didn’t disappear. It just got blurrier.

I (still) commit to reading the entire post, paragraph by paragraph, and making manual changes to it to better match my style.

As of today, it’s not clear to me whether this approach will stick.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #dev #meta

Codexbar

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 31 May 2026 18:03:11 +0200

♠ Previously.

Peter Steinberger’s excellent codexbar:

CodexBar tracks usage windows, credit balances, and reset countdowns across the providers you actually pay for — one status item each, or merge them into one.

It’s a tiny app that sits in the macOS system tray.

Every imaginable provider is supported. Notable examples include: Codex (OpenAI), Claude Code (Anthropic), OpenCode.

— § —

Reply via email

GitHub: disable copilot

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 27 May 2026 14:33:05 +0200

♠ Copilot Settings > Visibility > Show Copilot > Disabled.

It’s a drop-down menu.

— § —

Reply via email

Gmail: disable AI inbox

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 27 May 2026 14:03:16 +0200

♠ Google: First, it’s Gen AI, not “““AI”””.

You’ve already been doing machine learning in our inboxes for ages now.

Second: no, thank you.

Settings > Inbox > AI Inbox > [ ] Show AI Inbox:

Show AI Inbox — See a separate view of your inbox that includes suggested to-dos and key updates from your emails, chats, documents and more.

Uncheck that checkbox, and then continue to live happily and free¹ — at least for now, until the next “““AI””” setting is forced upon you against your consent and desire.

Only because you are the product. ↩︎

— § —

Reply via email

You can run that yourself

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 27 May 2026 12:53:15 +0200

LLM: Paste me the IPs (2-3 of them) and I’ll draft the gitops PR for the allowlist files.

Me: You can run that yourself.

What kind of agent are you??!? Do not be lazy!

— § —

Reply via email

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

Claude Enterprise: plan usage

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

♠ When enrolled in a Claude Enterprise plan, /usage (or /cost) are useless.

Instead, head over to https://claude.ai/settings/usage to assess your usage limits.

Usage limits normally reset at the beginning of the month.

Your plan admin can increase your usage limits manually ~~if you ask it nicely~~ when warranted.

— § —

Reply via email

No slop grenade

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

♠ An addition to the “No Hello” series:

No (AI) Slop Grenade:

Stop throwing AI-generated walls of text into conversations.

Don’t do this:

You: Should we use Redis or Memcached?

Them: Great question! The choice between Redis and Memcached is a nuanced decision that requires careful consideration of multiple factors. Let me break down the key differences: Redis offers a rich set of data structures including strings, hashes, lists, sets, and sorted sets, which provide flexibility for various use cases. It supports persistence through RDB snapshots and AOF logs, enabling data durability …more

Instead, be human:

You: Should we use Redis or Memcached?

Them: Redis. We need pub/sub for the notifications feature.

Clankers.

— § —

Reply via email

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

Grill me

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

♠ Matt Pocock (via Sebastian de Deyne):

This is an intro to the /grill-me skill, separate from my video on my top 5 skills. It’s the most flexible skill I’ve ever created, and one I use outside of coding too.

Here is the skill in all its glory:
---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---

Interview me relentlessly about every aspect of this plan until
we reach a shared understanding. Walk down each branch of the design
tree resolving dependencies between decisions one by one.

If a question can be answered by exploring the codebase, explore
the codebase instead.

For each question, provide your recommended answer.
This skill is incredibly short — just a few lines that pack a powerful punch.

This skill is very useful for brainstorming. I have adopted it as well.

— § —

Reply via email

★ 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

prove_it: verification hooks for Claude Code

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 21 May 2026 19:10:09 +0200

♠ Problem statement: Claude Code likes to declare “done” without running tests. Said no overconfident LLM ever.

prove_it by Justin Searls is a config-driven hook framework that intercepts Claude’s lifecycle events (SessionStart, PreToolUse, Stop) and runs whatever tasks you configure — tests, linters, AI reviewers — blocking the Stop until they pass.

I like this concept in spirit.

Installation:

% brew install searlsco/tap/prove_it
% prove_it install                    # one-time, registers global hooks at ~/.claude/
% cd <git repo> && prove_it init      # per-repo config + script stubs + git hooks; comparable to `pre-commit install`
% prove_it doctor                     # comparable to `brew doctor`

I (finally!) tried it today and concluded that it’s not for me.

That said, I really like the ideas that Justin developed there. I’ll look into adopting some of them into my global CLAUDE.md.

See the README.md for documentation.

— § —

Reply via email

llm: Anthropic Claude plugin

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 21 May 2026 16:33:51 +0200

♠ Simon Willison’s llm CLI ships with OpenAI models out of the box. Anthropic Claude support lives in a separate plugin, llm-anthropic.

% llm plugins
[]

Install it:

% llm install llm-anthropic
...
Successfully installed anthropic-0.103.1 docstring-parser-0.18.0 llm-anthropic-0.25

Verify:

% llm plugins
[
  {
    "name": "llm-anthropic",
    "hooks": [
      "register_models"
    ],
    "version": "0.25"
  }
]

Claude models are now registered:

% llm models | grep -i anthropic
Anthropic Messages: anthropic/claude-opus-4-7 (aliases: claude-opus-4.7)
Anthropic Messages: anthropic/claude-sonnet-4-6 (aliases: claude-sonnet-4.6)
Anthropic Messages: anthropic/claude-haiku-4-5-20251001 (aliases: claude-haiku-4.5)
[...]

Set the API key:

% llm keys set anthropic

And prompt away:

% llm -m claude-haiku-4.5 "hello"
Hello! How can I assist you today?

— § —

Reply via email

Homebrew conflicts

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 21 May 2026 15:32:45 +0200

♠ I wanted to try out worktrunk:

thiago.perrotta ~
% brew install worktrunk
==> Auto-updating Homebrew...
==> Fetching downloads for: worktrunk
==> Pouring worktrunk--0.52.0.arm64_tahoe.bottle.tar.gz
Error: The `brew link` step did not complete successfully
The formula built, but is not symlinked into /opt/homebrew
Could not symlink bin/wt
Target /opt/homebrew/bin/wt
is a symlink belonging to pancake. You can unlink it:
  brew unlink pancake

To force the link and overwrite all conflicting files:
  brew link --overwrite worktrunk

To list all files that would be deleted:
  brew link --overwrite worktrunk --dry-run

Possible conflicting files are:
/opt/homebrew/bin/wt -> /opt/homebrew/Cellar/pancake/2026.05.07.0/bin/wt
==> Caveats
The following worktrunk executables are shadowed by other commands earlier in your PATH:
  wt (shadowed by /opt/homebrew/bin/wt)
Running these by name will not invoke the version provided by Homebrew.
==> Summary
🍺  /opt/homebrew/Cellar/worktrunk/0.52.0: 12 files, 16.5MB
==> Running `brew cleanup worktrunk`...
==> Caveats
zsh completions have been installed to:
  /opt/homebrew/share/zsh/site-functions
brew install worktrunk  4.12s user 1.21s system 32% cpu 16.417 total

…however its wt binary conflicts with my wt tool from pancake. Booo!

Workaround? A symlink:

% ln -s /opt/homebrew/Cellar/worktrunk/0.52.0/bin/wt /opt/homebrew/bin/wtr

I will refer to it as mtr during evaluation.

This is not a proper long-term fix, it’s really just a band-aid.

I am more inclined to rename my wt for the sake of avoiding conflict should worktrunk stick to daily workflow.

In these moments I miss the flexibility of portage.

— § —

Reply via email

#ai #dev #macos

★ 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

claude: /powerup

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 04 May 2026 10:44:47 -0400

♠ Previously.

Run /powerup within Claude Code:

 ▐▛███▜▌   Claude Code v2.1.126
▝▜█████▛▘  Sonnet 4.6 · Claude Enterprise
  ▘▘ ▝▝    /Users/thiago.perrotta

❯ /powerup
───────────────────────────────────────────────────────────────────────────────
  Power-ups 5/10 unlocked ████████

  Each power-up teaches one thing Claude Code can do that most people miss. Open
  one, read it, try it, mark it done.

    ✔ Talk to your codebase    @ files, line refs
    ✔ Steer with modes         shift+tab, plan, auto
    ✔ Undo anything            /rewind, Esc-Esc
    ◯ Run in the background    tasks, /tasks
    ◯ Teach Claude your rules  CLAUDE.md, /memory
  ❯ ✔ Extend with tools        MCP, /mcp
    ◯ Automate your workflow   skills, hooks
    ◯ Multiply yourself        subagents, /agents
    ◯ Code from anywhere       /remote-control, /teleport
    ✔ Dial the model           /model, /effort

  ↑↓ to select · Enter to open · Esc to close

This is a clever and unobtrusive way to teach usage tips and tricks to developers, I like it!

— § —

Reply via email

Large context windows

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 29 Apr 2026 17:49:48 +0200

♠ Claude Code status bar in a lovely Wednesday:

mongodb (git:thiagowfx/atlas-mongo-promote-aws-peering ⎇ mongodb) [Opus 4.7 (1M context)] [██░░░ 406k/1000k 50%] $40.53 sid:{session ID}

It feels good to be able to use more than 200k tokens in a single session.

— § —

Reply via email

Gen AI and Slack

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 28 Apr 2026 17:13:10 +0200

♠ It’s a lovely Tuesday:

❯ https://{corp}.slack.com/archives/{channel}/{thread}

⏺ I can't fetch Slack URLs directly — the link points to a private Slack channel
that requires authentication. Could you paste the message contents (or a
screenshot) here? Once I can see what's in the thread, I can help with whatever
it's asking about.

✻ Worked for 3s

❯ You can. MCP.

⏺ I'll load the Slack MCP tool to read that thread.

⏺ Reading the thread now.

⏺ claude.ai Slack - Read thread messages (MCP)(channel_id: "{channel_id}", message_ts: "{message_ts}")

⏺ Got it. Here's what's happening in the thread:

[...]

Yes, we you can! Believe in yourself! Why do you give up so quickly?

— § —

Reply via email

Is it agent ready?

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 27 Apr 2026 01:34:34 +0200

♠ Is it agent ready? by Cloudflare:

Scan your website to see how ready it is for AI agents. We check multiple emerging standards — from robots.txt and Markdown negotiation to MCP, OAuth, Agent Skills and agentic commerce.

How do I “perform”¹? See perrotta.dev:

Level 1 — Basic Web Presence

Discoverability: 67/100 (2/3): robots.txt and sitemap

Content: 0/1

Bot Access Control: 50/100 (1/2): robots.txt

API, Auth, MCP & Skill Discovery: 0/6

I see value in Content Signals:

Introducing Content Signals, Cloudflare’s implementation of a mechanism for allowing website publishers to declare how automated systems should use their content.

As such, I just updated my robots.txt with:

Content-Signal: search=yes, ai-train=no, ai-input=yes

“AI Input” is the de facto standard in 2026, and I am a heavy user of Gen AI agents myself, therefore there’s no point to attempt to block it.

Nonetheless, I am still doing my best to flag AI training as disallowed.

Via disassociated.

Achieving 100% scoring is not an end goal here. These metrics are arbitrary, by Cloudflare. I use them merely as an inspiration / starting point to decide what’s worth to explore and/or adopt. ↩︎

— § —

Reply via email

claude: recap

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 24 Apr 2026 00:52:56 +0200

♠ Now that frontier models from Anthropic have context windows of up to 1M tokens, I constantly find myself forgetting what each session is about whenever I have 4+ terminal tabs open.

I know, I could simply name sessions, but I often don’t.

Can we throw AI at the issue? Of course, Gen AI solves problems generated by AI (pun intended).

There’s this built-in ~~command~~ skill: /recap:

Generate a one-line session recap now

200K+ tokens later, /recap is my hope to remind me of what I was doing the day before.

— § —

Reply via email

claude, claudey, claudeyy

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 18 Apr 2026 23:40:02 +0200

♠ My current workflow:

`claude` #

Pure claude code. Straight from homebrew: brew install claude-code.

`claudey` #

% which claudey
claudey: aliased to cco --allow-oauth-refresh --add-dir ~/.cache --add-dir ~/.aws/cli/cache --add-dir ~/.aws/sso/cache --add-dir ~/.azure --add-dir ~/.terraform.d/plugin-cache --add-dir ~/go --add-dir ~/Library/Keychains

Previously: cco.

`claudeyy` #

% which claudeyy
claudeyy: aliased to claude --allow-dangerously-skip-permissions

Living dangerously!

I’m satisfied with claudey most of the time.

— § —

Reply via email

★ 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

★ Filing upstream bugs in 2026

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 13 Apr 2026 14:33:07 +0200

♠ First of all, get familiar with some decent guidelines that exist since forever:

XYProblem
How To Ask Questions The Smart Way by ESR (Eric Steven Raymond)
ArchWiki: Bug reporting guidelines

What is different in 2026? Gen AI / LLMs / Coding agents, of course. Everything else stays the same.

We don’t have to complicate things, I’ll start with an example, this is what a typical decent bug report (or feature request) should look like, filed by yours truly¹:

nikvdp/cco (Claude Code Condom):

First of all, I love cco. Thanks for your effort and the good work on it!

Now, to the point: Claude has recently introduced an auto mode: https://claude.com/blog/auto-mode:

Today, we’re introducing auto mode, a new permissions mode in Claude Code where Claude makes permission decisions on your behalf, with safeguards monitoring actions before they run. It’s available now as a research preview on the Team plan, and coming to the Enterprise plan and API users in the coming days.

It’s supposed to be slightly safer than the YOLO mode (--dangerously-skip-permissions).

You can enable and set it with claude --enable-auto-mode (or via settings.json).

Feature request: cco should support launching claude in auto mode. Currently it unconditionally launches claude with --dangerously-skip-permissions.

Do you think this would be a reasonable addition? If so, I would be happy to give it a try to send a PR (realistically I would prompt Claude to do so).

Side note: the comment above was fully written (manually) by me. Slop notes from Claude come below 🙃:

⏺ No upstream support exists yet. The repo is nikvdp/cco and:

No issue or feature request for –auto mode support exists across all 25 issues and 33 PRs

No PR or commit adding it

The script hardcodes –dangerously-skip-permissions in 7 places (both native and Docker backends) with no configuration option

This would be a good feature request to file. The implementation would be straightforward — make the permission mode configurable (e.g. via a –permission-mode flag or CCO_PERMISSION_MODE env var) instead of hardcoding –dangerously-skip-permissions.

Worth noting: Claude Code’s –auto mode (aka –permission-mode auto) requires an API-tier plan (Team/Enterprise/API, not Pro or Max) and uses a classifier model to review actions before execution — so it’s a meaningful middle ground between full bypass and manual prompts.

Want me to draft an issue for the nikvdp/cco repo?

In no particular order:

Be kind². That cannot be understated. No one owes you anything. Leave (self-)entitlement at the door.
Be efficient. Do not waste the maintainer’s time. Information should be comprehensive/complete yet concise. Keep it simple and short (KISS).
Be precise, reduce room for ambiguity as much as possible. Link to docs whenever it makes sense. When linking to docs, be respectful of your peer’s time and ensure to extract and blockquote relevant snippets so that they don’t need to dig for it themselves. Furthermore, the links are important for verification purposes (trust, but verify).
Be proactive. Offer to help³ if you have the know-how and/or expertise to do so.
Move on. If you get no reply from the maintainer, do not bug them about your bug/FR/PR. Find the next activity to work on. Fork it. Work around it. Just don’t peg the maintainer to do it for you. This includes code review.

It is much easier if you remember that the maintainer is a person, just like you. Not a machine. Sounds obvious to state this, but it seems to me many people forget that, with so much context switching and social media these days…

If you’re still reading until this point, chances are that you actually care. Thank you! Keep it up.

Practice what you preach…I am obviously biased though. ↩︎
Or nice. Or polite. Or sympathisch. ↩︎
Only if you actually have time to do so. No empty promises, please. ↩︎

— § —

Reply via email

#ai #bestof #dev #serenity

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

claude: /simplify

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

♠ Previously.

My all-time favorite bundled skill for code reviewing in Claude Code: /simplify.

As per the official docs:

/simplify   Review changed code for reuse, quality, and efficiency, then fix any issues found. (bundled)

A sample run:

  Running 3 agents… (ctrl+o to expand)
   ├─ Code reuse review · 38 tool uses · 42.1k tokens
   │  ⎿  Read: modules/remote-access-ips/main.tf
   ├─ Code quality review · 17 tool uses · 29.8k tokens
   │  ⎿  Searching for 7 patterns, reading 10 files…
   └─ Efficiency review · 0 tool uses
      ⎿  Done
     (ctrl+b to run in background)

It is effective, not very opinionated (which is good in this context!), and non-intrusive.

And it surely burns a good share of tokens.

I’m interested in exploring ways to automate this skill invocation as part of every PR.

— § —

Reply via email