Video summary

Why I’m moving to Linux (for real)

Main summary

Key takeaways

Technology

Summary (technological concepts, features, analysis)

1) Why the creator is moving work off a Mac (Linux + self-hosted remote compute)

The creator uses:

  • A MacBook historically for day-to-day development and “Codex” (AI coding agent) workflows.
  • Windows primarily for filming; real dev work is mostly Mac-based until the change.

Pain points with running AI agents locally on macOS

  • High CPU load / “hammers” the machine when Codex runs—especially for longer “end-to-end” agent tasks (e.g., waiting for PR, reviewing, iterating).
  • Annoyance / practical issues from leaving the laptop running agents (e.g., needing to leave for events/meetings while the machine is blocked by heavy local compute).
  • Unreliable remote networks (e.g., 5G issues in transit), which made local-agent usage feel worse.
  • macOS security process overhead (syspolicyd)
    • macOS tracks newly spawned processes aggressively.
    • Codex/sub-agents spawn many processes (including MCP server/client processes per agent thread), resulting in “horrible numbers,” fan noise, and hesitation to use advanced agent features.
  • Filesystem performance differences (macOS APFS)
    • Benchmarks reportedly show large slowdowns on macOS for operations involving many small files and package installs.
    • Reported results:
      • “Git clean” / small-file heavy ops: ~2.5s on Linux vs ~35s on Mac
      • PNPM-style installs / dependency-heavy ops: Linux ~7.3s vs ~35s on Mac, with claims that EXT4 can be up to ~30x faster for these patterns
    • Conclusion: macOS APFS is “rough” for their frequent work-tree / sub-agent workflow.

2) Cloud coding tools: useful, but pricing/token caps reduce value

The creator has tried and uses cloud IDE/agent workflows (e.g., Devin, Cursor, and “Codex cloud-like usage”), but notes:

  • Serverless/cloud isn’t the “right solution for a ton” of tasks.
  • Subsidized token plans (e.g., Quad/Codex) can make cloud seem cheaper until you hit limits.

They cite research-based pricing analysis from SemiAnalysis:

  • Quad Pro Max / similar $20/$100/$200 tiers → monthly inference amounts in the hundreds to thousands range.
  • Codex plans:
    • $200 plan: ~14,000/month
    • $100 plan: ~3,500/month
    • $20 plan: ~700/month

Takeaway:

  • If you can rely on subsidized personal/subscription tiers, cloud IDEs may work.
  • For enterprise or usage beyond caps, cloud value can drop.

3) Their new architecture: Linux machines + Tailscale networking + SSH + remote IDE control

They set up multiple machines and connect them via Tailscale.

Primary workflow (SSH + terminal multiplexer)

  • Use SSH with tmux/cmux for work (with Ghostty integration via cmux mentioned).
  • SSH session behavior:
    • On login, it instantly opens tmux.
    • If disconnected/reconnected, processes remain in the same state.
  • They organize machines in a sidebar (e.g., Mac mini, another Mac mini for team use, “BB1” new framework, HP Z book laptop).

Remote coding / agent access (GUI-capable)

  • Use T3 Code to access remote machines with GUI support over Tailscale.
  • Notes:
    • Described as working “like native,” including persistent terminals and the ability to run tasks remotely.
    • They can switch networks (including cellular/5G) and still connect because of Tailscale.

4) Handling “Codex computer use” gaps on Linux/macOS

Codex “computer use” is described as:

  • More stable on macOS
    • Examples include continued progress when the display is off and accessing apps not visibly open.
  • Less stable on Linux
    • They use it less frequently and in more targeted ways.

Limitation: image pasting over SSH

  • They take lots of screenshots and paste images into agents.
  • Over SSH, they report errors because pasting images over SSH isn’t supported (or is hard).

Network addressing considerations

  • Outside the home network, they may need different addresses.
  • Codex can sometimes “figure it out,” but it’s still a consideration.

Strategy: choose a “brains” machine (the MacBook)

The MacBook acts as the control/coordination point because it has:

  • SSH keys / passwordless SSH access to the Linux fleet.
  • A “fleet skill” describing machines, configurations, and default settings.
  • Prompt/style consistency and agent-driven configuration updates across the fleet.

They also run an agent-driven step to align Linux prompt styling to match the Macs.

5) Extra remote-control hardware: GL.iNet network KVM + “finger bot”

They use a GL.iNet Comet Pro (network KVM):

  • Enables full remote control over HDMI/USB (monitor + keyboard + mouse behavior over the network).
  • Provides more than SSH, including:
    • reboot
    • control bootloader
    • flash OS by mounting ISO storage via the KVM feature

They also mention a “finger bot”:

  • A robotic finger that physically presses a button (power/reset) remotely.
  • Useful for hard reboots and emergency recovery without someone onsite.

They demonstrate Codex “computer use” through the KVM on an Ubuntu machine:

  • Codex controls the desktop UI, navigates, and runs terminal commands.

Real recovery example (boot/installation repair)

  • They recover a broken Linux install/boot by:
    • copying partition data
    • using KVM access so Codex can interact with the GRUB bootloader and repair partitions remotely

6) Day-to-day agent workflow improvements enabled by remote compute

With remote Linux machines, they can run longer multi-step tasks without melting a laptop.

Workflow includes:

  • investigate repo
  • make changes
  • open PR
  • wait for PR review bots
  • address review comments
  • optionally consult Claude for additional opinions

Example remote task:

  • Using T3 Code to switch into worktrees and check orchestrator status for an ongoing change.

HTML reporting:

  • They host an “HTML plan” for modernization/audit results as part of the agent workflow (via a microservice they built).

7) Practical recommendations and costs

Core recommendation

  • You don’t need a top-tier laptop to make this worthwhile.
  • Offload Linux compute to modest multi-core machines.

Hardware example: GMK K8 Plus KVM-controlled Linux box

  • ~$400 without RAM/SSD
  • ~$740 with 32GB RAM + 1TB SSD (when on sale)

Cloud caution

  • They advise against running personal Claude Code subagents on cloud for policy reasons (Anthropic restrictions).
  • Prefer local network compute to avoid policy/control issues.

Automation suggestion

  • Recommend automating Linux setup:
    • “Tell Codex to configure the machine” instead of manual setup.

Main speakers / sources

  • Main speaker: the video creator (speaks throughout; refers to their own setup/workflow using “I”).
  • Sponsors / product sources mentioned:
    • Railway (sponsor segment) — includes CLI, “agents,” MCP support, and environment provisioning.
    • GL.iNet (not a sponsor) — Comet Pro network KVM and “finger bot.”
    • T3 Code and T3 Connect (creator’s/related ecosystem; described as an upcoming feature).
  • Third-party analysis source referenced:
    • SemiAnalysis (pricing/research figures).
  • Other product references:
    • Codex, Claude code, Devin, Cursor, Quad (token/subsidy context)
    • Tailscale
    • tmux / cmux / Ghostty
    • GRUB (bootloader repair example)

Original video