Oscar Marion

Upgrade all Homebrew casks with --greedy

Oscar Marion — Mon, 19 Oct 2026 00:00:00 GMT

brew upgrade skips casks that update themselves, like VS Code, Zed or Raycast. Add --greedy to make Homebrew upgrade them too.

These casks are set to auto_updates true, and Homebrew leaves them to the app’s own updater (Homebrew FAQ).

To see which casks --greedy adds:

brew outdated --cask --greedy

Then upgrade them. The flag also picks up casks with version :latest:

brew upgrade --cask --greedy

To make it the default, add this to ~/.zshrc:

export HOMEBREW_UPGRADE_GREEDY=1

--greedy compares the cask with Homebrew’s install record, not with the installed app. If an app already updated itself, Homebrew reinstalls the cask’s version anyway.

Tailscale HTTPS certificates on TrueNAS

Oscar Marion — Sun, 11 Oct 2026 00:00:00 GMT

I have been using Tailscale in my homelab for over two years at this point, and I use their MagicDNS feature to access my TrueNAS server on the go: https://truenas.tail123456.ts.net.

After adding TrueNAS to a tailnet (official guide), the browser flags its web UI as not secure, since TrueNAS has no certificate for its ts.net name. Let’s fix that.

In reality, the certificate warning matters less on a tailnet, since WireGuard encrypts the traffic between your devices. So in my case, this is more of a “cosmetic” endeavor.

Requirements

MagicDNS and HTTPS Certificates enabled in the Tailscale admin console: Network → DNS.
The TrueNAS Tailscale app is installed and connected.

Get the certificate and key

You can run the commands below from the Tailscale container shell. From the TrueNAS shell, prefix each command with docker exec ix-tailscale-tailscale-1 (run docker ps if you’re unsure of the container name).

1. Get the certificate

Tailscale asks Let’s Encrypt for a certificate for the NAS’s tailnet name. Use the exact name shown on the Machines page of the admin console.

You get four PEM blocks: your certificate, then Let’s Encrypt’s chain of trust. Copy all four.

tailscale cert --cert-file - <host>.<tailnet>.ts.net

2. Get the private key

This prints the private key that matches the certificate. Paste it into TrueNAS, nowhere else.

tailscale cert --key-file - <host>.<tailnet>.ts.net

Import the certificate

In TrueNAS: Credentials → Certificates → Import

Name: anything, but include today’s date so you can tell certificates apart at the next renewal
Add to Trusted Store: off. The trusted store holds the certificates TrueNAS trusts when it connects to other servers. Your own certificate doesn’t belong there.
Certificate: all four PEM blocks from step 1, in order
Private Key: the private key from step 2
Passphrase: leave empty

Then select Import.

Apply it to the TrueNAS GUI

System → General Settings → GUI → Settings → GUI SSL Certificate. Save and wait for the web service to restart.

Cleanup

You can now go back to Credentials → Certificates and delete any expired Tailscale certificates.

You now have a valid HTTPS connection every time you connect to your TrueNAS GUI using the *.ts.net MagicDNS subdomain. Certificates have a 90-day expiry, so you’ll need to run these steps again. I will look into automating this process in the future, but for now that’s all I’ve got.

Bring back old Opus in Claude Code

Oscar Marion — Sat, 19 Sep 2026 00:00:00 GMT

I still use Opus 4.6 and 4.8 regularly, as I often find Opus 5 too verbose (and Fable too expensive). Here is how to add them back to the /model picker.

Add this to ~/.claude/settings.json. The rows appear after the built-in ones:

"modelPicker": {
  "options": [
    { "model": "claude-opus-4-8", "label": "Opus 4.8" },
    { "model": "claude-opus-4-6", "label": "Opus 4.6" },
  ]
}

Set modelPicker.replaceBuiltInOptions: true to show only these rows.

Craft over prompts

Oscar Marion — Mon, 24 Nov 2025 00:00:00 GMT

I ran out of Claude Code tokens the other day. And froze. Eight years into my software engineering career, dozens of projects, thousands of lines shipped… And yet, for a few minutes, it felt like I had forgotten how to write code. That’s when I realized I needed to take a step back. A little late, I know.

Most software engineers I work with have been using AI coding tools for years. We have seen the models evolve from barely usable to genuinely impressive.

There have been skeptics all along, often experienced software engineers for whom this whole thing is 90% marketing and 10% reality. But in the past few weeks, I see more and more of the ones who had previously embraced AI coding now taking a break from it.

I started using ChatGPT “research preview” in 2022 and gradually adopted various models in my day-to-day work as the IDE integrations improved. It got really good, really fast. In just three years, we went from copying code back and forth with a browser-based chatbot, to having code autocompletion in the editor, to AI agents finally letting me drink my matcha latte in peace while doing all the work for me.

Why would anyone want to go back?

“Just build something”

Take a look at how the industry views our work. For business people, code is a black box sitting between ideation and product. It’s a highly complex, expensive step that they hope will enable sales. But it comes with many scary words they don’t really understand: technical debt, scaling issues, regressions. Believe me, if they could avoid code altogether, they would.

In fact, they have tried. Think about the rise of “no-code” tools. Sure, there is still code behind them, but you only see the GUI. And if there’s a bug, it is another company’s problem. Just like with serverless, servers haven’t gone anywhere; they’re just for someone else to scale and deploy to.

Meet the new kid in town: vibe-coding. Write a prompt with your idea, wait, nudge, repeat, ship, make money. That’s the dream products like Lovable, Bolt or v0 are selling. You don’t need to be a software engineer. You don’t need to see the code. “Just build something,” and they’ll do the rest. But when something goes wrong, whose problem is it?

Whether you like it or not, you are responsible for the code you ship to end-users. And having to fix code you did not write, let alone understand, is not a good place to be. Especially if your shiny new SaaS handles any kind of personal or sensitive data.

Software engineers are not immune to this. In fact, back in the day, we copy-pasted code from StackOverflow, sometimes bitterly regretting it. But the scale and speed at which these models take us is unprecedented. We started by offloading boring tasks: write tests, create dummy data, document code, rename symbols. As the models got better, we asked them to debug errors, create features. Then, we let them execute commands on our machines.

Let’s be honest, it sometimes feels like magic. And sometimes, it deletes the production database.

“You’re absolutely right!”

Here is the pattern that finally clicked for me: these models speak beautifully, but they forget quickly. They’re confident, but they hallucinate. They flatter you, but only because they’re optimized to please.

There is a disturbing dissonance between the honeymoon phase the industry is in and the growing red flags raised by the community. If you’ve ever watched a model confidently walk you down a path that doesn’t exist, invent facts, or do the opposite of what it’s saying… you know the feeling.

Big Tech executives love to declare that 25% to 30% of their code is now written by AI, treating it like a KPI. But they rarely mention how much time engineers spend reviewing AI-generated code and cleaning up the mess, and how frustrating that work actually is.

Work that didn’t spark joy

I kicked off a side project a little while ago. I wanted to try Svelte 5. After the initial scaffolding, I let Claude Code drive most of the basic features while I wrote the documentation and refined my prompts.

In just a few hours, I got the basic features to work. That sounds like a massive time saver, right? But after the initial prototype, most of my time was spent prompting it to remove all the over-engineered abstractions and break up the 500+ line files it spewed.

The tool that was supposed to give me superpowers had me waiting between each prompt, wondering if its non-deterministic neural network would produce anything good next.

Between the constant back-and-forth every time it failed to deliver working code and the hours spent compacting the context window and optimizing my prompts, this ended up putting a weird distance between me and the project. I became a middle manager instead of learning about Svelte 5. And I was not having much fun.

The indigo trend

There are endless ways to be creative. Mine is to start projects from zero, having to figure out the user experience, the code architecture, the right patterns. Finding good variable names. Experiment. Make mistakes. Going through libraries documentation. Refactor.

Have you heard of the indigo trend? AI-generated UIs almost always use the same color: indigo-500. Wes Bos interviewed Tailwind’s creator about it, and it turns out the reason is simple: it was Tailwind UI’s default color at a time when many models were in their training phase.

The funny part is that it’s only going to get worse, as future models are being trained on that growing sea of generic purple landing pages. These models are trained on existing code; they output existing patterns, sometimes verbatim. It is harmless enough with color palettes, but not when it regurgitates a security vulnerability.

At some point, the so-called efficiency gains aren’t worth the loss of craft. When the hype settles, I believe we should (and will) use LLMs like any other tool: for the small set of jobs they’re actually good at.

My AI-detox

Here is the plan. For now, I am going back to basics. No Artificial Intelligence. Just me, my laptop, and a trusty old matcha latte.

So far, so good. It feels slower to kick off a project, but writing code brings much more joy than vibe-coding my way into oblivion. And what’s more, it doesn’t even feel slower over a few days of work.

If you’re not taking an AI coding break like me, I’ve come up with a few rules for my future self, for when I will reintroduce these tools to my workflow.

Own what you ship

→ If you can’t fully explain each line, don’t merge it.

Disable AI in your IDE

→ Uninstall CLI agents, and use models only in the browser when necessary. Or in Raycast. But keep it away from your editor; it’s too tempting.

Learn the basics

→ By no means an exhaustive list, but here are some major concepts: transformers, tokens, context windows, why hallucinations happen.

Prefer local models

→ Mostly to stay in control instead of being at the mercy of your internet connection and every model update. I use LM Studio as it supports MLX for Apple Silicon.

As of November 2025, Qwen3-coder-30b has been solid for me. Local models are usually less capable than the big cloud ones running on thousands of GPUs, so I recommend breaking your requests into smaller, focused prompts to get the best results.

Use it to review your code

→ Especially on solo projects, it’s better than having no one review your code. Expect false positives, but at times you will catch a real issue or code smell. It’s easy to enable on GitHub and the free tier is generous.

Use it to learn

→ Ask questions, request comparisons, and come up with edge cases to your tests. Remember to always double-check sources, especially when it comes to dependencies, as these models quite often use outdated specs.

How to resize logical volume in Proxmox

Oscar Marion — Sun, 06 Oct 2024 00:00:00 GMT

Allocate more space on Proxmox

Go to your VM > Hardware tab
Select the disk you want to resize
Click on the Disk Action dropdown in the menu bar, then Resize
Resize the disk as much as you need:

Extend the partition in the VM

Make the partition see the space (/dev/sda3 in my case):
```
sudo cfdisk
```
Then, resize the partition within cfdisk.
Extend the Physical Volume (PV) from the partition:
```
sudo pvresize /dev/sda3
```
Extend the Logical Volume (LV) to use all the space in the Volume Group (VG):
```
sudo lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv
```
Resize the file system:
```
sudo resize2fs /dev/ubuntu-vg/ubuntu-lv
```
Check that the file system sees the new space:
```
df -h
```

Source: https://packetpushers.net/blog/ubuntu-extend-your-default-lvm-space

Manually trigger DDNS update on a UDM Pro

Oscar Marion — Sat, 19 Aug 2023 00:00:00 GMT

I ran into this issue today, and to my surprise, there is no way of doing that from the Unifi Dashboard. While most of the responses you will find on Ubiquiti’s forums and on Reddit suggest restarting the console altogether, u/TheFuer on Reddit posted a much better way to do it, using the CLI.

First, connect to your UDM Pro via SSH. You can follow this guide if you don’t have it setup yet.

1. Determine the config/command that the UDM is using by typing this command:

$ ps aux | grep inadyn

It should return something similar to this:

root        1432  0.0  0.0   6336  3256 ?        S    00:49   0:00 /usr/sbin/inadyn -n -s -C -f /run/ddns-eth8-inadyn.conf
root       24298  0.0  0.0   4924   680 pts/0    S+   01:00   0:00 grep --color inadyn

2. Run inadyn with a force flag to force the update. Replace The path with the one the previous command returned:

$ inadyn -n -1 --force -f /run/ddns-eth8-inadyn.conf

You should get the following once the update is successful:

inadyn[25647]: In-a-dyn version 2.9.1 -- Dynamic DNS update client.

inadyn[25647]: Update forced for alias all.dnsomatic.com, new IP# XXX.XXX.XXX.XXX

inadyn[25647]: Updating cache for all.dnsomatic.com

Blacklisting Google .mov and .zip TLDs

Oscar Marion — Tue, 23 May 2023 00:00:00 GMT

Google has made the .zip and .mov top-level domains available for public registration, and cybercriminals are already using them in phishing campaigns. It might be a good idea to block them all together for now: here are the steps for PiHole users.

Log into your PiHole admin interface
Click on the “ RegEx filter” tab
In the “Regular Expression” field, write ^.*.(zip|mov)$
Click on “Add to Blacklist”

You can make sure the filtering is working by accessing somethingfishy.zip or notamoviefile.mov. If everything is setup correctly, you should get an ERR_ADDRESS_INVALID from your browser.

You should also see the following on your PiHole query logs:

Zoom TKL shortcuts (Bluetooth and RGB)

Oscar Marion — Fri, 21 Apr 2023 00:00:00 GMT

Via customization web application: usevia.app

Zoom TKL JSON File can be found here.

Bluetooth

Action	Shortcut
Initiate bluetooth pairing (Device 1)	FN + Z (Hold)
Initiate bluetooth pairing (Device 2)	FN + X (Hold)
Initiate bluetooth pairing (Device 3)	FN + C (Hold)
Connect to bluetooth device {1, 2, 3}	FN + {Z, X, C}

General

Action	Shortcut
Restore to factory settings	FN + Space + Backspace
Reset keyboard	FN + Shift + R
Wired mode	FN + Space
Enter deep sleep mode	FN + Tab (Hold)

Function keys

Action	Shortcut
Increase brightness	FN + F1
Decrease brightness	FN + F2
Enter Mission Control	FN + F3
Open home folder	FN + F4
Refresh	FN + F5
Previous track	FN + F7
Play / pause song	FN + F8
Next track	FN + F9
Mute	FN + F10
Volume up	FN + F11
Volume down	FN + F12

RGB

Action	Shortcut
Increase RGB brightness	FN + ↑
Decrease RGB brightness	FN + ↓
Increase RGB speed	FN + →
Decrease RGB speed	FN + ←
Toggle RGB	FN + \
Increase RGB hue	FN + P
Decrease RGB hue	FN + ;
Increase RGB saturation	FN + [
Decrease RGB saturation	FN + ’
Change RGB mode	FN + ]

Stop Wasting Build Minutes

Oscar Marion — Tue, 06 Apr 2021 00:00:00 GMT

CI pipelines are great. They make sure your code doesn’t break anything and follows conventions. Usually, they run tasks like unit tests, linting, and builds.

But sometimes the pipeline fails over a silly linting error. It did its job—stopping bad code from shipping—but that could’ve been caught earlier on your own machine!

The fix? Automate these checks locally before your PR. That’s where Git hooks come in. This tutorial covers the basics to help you get you and your team started.

Writing git hooks comes with a few challenges, mainly to ensure they are installed on your teammates’ machines.

Husky? 🐶

Husky is a tiny tool that makes it easy to set up git hooks and share them across your team. We will use it together with lint staged.

1. Install husky

npm install -D husky
# or
yarn add -D husky

2. Enable git hooks

npx husky install

3. Automate git hook installation for your teammates

For npm, add this prepare script to your package.json:

{
  "prepare": "npx husky install"
}

Yarn requires a slightly different configuration:

{
  "private": true,
  "scripts": {
    "postinstall": "npx husky install"
  }
}

Using Yarn2 in a non-private repo? Check this link.

4. Install lint-staged

npm install -D lint-staged
# or
yarn add -D lint-staged

Add the lint-staged configuration to your package.json and customise it to your needs. We assume that you already have linters and tests scripts set up.

"lint-staged": {
  "*.{ts,tsx}": [
    "npm run format", // prettier --write script
    "npm run lint:fix" // eslint --fix script
    "npm run test" // jest
  ]
},

5. Create your hook

This command will create a .husky folder at the root of your project:

npx husky add .husky/pre-commit "npx lint-staged"

What did we achieve?

Git hooks (via Husky) now run lint checks on each commit.
Linting only targets staged .ts and .tsx files.
Auto-fixable errors are fixed and committed; others cause the commit to fail with error details.
Hooks are automatically installed for teammates through the prepare/postinstall scripts.

Git 2.9+ is required for Husky, as it uses core.hooksPath to point to the .husky folder.

Final thoughts

Git hooks help catch mistakes early, keep your Git history clean, and save build minutes. Just remember, they complement—not replace—CI pipelines. And if needed, you can skip hooks with –no-verify.

Thanks for reading! 😃

A simple Tailwind & CRA setup

Oscar Marion — Fri, 19 Mar 2021 00:00:00 GMT

In this guide, I’ll show you how to install Tailwind on a new Create React App (CRA) project. As a bonus, we’ll also add dark/light theme support.

Why Tailwind?

Tailwind is a popular utility-first CSS framework. It’s lightweight (1.4kB vs. Bootstrap’s 60.9kB), highly customizable, and works with CRA, Next.js, Vue, Svelte, and more. Unlike Bootstrap, it doesn’t come with pre-made components, which means more flexibility.

The Standard Way

Tailwind suggests using CRACO to customize CRA. While that works, it’s a bit much for simpler setups.

Our Approach

We’ll streamline things by using PostCSS and npm scripts to compile the CSS before running CRA.

A GitHub repository with the final code can be found here.

1. Install CRA

This command will create a starter project with Typescript support. You can of course remove the template flag and use regular Javascript.

npx create-react-app my-react-app --template typescript

2. Go to your app folder and install Tailwind, PostCSS and Autoprefixer like so:

npm i -D tailwindcss autoprefixer postcss-cli

3. Create a postcss.config.js file at the root of your project:

const tailwindcss = require("tailwindcss");
module.exports = {
  plugins: [tailwindcss("./tailwind.config.js"), require("autoprefixer")],
};

4. Create a Tailwind configuration file by running:

npx tailwind init

You should get a tailwind.config.js file that looks like this:

module.exports = {
  purge: [],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {
    extend: {},
  },
  plugins: [],
};

5. Create a tailwind.css file in your project,

For instance under src/styles/tailwind.css:

@tailwind base;
@tailwind components;
@tailwind utilities;

6. Add a css script to package.json

As well as a prestart and a prebuild:

{
  "scripts": {
    "css": "postcss ./src/styles/tailwind.css -o ./src/styles/tailwind.generated.css",
    "prestart": "npm run css",
    "prebuild": "npm run css"
  }
}

7. Import Tailwind css file

This way, we’re making Tailwind classes available to all our app’s components.

/*...*/
import "./styles/tailwind.generated.css";
/*...*/

Don’t forget to add tailwind.generated.css to .gitignore, as this file gets generated each time we run the start or build command. We didn’t use Tailwind classes yet, but now is a good time to run npm run startand check that everything works.

Make some changes

To check that the Tailwind classes get picked up, open ./src/App.ts and edit the Learn React link className property:

<a
  className="App-link mt-2 rounded bg-white px-2"
  href="https://reactjs.org"
  target="_blank"
  rel="noopener noreferrer"
>
  Learn React
</a>

You should see the changes in your browser pretty instantly and your Learn React link should now look like this:

Cleanup the production build

Say we want to deploy this app right now. When running npm run build , CRA is kind enough to provide some information on our bundle size. As you can see, this app is quite hefty:

The bundled css weighs far too much, and there’s a reason for it: it includes all the Tailwind css classes from the @base, @components and @utilities that we set earlier. We want this on our development environment, but certainly not in production — only the used classes should be included in the build.

To clean up the unused classes, we’ll need to change the purge configuration of tailwind.config.js file to:

module.exports = {
  purge: {
    mode: "all",
    content: ["./src/**/*.ts", "./src/**/*.tsx"],
  },
  // ...
};

If you didn’t go for the Typescript template, make sure to change your file extensions accordingly. Now, let’s make sure Tailwind knows we run the build in a production environment by installing cross-env:

npm i -D cross-env

And change our prebuild script to:

"prebuild": "cross-env NODE_ENV=production npm run css"

As you run the build script, the bundled css weight should decrease a lot. To test that, npm run build once again:

Finally, let’s make sure our Tailwind classes are still applied: serve the built project by running npx serve -s build. Learn React should still look like on the dev environment.

Bonus: setup a light / dark mode switcher

1. Use CSS variables

Let’s extract the colors that are currently set in the src/App.css classes and set them as css variables:

:root {
  --color-primary: #282c34;
  --color-secondary: #ffffff;
  --color-accent: #61dafb;
}

You can now assign them to Tailwind variables. Your entire configuration should look like this:

module.exports = {
  purge: {
    mode: "all",
    content: ["./src/**/*.ts", "./src/**/*.tsx"],
  },
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {
      colors: {
        primary: "var(--color-primary)",
        secondary: "var(--color-secondary)",
        accent: "var(--color-accent)",
      },
    },
  },
  variants: {
    extend: {},
  },
  plugins: [],
};

As you changed the Tailwind configuration, you’ll have to stop the dev server and launch npm run startagain.

In App.css, you can remove the background-color and color properties set for the .App-header class, as well as the entire .App-link class.

Going back to App.tsx, make some changes to get the same look as before:

Add bg-primary text-secondaryto the header className attribute
For the Learn React link, replace App-link class by text-accent and bg-white by bg-secondary.

2. Enable dark mode

Create the light CSS variables under a data attribute set on the root div in App.tsx. To do that, add this to App.css, below the CSS variables you set before:

[data-theme="light"] {
  --color-primary: #ffffff;
  --color-secondary: #282c34;
  --color-accent: #61dafb;
}

We can now switch between these themes. To keep things simple for this tutorial, we will handle the theme in the component’s local state with the useState hook. In the real world, you would obviously save user preference in a cookie or in localStorage. You could also base the initial theme on prefers-color-scheme.

Let’s set our localState:

const [theme, setTheme] = useState(“dark”)

Add the current theme to the App.tsx root div:

<div className=“App” data-theme={theme}>

Next, let’s create our handler:

import React, { MouseEvent, useState } from 'react';
// ...
function App() {
  const [theme, setTheme] = useState(“dark”)

  const handleSwitchTheme = (e: MouseEvent<HTMLAnchorElement>) => {
    e.preventDefault();
    setTheme(theme === "dark" ? "light" : "dark")
  }
  // ...
}

Time to add a switch theme button. We will use the Learn more link and change it to our needs:

Try hitting the Switch theme button. If this fancy light theme shows up, congratulations, you got everything working!