Giving AI Its Own Computer

I’ve been running Claude Code (CC) on my management server — ubuntu-hp01 — for a few months now. It’s been a great workflow: SSH in, run claude, and let it help manage my homelab infrastructure, write blog posts, deploy services, and troubleshoot issues. But it’s always been limited to the terminal. No browser, no GUI, no way to visually verify what it just deployed.

So I gave it its own computer.

The Machine

I had an HP Pavilion sitting idle — an Intel i5-9400 with 6 cores, 16GB RAM, and a 120GB NVMe. Nothing fancy, but more than enough for a dedicated AI workstation. I installed Linux Mint 22.3 (Zena) on it, named it ccmint (CC + Mint, get it?), and plugged it into the homelab network.

The key difference from ubuntu-hp01: it has a monitor, keyboard, and a full desktop environment. This matters more than you’d think.

What CC Can Do Now

On ubuntu-hp01, CC could read files, run commands, manage Kubernetes, and write code. On ccmint, it gets all of that plus:

Visible browser automation — Playwright opens a real Chromium window. I can watch CC navigate sites, fill forms, and test web apps in real-time
Desktop interaction — xdotool and xclip let it simulate mouse clicks, keyboard input, and clipboard operations on any GUI application
Screenshots — scrot and maim can capture what’s on screen for visual debugging
Full dev environment — VS Code, Docker, Chrome, all running locally with a display

It’s the difference between “can write code” and “can use a computer like a human.”

The Setup

Here’s the fun part: CC set itself up. I SSH’d from ubuntu-hp01 to the fresh Mint install and told CC what I wanted. It handled the rest:

Base Tools

# The basics
sudo apt install -y git build-essential curl wget unzip jq htop tmux

# Node.js 22 via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
nvm install 22

# Claude Code itself
npm install -g @anthropic-ai/claude-code

Infrastructure Access

# kubectl for both clusters
curl -LO "https://dl.k8s.io/release/$(curl -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install kubectl /usr/local/bin/kubectl

# AWS CLI for Bedrock API access
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip
unzip awscliv2.zip && sudo ./aws/install

# Docker
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Then we copied over kubeconfig (both cluster contexts), SSH keys, AWS credentials, git config, and all of CC’s memory files from ubuntu-hp01.

GUI & Browser Control

# Desktop automation
sudo apt install -y xdotool xclip scrot maim

# Visible browser
npm install -g @playwright/mcp@latest
npx playwright install --with-deps chromium

# Desktop apps
sudo apt install -y vlc
# Plus Chrome, VS Code, Slack via .deb packages

MCP Servers

This is where it gets interesting. MCP (Model Context Protocol) servers extend what CC can do. We set up eight of them:

Server	Purpose
Brave Search	Web search without leaving the terminal
Playwright	Full browser automation with a visible window
UniFi MCP	Direct control of network infrastructure
Context7	Fresh, version-specific library documentation
Sequential Thinking	Better reasoning on complex multi-step problems
Fetch	HTTP requests to any API
Filesystem	Explicit file access beyond the project directory

The Playwright config is the interesting one. On ubuntu-hp01, it runs headless (no display). On ccmint, we removed the --headless flag so the browser window is visible on the desktop. I can literally watch CC browse the web.

The Bedrock Gotcha

CC uses AWS Bedrock for API access, which requires the environment variable CLAUDE_CODE_USE_BEDROCK=1. On ubuntu-hp01, this wasn’t persisted in .bashrc — I’d been setting it manually every session without realizing it. We fixed that on both machines:

echo "export CLAUDE_CODE_USE_BEDROCK=1" >> ~/.bashrc

Small thing, but the kind of paper cut that wastes five minutes every time you forget.

Architecture

Here’s how ccmint fits into the homelab:

┌─────────────────────────────────────────────────┐
│                  Homelab Network                 │
│                  10.10.10.0/24                   │
│                                                  │
│  ┌──────────────┐     ┌───────────────────────┐  │
│  │  ubuntu-hp01  │     │     kubecluster01     │  │
│  │  10.10.10.70  │     │  10.10.10.71-77       │  │
│  │  MicroK8s     │     │  RKE2 (7 nodes)       │  │
│  │  Rancher      │     │  Production workloads │  │
│  └──────────────┘     └───────────────────────┘  │
│                                                  │
│  ┌──────────────┐     ┌───────────────────────┐  │
│  │    ccmint     │     │        nas2           │  │
│  │ 10.10.10.166  │     │    10.10.10.20        │  │
│  │ CC Workstation│     │    Synology NAS       │  │
│  │ GUI + Browser │     │    NFS Storage        │  │
│  └──────────────┘     └───────────────────────┘  │
└─────────────────────────────────────────────────┘

ccmint sits outside the Kubernetes clusters entirely. It’s a standalone workstation that can talk to both clusters via kubectl, SSH into any node, browse any web UI, and run Docker containers independently.

What’s Next

The immediate plan is to start running CC directly on ccmint instead of over SSH from ubuntu-hp01. Having a local display opens up workflows that weren’t possible before:

Visual testing — build a site change, preview it in a real browser, iterate
Dashboard monitoring — have CC periodically screenshot Grafana and flag anomalies
Web UI automation — interact with services that don’t have great APIs (looking at you, Rancher)
Development containers — test deployments locally before pushing to the cluster

The bigger picture is that this is a step toward CC being more of a collaborator and less of a tool. When it can see what’s on screen and interact with any application, the workflow becomes more natural — more like pair programming with someone sitting next to you.

The Meta Moment

I should mention: CC wrote most of this blog post too. And it set up the machine it’s writing about. And it committed the config changes to the repo. There’s something satisfyingly recursive about an AI documenting how it set up its own workstation.

Welcome home, ccmint.