I touch my shitty headphones sometimes during FaceTime calls and it just kills the call

How can I stop that from happening on macOS?

> Open the iPhone default camera app, turn on pro res, there should be a little “free resources” button that appears.

But I can't see that anywhere

Are there more techniques too?

So ben and elma have different vowel realisations, ben is a more open vowel than the e in elma. But GPT just told me they are the same phoneme

Is that true?

So ben and elma have different vowel realisations, but GPT just told me they are the same phoneme

Is that true?

Every time I press right command right alt and i, Codex spawns in my face saying "Enable App Shots??"

I have this problem with other apps too

I cannot believe Apple and macOS allow this

And how do I stop it from happening?

The Codex app makes worktrees in all kinds of random locations across my drive. Sometimes in /tmp sometimes in ~/.codex

None of those are acceptable

I want it to make worktrees in the project folder.

~/Projects/my-project/... all worktrees must go here (sibling to the original repo)

I also want it to run a script ./setup_worktree.sh in every new worktree it makes. And when it deletes a worktree, I want it to run ./cleanup_worktree.sh first.

How can I make it do all that?

Based on examples of role-based access control vs object-capability, it looks like object-capability is just RBAC behind a function:

RBAC Style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);
  const target = await getUser(req.params.targetUserId);

  const updatedUser = await userAdminService.deactivateUserRBAC(actor, target);

  res.json(updatedUser);
});

async function deactivateUserRBAC(actor: User, target: User) {
  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  target.status = "deactivated";
  target.deactivatedBy = actor.id;

  return saveUser(target);
}

OPAC style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);

  const deactivateTargetUser =
    await userAdminAuthority.getDeactivateUserCapability({
      actorId: actor.id,
      targetUserId: req.params.targetUserId
    });

  const updatedUser = await deactivateTargetUser.invoke();

  res.json(updatedUser);
});

type DeactivateUserCapability = {
  invoke(): Promise<User>;
};

async function getDeactivateUserCapability(input: {
  actorId: string;
  targetUserId: string;
}): Promise<DeactivateUserCapability> {
  const actor = await getUser(input.actorId);
  const target = await getUser(input.targetUserId);

  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  return {
    async invoke() {
      target.status = "deactivated";
      target.deactivatedBy = actor.id;

      return saveUser(target);
    }
  };
}

If you inline the getDeactivateUserCapability function, both become literally the same code.

Is the whole point of OPAC really only to abstract away RBAC? What are the best ways to keep that enforced across a whole codebase?

I can't figure out why object capability systems are of any use at all.

I keep asking AI to write me examples, here is one example:

RBAC Style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);
  const target = await getUser(req.params.targetUserId);

  const updatedUser = await userAdminService.deactivateUserRBAC(actor, target);

  res.json(updatedUser);
});

async function deactivateUserRBAC(actor: User, target: User) {
  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  target.status = "deactivated";
  target.deactivatedBy = actor.id;

  return saveUser(target);
}

OPAC style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);

  const deactivateTargetUser =
    await userAdminAuthority.getDeactivateUserCapability({
      actorId: actor.id,
      targetUserId: req.params.targetUserId
    });

  const updatedUser = await deactivateTargetUser.invoke();

  res.json(updatedUser);
});

type DeactivateUserCapability = {
  invoke(): Promise<User>;
};

async function getDeactivateUserCapability(input: {
  actorId: string;
  targetUserId: string;
}): Promise<DeactivateUserCapability> {
  const actor = await getUser(input.actorId);
  const target = await getUser(input.targetUserId);

  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  return {
    async invoke() {
      target.status = "deactivated";
      target.deactivatedBy = actor.id;

      return saveUser(target);
    }
  };
}

If you inline the getDeactivateUserCapability function, it's literally the same code.

And there's nothing about the type system that makes that inlining illegal to do. And the LLM that writes the getDeactivateUserCapability function in the first place could make just as many mistakes as the LLM that writes the deactivateUserRBAC function in an RBAC codebase.

I have seen 10 examples like this in the last hour, I can't get AI to help me figure out why OCAP is useful.

How is OCAP meant to be applied to be useful?

I can't figure out why it is any use at all.

I keep asking AI to write me examples, here is one example:

RBAC Style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);
  const target = await getUser(req.params.targetUserId);

  const updatedUser = await userAdminService.deactivateUserRBAC(actor, target);

  res.json(updatedUser);
});

async function deactivateUserRBAC(actor: User, target: User) {
  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  target.status = "deactivated";
  target.deactivatedBy = actor.id;

  return saveUser(target);
}

OPAC style

app.post("/users/:targetUserId/deactivate", async (req, res) => {
  const actor = await getCurrentUser(req);

  const deactivateTargetUser =
    await userAdminAuthority.getDeactivateUserCapability({
      actorId: actor.id,
      targetUserId: req.params.targetUserId
    });

  const updatedUser = await deactivateTargetUser.invoke();

  res.json(updatedUser);
});

type DeactivateUserCapability = {
  invoke(): Promise<User>;
};

async function getDeactivateUserCapability(input: {
  actorId: string;
  targetUserId: string;
}): Promise<DeactivateUserCapability> {
  const actor = await getUser(input.actorId);
  const target = await getUser(input.targetUserId);

  if (!actor.roles.includes("Admin")) {
    throw new Error("Forbidden");
  }

  return {
    async invoke() {
      target.status = "deactivated";
      target.deactivatedBy = actor.id;

      return saveUser(target);
    }
  };
}

If you inline the getDeactivateUserCapability function, it's literally the same code.

And there's nothing about the type system that makes that illegal to do.

I have seen 10 examples like this in the last hour, I can't get AI to help me figure out why OCAP is useful

How is OCAP meant to be applied?

I don't want to pay gajillions of dollars to buy google drive storage nor do i want to give all my private chats to google

Please could someone recommend me some fun novels or fictional stories I can read that also get deep into or inspire interest in linguistics?

I am using Opus 4.8 with 1M context and high effort.

On a fresh start of Claude Code, my context usage is

❯ /context 
⎿  Context Usage
   ⛁ ⛁ ⛁ ⛀ ⛀ ⛁ ⛀ ⛀ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Opus 4.8 (1M context)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   claude-opus-4-8[1m]
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   24.1k/1m tokens (2%)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 3.9k tokens (0.4%)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 12.9k tokens (1.3%)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: 1.2k tokens (0.1%)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Memory files: 3.9k tokens (0.4%)
   ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛀   ⛁ Skills: 2.3k tokens (0.2%)
                                             ⛁ Messages: 8 tokens (0.0%)
                                             ⛁ Compact buffer: 3k tokens (0.3%)
                                             ⛶ Free space: 972.9k (97.3%)

   Memory files · /memory
   ├ ~/.claude/CLAUDE.md: 28 tokens
   ├ CLAUDE.md: 2.7k tokens
   └ ~/.claude/projects/-my-project/memory/MEMORY.md: 1.2k tokens

   Skills · /skills

   Project
   └ ~730 tokens

   Built-in
   ├ claude-api: ~360 tokens
   ├ update-config: ~240 tokens
   ├ deep-research: ~160 tokens
   ├ code-review: ~130 tokens
   ├ schedule: ~130 tokens
   ├ run: ~120 tokens
   ├ loop: ~110 tokens
   ├ verify: ~90 tokens
   ├ keybindings-help: ~80 tokens
   ├ fewer-permission-prompts: ~60 tokens
   ├ simplify: ~60 tokens
   ├ security-review: ~30 tokens
   ├ init: ~20 tokens
   └ review: < 20 tokens

Is that wildly different from everyone else's?

So what could I do to make claude code work faster?

It is when it gets to the stage of applying edits that I think it is painfully slow.

Maybe I could parallelize editing somehow?

Do people who dance with LED hoops program them to do lights in time with the music?

Is there a library of pre-programmed songs I can just load and dance to with the the hoop?

In SSB is [ɪi] or [ɪj] a more accurate transcription of the vowel in fleece? And [ʊu] [ʊw] for "goose"?

If you were plotting web frameworks in a feature space, what would be on the axes?

Maybe there would be an axis for each of

• runtime ←→ compiletime
• procedural ←→ declarative
• explicit ←→ implicit
• local reasoning ←→ global reasoning (self contained ←→ context-dependent)
• control flow oriented ←→ dataflow oriented
• "one obvious way to do it" ←→ extremely unopinionated and flexible

I'm probably missing some that might be way more useful. I haven't used many frameworks yet.

Which frameworks are the most unique from a, writing-code-in-it-as-a-developer (not implementation) perspective?

And which framework do you find to be the most fun or to have the lowest cognitive load?

If you were plotting web frameworks in a feature space, what would be on the axes?

Maybe there would be an axis for each of

• runtime ←→ compiletime
• procedural ←→ declarative
• explicit ←→ implicit
• local reasoning ←→ global reasoning (self contained ←→ context-dependent)
• control flow oriented ←→ dataflow oriented
• "one obvious way to do it" ←→ extremely unopinionated and flexible

I'm probably missing some that might be way more useful. I haven't used many frameworks yet.

Which frameworks are the most unique from a, writing-code-in-it-as-a-developer (not implementation) perspective?

And which framework do you find to be the most fun or to have the lowest cognitive load?