Heiko Panjas

A Git-Aware PowerShell Prompt That Earns Its Keep

2026-04-30T11:00:00+02:00

I spend most of my working day in terminals. On Windows, that means PowerShell Core, where the default prompt is fairly minimal: a path and a greater-than sign, with no information about which branch you’re on, whether you have uncommitted work, or whether there’s a stash you set aside a while ago and haven’t returned to.

So I put together a small replacement.

What It Does

The prompt is built from three segments, each colour-coded to deliver information at a glance:

The server tag — a grey block showing the logon server name (title-cased) followed by a 𝚸 glyph. It’s a small orientation aid when you’re hopping between machines via RDP or remote sessions. You always know where you are.

$LogonServer = ConvertTo-TitleCase -InputString $env:LOGONSERVER
Write-Host -NoNewline "${LogonServer}[`u{1D6B8}] " -BackgroundColor Gray -ForegroundColor Black

The working directory — blue background for normal sessions, dark red when running as Administrator. The colour distinction has helped me catch a few accidental elevated operations. Remove-Item -Recurse doesn’t ask for confirmation, so a permanent visual cue is useful.

$isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(
  [Security.Principal.WindowsBuiltInRole]::Administrator)

$location = (Get-Location).Path
if ($isAdmin) {
  Write-Host -NoNewline "$($location) " -ForegroundColor Gray -BackgroundColor DarkRed
} else {
  Write-Host -NoNewline "$($location) " -BackgroundColor Blue -ForegroundColor Black
}

The git segment — this is where it gets interesting. When you’re inside a repository, a fourth block appears with:

The branch name, prefixed with a 𝚩 glyph
A background colour that shifts from dark green (clean) to dark yellow (dirty) — the traffic-light metaphor lets you read state at a glance without parsing text
Individual Unicode indicators for untracked (𝚰), unstaged (𝚳), and staged (𝚱) changes
A stash counter, when stashes exist, so they don’t get forgotten

Outside a git repository, the segment simply disappears. No noise.

The colour switching and indicator assignment look like this:

$isDirty = $hasUnstagedChanges -or $hasStagedChanges -or $hasUntrackedFiles
$bgColor = if ($isDirty) { "DarkYellow" } else { "DarkGreen" }

$stashCount = (git stash list 2>$null).Count
$stashInfo = if ($stashCount -gt 0) { " `u{1D6B8}:$stashCount " } else { "" }

$unstagedIndicator   = if ($hasUnstagedChanges) { "`u{1D6B3} " } else { "" }
$stagedIndicator     = if ($hasStagedChanges)   { "`u{1D6B1} " } else { "" }
$untrackedIndicator  = if ($hasUntrackedFiles)  { "`u{1D6B0}"  } else { "" }

Write-Host -NoNewline "`u{1D6A9}:" -ForegroundColor Black -BackgroundColor $bgColor
Write-Host -NoNewline "$gitBranch" -ForegroundColor Black -BackgroundColor $bgColor
# ... stash count and status indicators follow
Write-Host -NoNewline "$untrackedIndicator$unstagedIndicator$stagedIndicator" `
  -ForegroundColor Black -BackgroundColor $bgColor

Why Not Oh My Posh or Starship?

Both are excellent tools, and for many setups they’re the right choice. They’re also extra dependencies — binaries to install, configure with TOML or JSON, and keep updated. For something as fundamental as my prompt, I prefer a single function in my $PROFILE that I can read end to end and modify in a few seconds. No theme files, no font requirements beyond a Unicode-capable terminal, and one less moving part to debug after an update.

The entire thing is plain PowerShell. It calls git branch --show-current and git status --porcelain directly, parses the two-character status codes, and sets colours accordingly. The --porcelain flag matters here — it gives machine-readable output that’s stable across git versions, unlike the human-readable git status which is localised and can change format.

The Parsing

The git status --porcelain format uses a two-character prefix per file:

First character: index (staged) status
Second character: work tree (unstaged) status
?? means untracked

The code walks each line and sets three boolean flags. It doesn’t count files or build lists — it only needs to know whether each category has entries, not how many. That keeps it fast even in a repository with thousands of changed files, where you’d rather the prompt didn’t do more work than necessary.

$gitStatusOutput = git status --porcelain 2>$null

$hasUnstagedChanges = $false
$hasStagedChanges   = $false
$hasUntrackedFiles  = $false

if ($gitStatusOutput) {
  foreach ($line in $gitStatusOutput) {
    if ($line.StartsWith('??')) {
      $hasUntrackedFiles = $true
      continue
    }
    # Second character: work tree (unstaged) status
    if ($line.Length -gt 1 -and $line[1] -ne ' ') {
      $hasUnstagedChanges = $true
    }
    # First character: index (staged) status
    if ($line.Length -gt 0 -and $line[0] -ne ' ' -and $line[0] -ne '?') {
      $hasStagedChanges = $true
    }
  }
}

The `ConvertTo-TitleCase` Helper

A small utility at the top normalises the LOGONSERVER environment variable, which Windows stores in upper case with leading backslashes. It finds the first letter, uppercases it, and lowercases the rest — just enough to make the prompt easier to scan.

function ConvertTo-TitleCase {
  param(
    [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
    [string]$InputString
  )

  if ([string]::IsNullOrEmpty($InputString)) { return $InputString }

  for ($i = 0; $i -lt $InputString.Length; $i++) {
    if ([char]::IsLetter($InputString[$i])) {
      return $InputString.Substring(0, $i) +
             $InputString[$i].ToString().ToUpper() +
             $InputString.Substring($i + 1).ToLower()
    }
  }

  return $InputString
}

Living With It

I’ve used variations of this prompt for a while, and the part I appreciate most is the colour coding. A glance at the terminal tells me:

Am I in a git repo? (Is there a coloured git segment?)
Is there uncommitted work? (Yellow or green?)
Did I stage something I forgot to commit? (𝚱 visible?)
Am I running elevated? (Red path background?)

None of that requires reading — it’s all peripheral.

If you’d like to try it, drop the functions into your PowerShell profile (code $PROFILE) and make sure your terminal supports Unicode. Windows Terminal does out of the box. The Mathematical Bold Capital glyphs (U+1D6A9 and friends) render in most modern terminals and give the prompt a distinctive look without requiring a Nerd Font.

Here’s the full source — drop it into your $PROFILE and you’re done:

function ConvertTo-TitleCase {
  param(
    [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
    [string]$InputString
  )

  if ([string]::IsNullOrEmpty($InputString)) {
    return $InputString
  }

  # Find the first letter and capitalize it
  for ($i = 0; $i -lt $InputString.Length; $i++) {
    if ([char]::IsLetter($InputString[$i])) {
      return $InputString.Substring(0, $i) + $InputString[$i].ToString().ToUpper() + $InputString.Substring($i + 1).ToLower()
    }
  }

  # If no letter found, return original string
  return $InputString
}

# Enhanced git prompt for PowerShell Core
function prompt {

  # Show logon server with a PowerShell icon and convert to title case
  $LogonServer = ConvertTo-TitleCase -InputString $env:LOGONSERVER
  Write-Host -NoNewline "${LogonServer}[`u{1D6B8}] " -BackgroundColor Gray -ForegroundColor Black

  # Check if running as admin
  $isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

  # Start with the location part of the prompt
  $location = (Get-Location).Path
  if ($isAdmin) {
    Write-Host -NoNewline "$($location) " -ForegroundColor Gray -BackgroundColor DarkRed
  }
  else {
    Write-Host -NoNewline "$($location) " -BackgroundColor Blue -ForegroundColor Black
  }

  # Get Git branch and status if in a git repository
  if (Get-Command git -ErrorAction SilentlyContinue) {
    try {
      $gitBranch = git branch --show-current 2>$null
      if ($gitBranch) {
        # Get all status output
        $gitStatusOutput = git status --porcelain 2>$null

        # Initialize status flags
        $hasUnstagedChanges = $false
        $hasStagedChanges = $false
        $hasUntrackedFiles = $false

        if ($gitStatusOutput) {
          foreach ($line in $gitStatusOutput) {
            # Check for untracked files (indicated by '??')
            if ($line.StartsWith('??')) {
              $hasUntrackedFiles = $true
              continue
            }

            # Check if the second character is not a space (indicating unstaged change)
            if ($line.Length -gt 1 -and $line[1] -ne ' ') {
              $hasUnstagedChanges = $true
            }

            # Check if the first character is not a space (indicating staged change)
            if ($line.Length -gt 0 -and $line[0] -ne ' ' -and $line[0] -ne '?') {
              $hasStagedChanges = $true
            }
          }
        }

        # Set background color based on whether there are any changes
        $isDirty = $hasUnstagedChanges -or $hasStagedChanges -or $hasUntrackedFiles
        $bgColor = if ($isDirty) {
          "DarkYellow"
        }
        else {
          "DarkGreen"
        }

        # Check for stashes
        $stashCount = (git stash list 2>$null).Count
        $stashInfo = if ($stashCount -gt 0) {
          " `u{1D6B8}:$stashCount "
        }
        else {
          ""
        }

        $unstagedIndicator = if ($hasUnstagedChanges) {
          "`u{1D6B3} "
        }
        else {
          ""
        }
        $stagedIndicator = if ($hasStagedChanges) {
          "`u{1D6B1} "
        }
        else {
          ""
        }
        $untrackedIndicator = if ($hasUntrackedFiles) {
          "`u{1D6B0}"
        }
        else {
          ""
        }

        # Write opening angle bracket with background color
        Write-Host -NoNewline "`u{1D6A9}:" -ForegroundColor Black -BackgroundColor $bgColor

        # Write branch name
        Write-Host -NoNewline "$gitBranch" -ForegroundColor Black -BackgroundColor $bgColor

        # Add stash count if there are stashes
        if ($stashCount -gt 0) {
          Write-Host -NoNewline $stashInfo -ForegroundColor Black -BackgroundColor $bgColor
        }
        elseif ($isDirty) {
          # Write a space if there are no stashes
          Write-Host -NoNewline " " -ForegroundColor Black -BackgroundColor $bgColor
        }

        # Add status indicators
        Write-Host -NoNewline "$untrackedIndicator$unstagedIndicator$stagedIndicator" -ForegroundColor Black -BackgroundColor $bgColor

        # Determine if we need a separator
        $hasAnyIndicators = $stashCount -gt 0 -or $hasUnstagedChanges -or $hasStagedChanges -or $hasUntrackedFiles
        if ($hasAnyIndicators -eq $false) {
          Write-Host -NoNewline " " -ForegroundColor Black -BackgroundColor $bgColor
        }
      }
    }
    catch {
      # Not in a git repository or git command failed
    }
  }

  # Close the bracket
  if ($isAdmin) {
    Write-Host -NoNewline ">"
  }
  else {
    Write-Host -NoNewline ">"
  }

  # Return a space for the actual prompt
  return " "
}

Stop Hardcoding API Keys in Your PowerShell Profile

2026-04-30T10:00:00+02:00

If you work with AI coding agents on Windows, you’ve probably got a handful of API keys that need to be available as environment variables in every terminal session. The straightforward approach is to put them directly into your $PROFILE:

$env:ANTHROPIC_API_KEY = "sk-ant-api03-..."
$env:OPENAI_API_KEY = "sk-proj-..."

This works, but the secrets then live in a plain text file on disk. Any process running as your user can read them, and if your dotfiles are in a Git repo there’s an extra risk of accidentally committing the file.

macOS has the security command, which reads secrets from the system Keychain in a single line you can pipe into an environment variable. On Windows, the equivalent store is the Credential Manager — the same place that holds saved Wi-Fi passwords and browser credentials — but there’s no built-in CLI to query it from PowerShell.

Existing PowerShell Modules

The first instinct is to install a PowerShell module. The Gallery has a few options with names like CredentialManager or CredentialManagement. Coverage and maintenance vary: some haven’t been updated in a while, some only target Windows PowerShell 5.1, and behaviour under pwsh 7 isn’t always reliable. After trying a couple of them, I went looking for a smaller alternative.

Calling the Win32 API Directly

The Windows API for reading credentials is CredRead in advapi32.dll. It’s been stable since Windows XP, and you can call it directly from PowerShell via Add-Type with a small C# shim — no modules, no NuGet packages, no dependencies beyond what ships with Windows.

Here’s the complete solution. Drop this into your $PROFILE (edit it with code $PROFILE or notepad $PROFILE):

Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;

public class CredManager {
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct CREDENTIAL {
        public uint Flags;
        public uint Type;
        public string TargetName;
        public string Comment;
        public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
        public uint CredentialBlobSize;
        public IntPtr CredentialBlob;
        public uint Persist;
        public uint AttributeCount;
        public IntPtr Attributes;
        public string TargetAlias;
        public string UserName;
    }

    [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern bool CredRead(string target, uint type, uint flags, out IntPtr credential);

    [DllImport("advapi32.dll")]
    private static extern void CredFree(IntPtr credential);

    public static string Read(string target) {
        IntPtr ptr;
        if (!CredRead(target, 1, 0, out ptr))
            return null;
        var cred = (CREDENTIAL)Marshal.PtrToStructure(ptr, typeof(CREDENTIAL));
        string secret = Marshal.PtrToStringUni(cred.CredentialBlob, (int)cred.CredentialBlobSize / 2);
        CredFree(ptr);
        return secret;
    }
}
"@ -ErrorAction SilentlyContinue

$env:ANTHROPIC_API_KEY = [CredManager]::Read("ANTHROPIC_API_KEY")
$env:OPENAI_API_KEY = [CredManager]::Read("OPENAI_API_KEY")
$env:MISTRAL_API_KEY = [CredManager]::Read("MISTRAL_API_KEY")

The -ErrorAction SilentlyContinue on Add-Type is important: without it, opening a second terminal tab would fail because the CredManager type is already loaded in the current process and .NET refuses to define it again.

Storing Credentials

Before the profile can read anything, you need to put your keys into the Credential Manager. The built-in cmdkey command does this:

cmdkey /generic:"ANTHROPIC_API_KEY" /user:"heiko" /pass:"sk-ant-api03-..."
cmdkey /generic:"OPENAI_API_KEY" /user:"heiko" /pass:"sk-proj-..."

The /user: value doesn’t matter for this use case — the code only reads the password blob. Pick whatever makes sense when you see it listed in the Credential Manager UI.

You can also add credentials through the GUI: open “Credential Manager” from the Start menu, select “Windows Credentials”, and click “Add a generic credential”.

How It Works

The C# shim does three things:

CredRead looks up a “Generic Credential” (type 1) by its target name and returns a pointer to a CREDENTIAL struct in unmanaged memory.
Marshal.PtrToStructure copies the unmanaged struct into a managed C# object so we can read its fields.
Marshal.PtrToStringUni reads the credential blob — which is stored as a UTF-16 byte array — into a .NET string. The blob size is in bytes, so we divide by 2 to get the character count.
CredFree releases the unmanaged memory that CredRead allocated.

The credentials are stored encrypted under your Windows user profile using DPAPI. They can only be decrypted by processes running as your user account on your machine. This is the same protection that Windows uses for saved passwords in Edge, RDP connections, and mapped network drives.

Verifying It Works

After reloading your profile (. $PROFILE or just open a new terminal), check that the variables are set:

$env:ANTHROPIC_API_KEY.Substring(0, 12) + "..."
# sk-ant-api0...

Don’t echo the full key — the point of all this is to keep it out of plain text.

Why Not Use `$env:` in the System Settings?

You could set environment variables through the Windows system UI (“Edit environment variables for your account”). The problem: those values are stored in the registry in plain text, visible to any process that can read HKCU\Environment. You’re trading one plain text location for another.

Why Not Use a `.env` File?

A .env file has the same drawback: it’s plain text on disk. It is somewhat better than hardcoding in your profile because you can .gitignore it, but it’s still unencrypted and readable by anything running as your user.

The Credential Manager approach gives you OS-level encryption at rest, per-user isolation, and a stable Windows API that should keep working across PowerShell and Windows versions. For roughly 30 lines of C# pasted once into your profile, that seems like a reasonable trade.

Installation Instructions for Coding Agents

2026-02-18T10:00:00+01:00

Terminal-native coding agents have become a staple of modern development workflows. This post collects the canonical installation commands for the four CLIs I currently rotate between — Claude Code, OpenAI Codex CLI, GitHub Copilot CLI, and Mistral Vibe — across macOS, Linux, and Windows. Each section lists the options pulled straight from the upstream documentation, so you can pick whichever fits your package manager of choice.

Prerequisites

Linux, macOS, or Windows
~/.local/bin in PATH (Linux/macOS)
Bun (for GitHub Copilot CLI and OpenAI Codex CLI)
uv (for Mistral Vibe)

Claude Code

Native install (macOS/Linux/WSL, recommended):

curl -fsSL https://claude.ai/install.sh | bash

macOS (Homebrew):

brew install --cask claude-code

Windows (PowerShell):

irm https://claude.ai/install.ps1 | iex

Windows (WinGet):

winget install Anthropic.ClaudeCode

OpenAI Codex CLI

Cross-platform (Bun):

bun add -g @openai/codex

macOS (Homebrew):

brew install --cask codex

Or download the binary for your platform (including Windows) from the latest GitHub release.

GitHub Copilot CLI

See the Getting Started guide for details.

macOS/Linux (Homebrew):

brew install copilot-cli

Windows (WinGet):

winget install GitHub.Copilot

Cross-platform (Bun):

bun add -g @github/copilot

Mistral Vibe

See the README for details.

macOS/Linux (one-line install):

curl -LsSf https://mistral.ai/vibe/install.sh | bash

Cross-platform (uv):

uv tool install mistral-vibe

Verify Installations

claude --version
codex --version
copilot --version
vibe --version

CoreML Models for whisper.cpp

2024-11-26T21:31:55+01:00

A guide for setting up and converting Whisper models to Core ML format on Apple Silicon Macs, following the official whisper.cpp Core ML instructions.

Prerequisites

Make sure Xcode and the command-line tools are installed:

$ xcode-select --install

macOS Sonoma (14) or newer is recommended; older releases can suffer from transcription hallucinations with Core ML models.

Miniconda Installation Instructions

These commands install Miniconda on a Mac with Apple Silicon (ARM64) processor. First, it downloads the installation script using curl. Then it runs the script in batch mode (-b), updating any existing installation (-u), and installing to the specified directory (-p). Finally, it removes the downloaded installer file. Replace <MINICONDA_DIRECTORY> with your desired installation path, like ~/miniconda3.

$ curl -LO https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
$ bash Miniconda3-latest-MacOSX-arm64.sh -b -u -p <MINICONDA_DIRECTORY>
$ rm Miniconda3-latest-MacOSX-arm64.sh

Create the Python Environment

These commands set up and activate a new conda environment. First, the source command activates conda in your current shell session, making the conda command available. Replace <MINICONDA_DIRECTORY> with your Miniconda installation path. The conda create command makes a new environment named “py311-whisper” with Python 3.11 installed (the version recommended by the upstream project). The -n flag sets the environment name, while python=3.11 specifies the Python version. The -y flag automatically answers “yes” to prompts. Finally, conda activate switches into the newly created environment, where you can start installing and using packages.

$ source <MINICONDA_DIRECTORY>/bin/activate
$ conda create -n py311-whisper python=3.11 -y
$ conda activate py311-whisper

Install the Required Python Packages

These commands install the Python packages needed to convert Whisper models to Core ML format. ane_transformers provides Apple Neural Engine optimizations, openai-whisper is the upstream speech recognition model, and coremltools performs the conversion to Apple’s Core ML format.

$ pip install ane_transformers
$ pip install openai-whisper
$ pip install coremltools

Download the whisper.cpp Models

These commands set up the GGML version of the Whisper model. First, it changes to the models directory within your Whisper installation (replace <WHISPER_DIRECTORY> with your actual Whisper directory path). Then it runs a script to download the “base” size GGML model, which is an optimized version of Whisper designed for CPU inference. The base model offers a good balance between accuracy and resource usage.

$ cd <WHISPER_DIRECTORY>/models
$ ./download-ggml-model.sh base

Note: Other available models are tiny, small, medium, large-v1, large-v2, large-v3 and large-v3-turbo. English-only variants (e.g. base.en, small.en) are also available and tend to be more accurate for English audio.

Convert the whisper.cpp Models

This command converts the base Whisper model to Core ML format. It runs a script that transforms the previously downloaded GGML base model into Apple’s Core ML format, optimized for the Apple Neural Engine. The result is a models/ggml-base-encoder.mlmodelc directory that whisper.cpp will load automatically when built with -DWHISPER_COREML=1.

$ ./generate-coreml-model.sh base

Note: Repeat for other models if needed, e.g. tiny, small, medium, large-v1, large-v2, large-v3 or large-v3-turbo. The first run on a device is slow because the ANE service compiles the model to a device-specific format; subsequent runs are fast.

Remove the Python Environment

These commands clean up the conda environment setup. First, conda deactivate exits the current environment and returns to the base conda environment. Then conda env remove deletes the “py311-whisper” environment and all its installed packages, freeing up disk space. This is useful when you’re done with your work and want to clean up your system.

$ conda deactivate
$ conda env remove -n py311-whisper

whisper.cpp for macOS

2024-11-25T21:31:55+01:00

A guide for building whisper.cpp with Metal and Core ML support on macOS.

Install the Required Build Tools

This command uses Homebrew (macOS’s package manager) to install two essential build tools. cmake is a cross-platform build system generator that manages the compilation process, while ninja is a small, fast build system designed to run builds quickly. These tools are often required dependencies when compiling software from source code.

$ brew install cmake ninja

Checkout the whisper.cpp Sources

These commands set up the C++ implementation of the Whisper model. First, git clone downloads the whisper.cpp repository to your specified directory (replace <WHISPER_DIRECTORY> with your desired path). Then it changes into that directory using cd. Finally, it creates and switches to a new branch named “v1.8.4” based on the v1.8.4 tag, ensuring you’re using a stable, tested version of the code.

$ git clone https://github.com/ggml-org/whisper.cpp <WHISPER_DIRECTORY>
$ cd <WHISPER_DIRECTORY>
$ git checkout -b v1.8.4 v1.8.4

Note: v1.8.4 is the latest release at the time of writing. You can find the newest version by running git describe --tags anytime.

Download the whisper.cpp Base Model

This command downloads the optimized GGML version of Whisper’s base model. The script download-ggml-model.sh is located in the models subdirectory and downloads the “base” size model, which is a good balance between accuracy and resource usage. The GGML format is specifically optimized for CPU inference, making it efficient for running on desktop computers.

$ models/download-ggml-model.sh base

Configure Hardware Support

Metal

This command sets up the build configuration for the project using CMake. It uses the Ninja build system generator, creates the build files in a directory named “build”, and configures for a release build with optimizations enabled rather than debug settings. Metal acceleration is enabled by default on Apple Silicon, so no extra flag is required.

$ cmake -G Ninja -B build -DCMAKE_BUILD_TYPE=Release

CoreML

This command sets up the build configuration for the project using CMake. It’s similar to the previous configuration but adds Core ML support through the -DWHISPER_COREML=1 flag. This enables the project to use Apple’s Neural Engine for faster Encoder inference on Apple Silicon Macs (more than 3x faster than CPU-only).

$ cmake -G Ninja -B build -DCMAKE_BUILD_TYPE=Release -DWHISPER_COREML=1

Build

This command compiles the project using the configuration we set up earlier. It tells CMake to build the project using the files in the “build” directory with Release configuration settings, which enables optimizations for best performance. The build process will create the executable files needed to run the program.

$ cmake --build build --config Release

Test

This command runs the compiled whisper-cli binary to transcribe speech from an audio file. It uses the base GGML model located at models/ggml-base.bin to process the sample audio file samples/jfk.wav (which contains a JFK speech). The -m flag specifies the model path, and -f specifies the input audio file path.

$ build/bin/whisper-cli -m models/ggml-base.bin -f samples/jfk.wav

Note: The previous main binary was renamed to whisper-cli in newer releases.

Heiko Panjas

A Git-Aware PowerShell Prompt That Earns Its Keep

What It Does

Why Not Oh My Posh or Starship?

The Parsing

The ConvertTo-TitleCase Helper

Living With It

Stop Hardcoding API Keys in Your PowerShell Profile

Existing PowerShell Modules

Calling the Win32 API Directly

Storing Credentials

How It Works

Verifying It Works

Why Not Use $env: in the System Settings?

Why Not Use a .env File?

Installation Instructions for Coding Agents

Prerequisites

Claude Code

OpenAI Codex CLI

GitHub Copilot CLI

Mistral Vibe

Verify Installations

CoreML Models for whisper.cpp

Prerequisites

Miniconda Installation Instructions

Create the Python Environment

Install the Required Python Packages

Download the whisper.cpp Models

Convert the whisper.cpp Models

Remove the Python Environment

whisper.cpp for macOS

Install the Required Build Tools

Checkout the whisper.cpp Sources

Download the whisper.cpp Base Model

Configure Hardware Support

Metal

CoreML

Build

Test

The `ConvertTo-TitleCase` Helper

Why Not Use `$env:` in the System Settings?

Why Not Use a `.env` File?