From the Wheel to the Horse

Keep that idea in mind, because it repeats throughout history: every major innovation either takes over a routine skill, or turns a new skill into one we no longer think about.

The wheel is one of the earliest examples. It appeared in Mesopotamia around 3500 BCE, first as the potter’s wheel and soon after on carts. Before it, moving anything heavy meant carrying it, dragging it, or rolling it on logs, and each of those took constant, deliberate effort. The wheel did not make people stronger. It made strength matter less, and the attention it freed went into other things.

Riding animals followed the same pattern, but inside the human body. Learning to ride a horse is hard. You have to balance, read the animal, and coordinate your legs, hands, and weight all at once. Yet once a rider masters it, riding becomes like walking: the rider decides where to go, and the body handles how. A skilled rider can scan the horizon, talk, or plan the day while the riding happens underneath. One skill became autonomous, and in doing so it extended how far a person could go.

Driving Into a Bigger World

Then came engines and the car, and the same story played out on a much larger scale.

For most of history, a person’s world was the region they could walk or ride across. A journey between countries took weeks or months, and travelling around the world was something almost no one would do in a lifetime. Engines changed that. Cars, trains, ships, and later aeroplanes shrank the planet. Today you can cross a continent in an afternoon, circle the globe in a couple of days, and people have even left the planet entirely and travelled to space.

Driving itself followed the walking pattern. Every new driver remembers how overwhelming the first lesson was: mirrors, pedals, gears, signals, and the road all at once. A few months later, most drivers arrive home with little memory of the journey. The driving became autonomous, and the conscious mind returned to the only thing that really needed it: deciding where to go, and reacting when something unexpected happens.

The Calculator and the Human “Computers”

The example closest to AI, in my opinion, is the calculator.

Before electronic machines, “computer” was a job title. Rooms full of people, many of them women, and many highly trained in mathematics, performed calculations by hand for astronomy, engineering, ballistics, and aeronautics. Entire industries depended on human arithmetic.

Calculating machines took that job away. And the early ones were not even fully reliable. Mechanical calculators going back to Pascal and Leibniz in the seventeenth century had trouble with carrying digits correctly, and some of the early pocket electronic calculators of the 1970s gave noticeably inaccurate results for functions like logarithms and trigonometry. It took years of engineering before people could simply trust whatever number appeared on the screen. Today nobody double-checks a calculator, we assume it is right, and we are almost always correct to.

That history is worth remembering whenever someone dismisses AI because it still makes mistakes. Reliability is something technologies earn over time. It is rarely there on day one.

So what happened to the human computers? Many of those jobs disappeared, but they were replaced by something better. At NACA (later NASA), Dorothy Vaughan, who led a unit of human computers, saw that electronic computers were coming for her team’s work. Instead of fighting it, she taught herself and her colleagues the programming language FORTRAN, and they became some of the agency’s early programmers. The boring arithmetic went to the machine, and the people moved up to more important work.

Mathematics as a whole followed the same path. Freed from grinding through calculations by hand, mathematicians and engineers could tackle problems that would have been impossible before: numerical simulation, statistics on huge datasets, and eventually the very machine learning that powers today’s AI. The calculator did not shrink the need for mathematics. It made the demand for it grow.

How Something Becomes Autonomous

So how does a skill become autonomous in the first place? I think it happens in four stages:

1. We learn. Everything is deliberate, slow, and exhausting. Each step needs our full attention.
2. We master it. The skill becomes smooth, and the steps blend into a single fluid action.
3. We become observers. With the doing handled, our attention shifts outwards, to the environment and what is changing in it.
4. We decide. The world is not deterministic. When the environment looks familiar, we act automatically, exactly as before. When something changes, for example a child steps into the road, the ground is icy, or the horse is nervous, our observation pulls the brain back in, and we make a new decision.

Neuroscience describes something very similar. Researchers distinguish between habitual control, which is fast, cheap, and automatic, and goal-directed control, which is slow, deliberate, and flexible. The brain switches between them depending on how certain it is about the situation (Daw, Niv & Dayan, 2005). Routine situations run on habit, and surprises bring back deliberate thought.

We Are Agents, Too

If this sounds familiar to anyone working in AI, it should: it is a description of an agent.

In reinforcement learning, an agent observes the state of its environment, takes actions according to a policy, and receives rewards, while trying to maximise its reward over time. Today’s agentic AI systems work in the same way. They observe, plan, act, and adjust when the world does not behave as expected.

Humans are agents in exactly this sense. We observe the world, act on it, and are rewarded or punished by the results. And our long history of handing skills over to tools is what a good agent does: it delegates routine work to cheap, reliable subroutines, so that its limited attention goes into the decisions that actually affect its reward.

Seen this way, AI is not a rival agent competing for our place. It is the next layer of autonomy in our own stack, after the body that walks, the horse that carries, the engine that drives, and the calculator that computes. AI takes on the routine cognitive work, such as drafting, searching, summarising, and writing boilerplate code, and leaves us the higher-level role: setting goals, noticing when something has changed, and making the decisions that matter.

AI Is the Hand, We Are the Brain

Which brings us to AI.

Everything above has been building up to this point. The wheel took over carrying, the horse and then the engine took over travelling, and the calculator took over arithmetic. AI is next in line, and it is the broadest step yet. Any job that can be automated, or done autonomously, AI is going to take over. That includes writing routine code, filling in forms, summarising documents, sorting data, answering standard questions, and running the same analysis for the hundredth time. These are the cognitive equivalent of walking: tasks we once had to learn deliberately, and which no longer need our full attention once mastered.

This is not something to fear. It is the same division of labour our own bodies already use. When you walk, your legs do the walking and your brain decides where to go. It only steps in when something changes: a curb, a crowd, a slippery floor. AI gives us that same arrangement for our work. AI will be the hand, and humans will be the brain. AI does the doing; we observe and decide. We set the goals, watch the environment, notice when something is not right, and make the calls that require judgement, responsibility, and an understanding of what actually matters.

That is exactly the four-stage path from earlier, applied to a whole civilisation. We are moving past the learning and mastering stages for a huge range of tasks and into the stages that were always the most valuable: observing and deciding.

Finding the Next Skill

So where does that leave us?

Not in a world without work, but in one where the work keeps moving up. Each innovation makes some skills obsolete and creates demand for new ones. Few people need to shoe a horse, do long division by hand, or read a paper map today, and almost nobody misses those jobs. In their place came skills nobody could have imagined before: driving, programming, data analysis, and now, directing and supervising AI systems.

The lesson I take from history is simple. Instead of holding on to skills that innovation has made obsolete, we should be looking for the new ones that it has created. We need to learn them, master them, let them become automatic, and then move up again. Let AI be the hand. Our job is to become a better brain: to observe more carefully, decide more wisely, and keep moving up. That is how we have always adapted, and I believe it is how we will build a better life alongside AI.

The Bitter Lesson Does Not Apply Here

In natural language processing, the prevailing philosophy is the bitter lesson: simply scaling up unconstrained architectures and feeding them vast data will eventually beat any hand-engineered model. In chemistry, this rule seems to fundamentally break down.

The reason is structural: physical laws are not patterns to be learned from data; they are constraints. A molecule does not change its behaviour depending on what language you use to describe it, or how many other molecules your model has seen. The geometry of space, the symmetries of rotation and translation, the rules of quantum mechanics — these are fixed. Models that are explicitly built to respect these constraints, rather than hoping to infer them from data, consistently outperform those that do not when it comes to complex, unfamiliar chemical scenarios.

This matters beyond scientific accuracy. The energy cost of training a large chemistry model is substantial — comparable to the footprint of transcontinental flights, depending on the hardware and duration. The justification for that cost rests on the assumption that a sufficiently general model will not need to be retrained as new chemical domains come into scope. If that assumption is wrong, the cost is not paid once. It is paid repeatedly.

Scale can help a model interpolate better within the chemistry it has already seen. It cannot, on its own, teach a model to reason about chemistry it has never encountered.

The Extrapolation Wall

If an AI model cannot discover something truly new, what is its value in science? The ultimate goal of chemistry AI is genuine scientific discovery — novel therapeutics, advanced materials, structures that push beyond what currently exists. By definition, this requires out-of-distribution (OOD) generalisation: the model must accurately extrapolate into chemical spaces it has never encountered during training.

This is where current foundation models quietly struggle. When evaluated not on held-out versions of familiar molecules, but on genuinely new chemical compositions assembled from known building blocks, the performance of even the most capable models degrades substantially — often by an order of magnitude or more compared to their in-distribution accuracy. More troublingly, the models that perform best on familiar chemistry are not always the ones that generalise best to new chemistry. Standard benchmarks, which test models on data drawn from the same distribution they were trained on, can paint a misleadingly optimistic picture.

The practical consequence of this generalisation failure is rarely discussed openly. When a model cannot extrapolate to a new chemical domain, practitioners retrain it or fine-tune it on domain-specific data. Each time the scope of the problem shifts — a new class of materials, a new reaction type, an updated reference dataset — the energy cost is paid again. The promise of universality was precisely that this would not be necessary. A model that genuinely generalises across chemical space would need far less of this repeated adaptation, and the cumulative environmental cost of deploying chemistry AI at scale would be meaningfully lower. Closing the OOD gap would not eliminate that cost, but it would reduce it in a way that compounds over time and across the research community.

This gap between in-distribution accuracy and out-of-distribution performance is the central unanswered question in the field. It is also the question our recent work at Cardiff University, Benchmarking Compositional Generalisation for Machine Learning Interatomic Potentials, is designed to probe systematically — not to offer a solution, but to establish clearly where current models succeed, where they fail, and how large the gap actually is.

The Physics Trap: Systematic Softening

Universal machine-learned interatomic potentials — models trained to act as fast surrogates for expensive quantum mechanical calculations across a wide range of materials — represent some of the most impressive engineering in scientific AI. But a specific physical flaw haunts them: systematic softening.

These models are predominantly trained on atomic configurations close to their equilibrium states, where forces are small and well-behaved. When they encounter high-energy environments — distorted structures, defect sites, transition states — they systematically underpredict the forces and the curvature of the energy landscape. The result is an artificially smooth picture of molecular behaviour: the model describes a world that is slightly less tense, slightly less reactive, slightly less physically real than the one it is meant to simulate.

This is not a bug that more data trivially fixes. The distributions of configurations that matter most for reactive chemistry, materials failure, and catalysis are precisely the configurations that are hardest and most expensive to generate, and therefore most underrepresented in training sets. The models are physically flawed at exactly the regimes where accurate physics is most needed.

The response in practice is, again, fine-tuning: taking a universal model and adapting it to a specific high-energy regime with targeted data. This works, to a degree — but it reintroduces the per-domain training cost that universality was meant to eliminate. Each specialised application becomes its own compute and energy expenditure on top of the original training investment. The physics trap is not just a scientific problem; it is a resource problem that compounds with every new deployment context.

So, Do We Actually Need Them?

Given these limitations — poor out-of-distribution generalisation, systematic physical errors, and the failure of naive scaling — one might conclude that chemical foundation models are overhyped. That would be the wrong conclusion.

We need them. We just need to be honest about what they currently are and what they are not.

They are not zero-shot oracles. They are powerful starting points. Fine-tuning on even a small number of task-specific configurations can substantially correct for systematic errors. Better benchmarking — designed to test genuine extrapolation rather than interpolation — can guide the field toward architectures and training strategies that close the OOD gap. Better uncertainty quantification can tell practitioners when to trust a model and when to reach for the quantum chemistry code.

And when integrated thoughtfully into a human-led discovery pipeline, these systems yield real results. There are already drug candidates in clinical trials that would not exist without generative AI tools for chemistry. The technology works — within its limits.

The energy picture deserves an honest summary too. Improving OOD generalisation would reduce the cumulative cost of deploying chemistry AI: fewer retraining cycles, less per-domain fine-tuning, longer useful lifetimes for a given model. That is a meaningful gain, and it is one the field tends to undervalue when discussing the case for better benchmarks and more rigorous evaluation. But it would not eliminate the energy cost of achieving high accuracy in the first place. Training a model that is both physically accurate and genuinely generalisable across chemical space remains an unsolved problem, and any solution to it will itself require substantial compute. The goal of better generalisation is to stop paying the same cost repeatedly — not to make the cost disappear.

The right framing is this: chemical foundation models are engines that drastically accelerate the exploration phase of scientific discovery. They reduce the cost of hypothesis generation, broaden the searchable chemical space, and surface candidates for expert validation. What they are not — and may never be, given the nature of physical law — is a replacement for domain understanding, careful data curation, and rigorous validation.

Scale matters. But in chemistry, physics matters more. And until our models can genuinely compose what they have learned about molecular fragments into predictions about new ones, the universal promise remains exactly that — a promise.

How I Fixed the Packages Problem

That remaining problem — missing packages — was not unique to Fedora. It had been following me across every distribution I had ever used, in different forms. On Debian it was outdated versions. On Arch it was AUR maintenance risk. On CentOS it was the gap between stability and currency. Fedora brought me closer than anything else had, but it did not fully close it. The answer, when it finally arrived, did not come from the distribution at all.

Before getting to that, I want to talk about my relationship with Python — because the solution to the packages problem and the solution to surviving the Python ecosystem turned out to be the same thing.

pixi global install <package_name>

pixi global install zoxide ripgrep fd-find bat eza btm dust ncdu delta hyperfine xh sd neovim tmux zellij btop zsh xonsh skim yazi tokei

uv tool install <package_name>

Why I Left Fedora for openSUSE Tumbleweed

Fedora was, honestly, excellent. It was stable, polished, and day to day I rarely had anything to complain about. What eventually wore me down was not breakage — it was the release cycle. Fedora ships a new version roughly every six months, and each release is supported for only about thirteen months, so staying current means a major-version upgrade twice a year. The upgrades themselves usually went fine, but each one still meant setting time aside, checking that third-party repositories and GPU drivers had caught up, and keeping an eye on the end-of-life countdown. On the machine I depend on for my research, that recurring chore became friction I did not want.

I had already tried openSUSE Tumbleweed around the time I was first settling into Fedora, so moving back to it was an easy decision. Tumbleweed is a rolling release, so there is no versioning at all: no “Fedora 43 to 44” migration, no end-of-life date to plan around — the system simply stays current. And despite being rolling, it is the most stable distribution I have used, thanks to openSUSE’s automated testing pipeline (openQA), which gates every snapshot before it ships. It is also one of the most genuinely community-oriented projects in the Linux world, which matters to me for the same reason I left Nobara.

For me, Tumbleweed is the best of both worlds: the freshness of a rolling release, without giving up the stability I had come to rely on with Fedora.

Different Distros for Different Jobs

Tumbleweed is now my desktop daily driver, but the story does not end there — because Linux is not just my desktop. It is also every server I deploy to, every container image I build from, and every machine I do not personally sit in front of.

The fact that openSUSE is SUSE-based rather than Red Hat-based barely matters on the desktop any more — Flatpak and pixi cover the gap regardless of what is underneath. For servers, though, it matters a great deal: if I am deploying to infrastructure running SLES, openSUSE (Tumbleweed, or openSUSE Leap for a non-rolling option) is the natural match, whereas a RHEL-family choice makes more sense alongside RHEL-compatible infrastructure.

Which brings me to AlmaLinux. Most of my Docker base images are AlmaLinux — it is a clean, community-driven RHEL rebuild, and that compatibility matters when the goal is reproducible builds across HPC systems, cloud instances, and local containers that all ultimately trace back to a RHEL lineage. For a long time, AlmaLinux on the desktop felt like a non-starter — too conservative, too server-oriented, missing too much. But with Flatpak filling in GUI applications and pixi filling in everything else, that gap has effectively closed. I now run AlmaLinux on some of my desktops too, and it feels far less like a compromise than it would have a few years ago.

So the honest version of the story is less “I found The One Distro” and more “I stopped needing to find one.” openSUSE Tumbleweed is my desktop — KDE, gaming, day-to-day tinkering — with no upgrade cycle to babysit. AlmaLinux sits underneath almost everything I containerise, and increasingly on desktops too. Fedora remains a distribution I respect and would happily recommend; I simply prefer not to have a release calendar. What used to feel like indecision now feels like having the right tool for the job — and the credit, again, goes to Flatpak and pixi for making the switching cost low enough that it no longer feels like a trade-off.

The Setup

If you are curious about the tools and how I configure them, this section is for you. The nice thing about all of this is that it is entirely distro-agnostic — even my IDEs, Zed (the main one) and VS Code (the reserve), are available everywhere these days. Whether I am on openSUSE Tumbleweed, AlmaLinux, or Fedora, the setup below is identical, because Flatpak, pixi global install, and IDE installers all work the same way regardless of distro.

# Install pueue (client + daemon) globally via pixi
pixi global install pueue

# Enable and start the daemon as a systemd user service
systemctl --user enable pueued
systemctl --user start pueued
systemctl --user status pueued

pueue add -- pixi run python train.py --config exp1.yaml
pueue add -- pixi run python train.py --config exp2.yaml
pueue status

# zoxide must be initialized before the `cd` alias below, otherwise the `z`
# function doesn't exist yet and `cd` fails until you manually re-source
# this file
eval "$(zoxide init zsh)"

# Modern replacements
alias ls="eza --icons --group-directories-first"
alias tree="eza --icons --tree"
alias treed="eza --icons --tree --level"
alias lsdu='du -a -h --max-depth=1 | sort -hr'
alias du='dust'
alias top='btm'
alias cd='z'
alias grep='rg'
alias vim='nvim'
alias search='sk'

# Pipe --help and -h output through bat for syntax highlighting
alias -g -- -h='-h 2>&1 | bat --language=help --style=plain'
alias -g -- --help='--help 2>&1 | bat --language=help --style=plain'

# Set of general useful functions

# Create directory and instantly cd into it
mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Easily move UP 'N' directories (e.g., 'up 3' moves up 3 levels)
up() {
    local levels="${1:-1}"
    local path=""
    for ((i=1; i<=levels; i++)); do
        path="../$path"
    done
    cd "$path"
}

# Check public and local IP addresses cleanly
myip() {
    local local_ip=$(hostname -I 2>/dev/null | awk '{print $1}' || ipconfig getifaddr en0 2>/dev/null || echo "Unknown")
    echo "Local IP:   $local_ip"
    echo "Public IP:  $(curl -s https://ifconfig.me)"
    echo "Location:   $(curl -s https://ipapi.co/city/), $(curl -s https://ipapi.co/country_name/)"
}

# Runs a clean multi-record (A, AAAA, MX, NS, TXT) DNS check for a domain.
dnslookup() {
    if [[ -z "$1" ]]; then
        echo "Usage: dnslookup <domain>"
        return 1
    fi
    echo "=== A / AAAA Records ==="
    dig +short "$1" A "$1" AAAA
    echo "\n=== MX Records ==="
    dig +short "$1" MX
    echo "\n=== NS Records ==="
    dig +short "$1" NS
    echo "\n=== TXT Records ==="
    dig +short "$1" TXT
}

# Find which process is listening on a specific port (e.g., 'port 8080')
port() {
    if [[ -z "$1" ]]; then
        echo "Usage: port <port_number>"
        return 1
    fi
    lsof -i :"$1"
}

# Locates and forcibly terminates (kill -9) whatever process is occupying a given port.
killport() {
    if [[ -z "$1" ]]; then
        echo "Usage: killport <port_number>"
        return 1
    fi
    local pid=$(lsof -t -i:"$1")
    if [[ -n "$pid" ]]; then
        echo "Killing process $pid on port $1..."
        kill -9 $pid
    else
        echo "No process found on port $1."
    fi
}

# Quick HTTP server in the current directory (Python 3)
serve() {
    local port="${1:-8000}"
    echo "Serving current directory on http://localhost:${port}"
    python3 -m http.server "$port"
}

# Pretty-prints each directory in your $PATH on a new line for easy inspection.
path() {
    echo "$PATH" | tr ':' '\n'
}

# Side-by-side file comparison using your default Neovim alias.
vdiff() {
    if [[ $# -lt 2 ]]; then echo "Usage: vdiff <file1> <file2>"; return 1; fi
    nvim -d "$1" "$2"
}

# Previews the head of gzipped or zstd-compressed text/log files without extraction.
vgz() {
    if [[ -z "$1" ]]; then echo "Usage: vgz <file.gz|file.zst> [lines]"; return 1; fi
    local lines="${2:-20}"
    case "$1" in
        *.gz)  gzip -dc "$1" | head -n "$lines" ;;
        *.zst) zstdcat "$1" | head -n "$lines" ;;
        *)     echo "Unsupported archive format." ;;
    esac
}

# Lists files inside .zip, .tar, .tar.gz, or .whl archives without extracting.
vzip() {
    if [[ -z "$1" ]]; then echo "Usage: vzip <archive_file>"; return 1; fi
    case "$1" in
        *.zip|*.whl) unzip -l "$1" ;;
        *.tar.gz|*.tgz) tar -tzvf "$1" ;;
        *.tar) tar -tvf "$1" ;;
        *) echo "Unsupported extension." ;;
    esac
}

mkdir -p ~/.zsh/plugins
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/plugins/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting ~/.zsh/plugins/zsh-syntax-highlighting
git clone https://github.com/zdharma-continuum/fast-syntax-highlighting ~/.zsh/plugins/fast-syntax-highlighting

source ~/.zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh
source ~/.zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
source ~/.zsh/plugins/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh

curl -s https://ohmyposh.dev/install.sh | bash -s

oh-my-posh font install meslo

mkdir -p ~/.config/ohmyposh
# then save the JSON below as ~/.config/ohmyposh/jandedobbeleer.omp.json

# ~/.zshrc
eval "$(oh-my-posh init zsh --config ~/.config/ohmyposh/jandedobbeleer.omp.json)"

# ~/.bashrc
eval "$(oh-my-posh init bash --config ~/.config/ohmyposh/jandedobbeleer.omp.json)"

{
  "$schema": "https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/schema.json",
  "blocks": [
    {
      "alignment": "left",
      "segments": [
        {
          "background": "#c386f1",
          "foreground": "#ffffff",
          "leading_diamond": "",
          "style": "diamond",
          "template": " {{ .UserName }} ",
          "trailing_diamond": "",
          "type": "session"
        },
        {
          "background": "#ff479c",
          "foreground": "#ffffff",
          "powerline_symbol": "",
          "options": {
            "folder_separator_icon": "  ",
            "home_icon": "~",
            "style": "full"
          },
          "style": "powerline",
          "template": "   {{ .Path }} ",
          "type": "path"
        },
        {
          "background": "#fffb38",
          "background_templates": [
            "{{ if or (.Working.Changed) (.Staging.Changed) }}#FF9248{{ end }}",
            "{{ if and (gt .Ahead 0) (gt .Behind 0) }}#ff4500{{ end }}",
            "{{ if gt .Ahead 0 }}#B388FF{{ end }}",
            "{{ if gt .Behind 0 }}#B388FF{{ end }}"
          ],
          "foreground": "#193549",
          "leading_diamond": "",
          "powerline_symbol": "",
          "options": {
            "branch_template": "{{ trunc 25 .Branch }}"
          },
          "style": "powerline",
          "template": " {{ .UpstreamIcon }}{{ .HEAD }}{{if .BranchStatus }} {{ .BranchStatus }}{{ end }}{{ if .Working.Changed }}  {{ .Working.String }}{{ end }}{{ if and (.Working.Changed) (.Staging.Changed) }} |{{ end }}{{ if .Staging.Changed }}  {{ .Staging.String }}{{ end }}{{ if gt .StashCount 0 }}  {{ .StashCount }}{{ end }} ",
          "trailing_diamond": "",
          "type": "git"
        },
        {
          "background": "#6CA35E",
          "foreground": "#ffffff",
          "powerline_symbol": "",
          "style": "powerline",
          "template": "  {{ if .PackageManagerIcon }}{{ .PackageManagerIcon }} {{ end }}{{ .Full }} ",
          "type": "node"
        },
        {
          "background": "#8ED1F7",
          "foreground": "#111111",
          "powerline_symbol": "",
          "style": "powerline",
          "template": "  {{ if .Error }}{{ .Error }}{{ else }}{{ .Full }}{{ end }} ",
          "type": "go"
        },
        {
          "background": "#4063D8",
          "foreground": "#111111",
          "powerline_symbol": "",
          "style": "powerline",
          "template": "  {{ if .Error }}{{ .Error }}{{ else }}{{ .Full }}{{ end }} ",
          "type": "julia"
        },
        {
          "background": "#FFDE57",
          "foreground": "#111111",
          "powerline_symbol": "",
          "options": {
            "display_mode": "files",
            "fetch_virtual_env": false
          },
          "style": "powerline",
          "template": "  {{ if .Error }}{{ .Error }}{{ else }}{{ .Full }}{{ end }} ",
          "type": "python"
        },
        {
          "background": "#AE1401",
          "foreground": "#ffffff",
          "powerline_symbol": "",
          "options": {
            "display_mode": "files"
          },
          "style": "powerline",
          "template": "  {{ if .Error }}{{ .Error }}{{ else }}{{ .Full }}{{ end }} ",
          "type": "ruby"
        },
        {
          "background": "#FEAC19",
          "foreground": "#ffffff",
          "powerline_symbol": "",
          "options": {
            "display_mode": "files"
          },
          "style": "powerline",
          "template": " {{ if .Error }}{{ .Error }}{{ else }}{{ .Full }}{{ end }} ",
          "type": "azfunc"
        },
        {
          "background_templates": [
            "{{if contains \"default\" .Profile}}#FFA400{{end}}",
            "{{if contains \"jan\" .Profile}}#f1184c{{end}}"
          ],
          "foreground": "#ffffff",
          "powerline_symbol": "",
          "options": {
            "display_default": false
          },
          "style": "powerline",
          "template": "  {{ .Profile }}{{ if .Region }}@{{ .Region }}{{ end }} ",
          "type": "aws"
        },
        {
          "background": "#ffff66",
          "foreground": "#111111",
          "powerline_symbol": "",
          "style": "powerline",
          "template": "  ",
          "type": "root"
        },
        {
          "background": "#83769c",
          "foreground": "#ffffff",
          "options": {
            "always_enabled": true
          },
          "style": "plain",
          "template": "<transparent></>  {{ .FormattedMs }}⠀",
          "type": "executiontime"
        },
        {
          "background": "#00897b",
          "background_templates": [
            "{{ if gt .Code 0 }}#e91e63{{ end }}"
          ],
          "foreground": "#ffffff",
          "options": {
            "always_enabled": true
          },
          "style": "diamond",
          "template": "<parentBackground></>  ",
          "trailing_diamond": "",
          "type": "status"
        }
      ],
      "type": "prompt"
    },
    {
      "segments": [
        {
          "background": "#0077c2",
          "foreground": "#ffffff",
          "style": "plain",
          "template": "<#0077c2,transparent></>  {{ .Name }} <transparent,#0077c2></>",
          "type": "shell"
        },
        {
          "background": "#1BD760",
          "foreground": "#111111",
          "invert_powerline": true,
          "powerline_symbol": "",
          "options": {
            "paused_icon": " ",
            "playing_icon": " "
          },
          "style": "powerline",
          "template": "  {{ .Icon }}{{ if ne .Status \"stopped\" }}{{ .Artist }} - {{ .Track }}{{ end }} ",
          "type": "ytm"
        },
        {
          "background": "#f36943",
          "background_templates": [
            "{{if eq \"Charging\" .State.String}}#40c4ff{{end}}",
            "{{if eq \"Discharging\" .State.String}}#ff5722{{end}}",
            "{{if eq \"Full\" .State.String}}#4caf50{{end}}"
          ],
          "foreground": "#ffffff",
          "invert_powerline": true,
          "powerline_symbol": "",
          "options": {
            "charged_icon": " ",
            "charging_icon": " ",
            "discharging_icon": " "
          },
          "style": "powerline",
          "template": " {{ if not .Error }}{{ .Icon }}{{ .Percentage }}{{ end }}{{ .Error }} ",
          "type": "battery"
        },
        {
          "background": "#2e9599",
          "foreground": "#111111",
          "invert_powerline": true,
          "leading_diamond": "",
          "style": "diamond",
          "template": " {{ .CurrentDate | date .Format }} ",
          "trailing_diamond": "",
          "type": "time"
        }
      ],
      "type": "rprompt"
    }
  ],
  "console_title_template": "{{ .Shell }} in {{ .Folder }}",
  "final_space": true,
  "version": 4
}

git clone --depth 1 https://github.com/AstroNvim/template ~/.config/nvim \
  && rm -rf ~/.config/nvim/.git \
  && nvim

return {
  {
    "stevearc/oil.nvim",
    lazy = false,
    opts = {},
    keys = {
      { "-", "<cmd>Oil<cr>", desc = "Open parent directory" },
    },
  },
  {
    "nvim-mini/mini.nvim",
    version = false,
    config = function()
      require("mini.ai").setup()
      require("mini.surround").setup()
    end,
  },
}

/plugin marketplace add anthropics/claude-plugins-official

/plugin install code-review@claude-plugins-official
/plugin install code-simplifier@claude-plugins-official
/plugin install context7@claude-plugins-official
/plugin install pyright-lsp@claude-plugins-official
/plugin install skill-creator@claude-plugins-official
/plugin install superpowers@claude-plugins-official

/plugin marketplace add DietrichGebert/ponytail

/plugin install ponytail@ponytail

uv tool install graphifyy    # or: pipx install graphifyy
graphify install             # registers the /graphify skill with Claude Code

/graphify .                            # build the graph for this folder
/graphify . --update                   # re-read only the files that changed
/graphify query "how does X reach Y?"  # ask the graph a question

export NODE_SHELL="zsh"

getgnode() {
    local ngpus=1
    local time_limit="02:00:00"
    local partition="workq"  # Adjust for your cluster

    while [[ $# -gt 0 ]]; do
        case "$1" in
            -h|--help)
                echo "Usage: getgnode [OPTIONS]"
                echo "Allocate and attach to an interactive SLURM GPU node."
                echo ""
                echo "Options:"
                echo "  -g, --gpus INT         Number of GPUs to request (default: 1)"
                echo "  -p, --partition NAME   SLURM partition (default: workq)"
                echo "  -t, --time HH:MM:SS    Time limit (default: 02:00:00)"
                echo "  -h, --help             Show this help"
                return 0
                ;;
            -g|--gpus)      ngpus="$2";      shift 2 ;;
            -p|--partition) partition="$2";  shift 2 ;;
            -t|--time)      time_limit="$2"; shift 2 ;;
            *)
                echo "Error: Unknown argument '$1'"
                echo "Type 'getgnode --help' for usage."
                return 1
                ;;
        esac
    done

    salloc --partition="${partition}" \
           --gres=gpu:"${ngpus}" \
           --time="${time_limit}" \
           srun --pty "${NODE_SHELL:-zsh}"
}

fetchgnode() {
    if [[ "$1" == "-h" || "$1" == "--help" || -z "$1" ]]; then
        echo "Usage: fetchgnode <jobid>"
        echo "Attach a new shell to an existing SLURM job."
        return 0
    fi
    srun --jobid="$1" --overlap --pty "${NODE_SHELL:-zsh}"
}


slog() {
    if [[ -z "$1" ]]; then
        echo "Usage: slog <job_id> [lines]"
        echo "Tails the stdout log file for a given Slurm job."
        return 1
    fi

    local lines="${2:-50}"
    # Search current dir for slurm-<jobid>.out or <name>-<jobid>.out
    local logfile=$(ls -t *"$1"*.out 2>/dev/null | head -n 1)

    if [[ -n "$logfile" ]]; then
        echo "Tailing log: $logfile"
        tail -n "$lines" -f "$logfile"
    else
        echo "Error: No log file matching *'$1'*.out found in current directory."
        return 1
    fi
}

sfree() {
    echo "=== Available Cluster Resources ==="
    sinfo -N -h -o "%15P %10t %10G %N" | grep -E "idle|mix" | grep -v "drain" | column -t
}

snode() {
    if [[ -z "$1" ]]; then
        echo "Usage: snode <job_id>"
        echo "Lookup the host node of a running job and attach to it."
        return 1
    fi

    local node=$(squeue -j "$1" -h -o "%N" 2>/dev/null)
    if [[ -z "$node" || "$node" == "N/A" ]]; then
        echo "Error: Job $1 is not actively running."
        return 1
    fi

    echo "Connecting to job $1 on node [$node]..."
    srun --jobid="$1" --overlap --pty "${NODE_SHELL:-zsh}"
}


seffme() {
    if [[ -z "$1" ]]; then
        echo "Usage: seffme <job_id>"
        echo "Check peak memory, CPU efficiency, and exit codes for a job."
        return 1
    fi

    if command -v seff &>/dev/null; then
        seff "$1"
    else
        sacct -j "$1" --format=JobID,JobName%20,State,ExitCode,MaxRSS,ReqMem,AllocCPUS,Elapsed -X
    fi
}


rebatch() {
    if [[ $# -lt 2 ]]; then
        echo "Usage: rebatch <job_id> <script.sh>"
        echo "Cancels <job_id> and submits <script.sh>."
        return 1
    fi

    echo "Canceling job $1..."
    scancel "$1"
    echo "Submitting $2..."
    sbatch "$2"
}


alias sqm="squeue --me"

What Actually Stuck

Looking back, the journey was never really about finding the right distribution — though it took me a long time to admit that. Every distribution I used taught me something: Debian gave me discipline, Arch gave me depth, CentOS gave me an appreciation for stability, Nobara reminded me why community matters, Fedora showed me how polished a Linux desktop can be, and openSUSE Tumbleweed showed me that rolling release and reliability are not opposites.

What I was actually searching for was a coherent philosophy: a system I could understand completely, trust in production, enjoy on the desktop, and extend without fighting it. The distribution itself turned out to be the least important variable. openSUSE Tumbleweed with KDE is where I am happiest on the desktop — stable, community-driven, and free of version upgrades. AlmaLinux is where most of my containers and HPC environments live, and it has earned a place on some of my desktops too. And across every single one of them, Flatpak handles GUI applications and pixi handles everything else — Python environments, binary tools, cross-platform reproducibility — with a single unified interface that works identically whether I am on my workstation, my laptop, or a GH200 node on Isambard-AI.

The packages problem that once felt like an unsolvable compromise turned out to have a clean answer. I just had to wait for the Rust ecosystem to mature enough to build it — and stop insisting that the answer had to come bundled with a single distribution.