What Claude Code Taught Us About Building Tools for the Terminal

Vindhya Data Science August 2026 ~8 min read

The most talked-about tool in software development is not a web app, IDE, or SaaS dashboard. It's Claude Code, and it runs in a terminal. You launch it from a shell prompt, you talk to it in monospace text, and it does its work inside the same little rectangle developers have been staring at since the 1970s. The most advanced AI coding agent on the market initially shipped as a TUI, a text user interface, and it works surprisingly well.

The popularity of Claude Code is reviving TUIs in general, and for good reason. They start instantly. They run anywhere — over SSH, inside a container, on old, underpowered laptops. They're primarily keyboard-driven, so your hands never need to reach for a mouse. And they are fast to develop. The modern generation of TUI frameworks like Go's Bubble Tea ecosystem make terminal apps feel new, with real layout, color, and interactivity giving a unique modern retro feel.

We're Vindhya Data Science — a team of data scientists, bioinformaticians, and engineers who spend most of our days analyzing sensitive data or engineering scientific software tools for clients. For us, having a secure, easy-to-deploy development environment is essential for getting our job done. Seeing the revival of TUI apps, we saw an opportunity to streamline our workflows using the latest technologies. So we developed our own tool: vmup.

The problem: secure sandboxes, on demand

A lot of our work follows the same shape. A scientist needs a containerized development environment running RStudio or Jupyter, with access to data, inside a Google Cloud project, behind a security boundary a client's compliance team will sign off on. It needs to be quick to create, easy to resize, and simple to destroy when the job is done.

Before vmup, "spinning up a VM" meant one of two things: twenty minutes of clicking through the GCP console, or a folder of copy-pasted gcloud commands and Terraform snippets that were subtly different on everyone's laptop. Both paths had the same failure modes. The risk of incorrectly configuring the infrastructure and exposing security vulnerabilities. Instances left running over the weekend because stopping them was a chore. And every new team member re-learning the same ritual from outdated documentation.

The fix wasn't more documentation. It was building a tool to make the infrastructure deployment easy. Inspired by the success and speed of the Claude Code TUI, we knew exactly what we wanted: type a command, get a full-screen terminal app, press a few keys, done.

What vmup does

vmup is a single-binary terminal application for launching and managing GCP compute instances. Under the hood it's Go and Bubble Tea; the Terraform configuration is embedded in the binary via go:embed, and Terraform itself is auto-downloaded on first run. The only prerequisite is the gcloud CLI. There is no server, no agent, no YAML to maintain — you install one file and run it.

Run vmup, and you get a live table of every instance in your project:

vmup - GCP Instance Manager

 1 Instances 2 Data Disks                          refreshed 3:04 PM

  VM Name        Project          Machine         Status
  ──────────────────────────────────────────────────────────────
> rstudio-demo   my-gcp-project   e2-highmem-2    RUNNING (1 tunnel)
  analysis-vm    my-gcp-project   e2-highmem-4    STOPPED
  ──────────────────────────────────────────────────────────────

  Image:         my-rstudio-image
  Port Mapping:  8787:8787
  Tunnel active: http://localhost:8787

  ↑/↓ navigate • : command • / filter • r refresh • ? help

Press n and you get a launch form with sensible defaults: the project ID is auto-detected from your gcloud config, regions and zones are fetched live from the Compute API, and machine types are filtered to your image's CPU architecture with a live hourly cost estimate next to each one, pulled from the Cloud Billing API. You see what a machine costs before it exists, which helps our team pick the right resources for the task at hand.

Submit, and vmup shows a review screen then runs terraform init and apply with the output streaming into the TUI. A few minutes later you have a running instance, SSH tunnels already established (nothing exposed to the public internet), and RStudio waiting at localhost:8787. The whole lifecycle is managed with single keystrokes: s to start, x to stop, c to connect to an interactive SSH session, Shift+D to destroy everything. Like Claude Code or vim, a : command palette makes every action discoverable and fuzzy-searchable, and / filters the list with queries like status:running.

Security by construction

The beauty of infrastructure as code (IaC): every vmup launch provisions a small, fully isolated stack. A dedicated VPC per deployment. Cloud NAT for outbound traffic. And firewall rules that accept inbound connections only from Google's Identity-Aware Proxy range. Easy to create, easy to destroy.

Instances get no public-facing open ports. Port scans find nothing — there is no path from the public internet to the VM. The only way in is an IAP tunnel authenticated with an authorized Google account.

All access — interactive SSH and forwarded services like RStudio — goes through IAP tunnels tied to your Google identity, and vmup's Terraform grants the required IAM role automatically at launch. Access control becomes identity and IAM rather than passwords and IP allowlists: remove someone's IAP role and their access is gone, instantly. Nobody on the team has to remember to configure any of this, because it's baked into the tool itself. Consistent, secure stacks.

Disposable VMs, persistent data

vmup VMs are designed to be disposable. Yet, we didn't want any precious data destroyed in the process. So vmup has a second tab for data disks — persistent disks that live independently of any VM. Since data and infrastructure have different lifecycles, vmup respects that they should exist independently. The stack can come down, but the same disk can easily be reattached later. Disks can be created, resized, attached, and mounted from the TUI, and a disk can be attached to multiple VMs read-only which is handy for sharing a reference dataset across projects. Deleting a disk requires a two-step confirmation to prevent a stray keystroke from wiping your precious data.

Why Go?

The Go language choice comes with a lot of advantages. vmup is written in Go, and the first reason for choosing this language is how we work: our scientists run macOS (Intel and Apple silicon), Linux, and Windows — sometimes all three on the same project. Go cross-compiles to every one of them from a single codebase, so each release ships native binaries for five platform-architecture combinations with no porting effort. And because Go builds a fully static executable, a data scientist doesn't need a toolchain to use an infrastructure tool — no Python environment to manage, no dependency drift between laptops, less computational overhead than containers. One curl | sh, and it runs.

The single-binary provides more than convenience. go:embed lets us ship the entire Terraform configuration inside the executable, so the infrastructure definition can't drift out of sync with the app that applies it. Everything vmup needs is either in the binary or auto-installed on first run. Since vmup's state is just files on disk, the portability extends across machines too. The settings screen lets you point the data directory anywhere, and pointing it at a synced or network drive means the same VMs and disks can be configured and managed from any machine you work on. Launch an instance from the Mac at the office, stop it from the Linux box at home. The binary behaves identically everywhere, so the state doesn't care where you're sitting. IaaC + single binary management tool creates portability.

Finally, the ecosystem is incredible. Bubble Tea and the rest of the Charm libraries live in Go, and goroutines are a natural fit for a tool that's simultaneously streaming Terraform output, polling GCP, and managing SSH tunnels. For a cross-platform terminal app that manages infrastructure, Go is a perfect fit.

With great speed comes great responsibility

There's a pleasant circularity here: a tool inspired by Claude Code's interface was, in large part, built with Claude Code's assistance. We had already built a working prototype of this tool that cobbled together bash, Terraform, and Python, but it lacked a polished user experience and the convenience of an executable. Claude was able to help us transform our collection of scripts into a stand-alone program. The Bubble Tea plumbing and the docs site came out of pair-writing sessions with the agent — grounded in context from the codebase and steered by our choices. Because of its self-contained toolchain, readability, and reliability, Go makes an ideal language for AI-assisted software engineering. Features we'd have previously budgeted a week for completed in an afternoon; well documented, highly structured components like forms and table views mostly wrote themselves.

Once you've felt the speed of developing with Claude, it's hard to go back. It's also exactly where responsibility matters. Our experience matches everyone else's. Claude is remarkably good at pattern-shaped work, and it will also confidently hand you a subpar solution or a plausible-looking Terraform attribute that doesn't exist. Learning to architect systems, to speak the same language as these agents, makes the end product that much better. Perhaps this take will be outdated in a few months or years, as tools like Beads equip agents with the infrastructure to systematically coordinate complex architecture and accelerate development loops. At least for now, the responsibility rests with us. Our decisions, the ones that make vmup vmup — the IAP-only security model, the disposable-VM philosophy, the choice that destroying anything requires typing its name — were made by humans, sometimes overriding Claude's tendencies.

Where it goes from here

vmup works well for our company, but there are plenty of future directions. Please give it a try and let us know what features should be added next. Here are a few on our minds:

Other cloud providers: vmup is GCP-native today, but nothing about the core model (embedded Terraform, identity-authenticated tunnels, no public ingress) is inherently GCP-specific. Extending it to AWS is the obvious next step.
Customizable Terraform templates: the stack vmup builds today is a good default, but infrastructure is never one-size-fits-all. Teams should be able to make adjustments, customize the resources vmup creates, or add their own infrastructure to the stack as they wish — GPUs, extra service accounts, project-specific networking — with the embedded template as a starting point rather than a ceiling.
Scheduled auto-stop: the TUI makes it quick to start and stop instances, but remembering to do so is still on the user. Developing solutions to automate this can help us further protect against unintentional cloud spend.
An MCP server and CLI: the direction we find most interesting. If agents like Claude Code are going to do real analytical work, they'll need to provision their own secure sandboxes. A vmup MCP server would let an agent request an environment and get a tunnel back — the TUI for humans, the same machinery for agents.

Try it

vmup is open source under the Apache 2.0 license. The only prerequisite is the Google Cloud SDK; Terraform installs itself on first run.

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/vindhyadatascience/vmup/main/install.sh | sh

Windows (PowerShell):

irm https://raw.githubusercontent.com/vindhyadatascience/vmup/main/install.ps1 | iex

Then run vmup, press n, and you're a few keystrokes from a secure analysis environment. The source is on GitHub, and the full documentation, including a first-VM walkthrough and the complete security model, lives at the vmup docs site. Issues and PRs welcome.

References

Claude Code: anthropic.com/claude-code
Bubble Tea: github.com/charmbracelet/bubbletea
Vindhya Data Science: vindhyadatascience.com
vmup (GitHub): github.com/vindhyadatascience/vmup
Go makes an ideal language for AI-assisted software engineering: developers.googleblog.com
Beads: beads.gascity.com
Google Cloud SDK: cloud.google.com/sdk/docs/install
vmup docs site: vindhyadatascience.github.io/vmup