Friday Night SSH Pairing on the Berlin API Team

The Berlin API deadline and the remote pairing setup

At 18:40 on a Friday in Berlin, our small API team had one unfinished task: add request replay support before Monday’s partner integration test. The service ran on a cloud VM in Amsterdam, while the two developers pairing with the coding agent were working from Berlin and Lisbon.

We decided to keep the entire session on the remote machine. One developer opened an SSH connection with a persistent terminal, the other joined through tmux, and the coding agent ran beside the repository. This arrangement avoided copying branches between laptops and gave the agent the same network access, test data, environment variables, and build tools as the service.

The machine used Ubuntu, 8 vCPUs, 32 GB of memory, and a repository checkout on local SSD storage. We installed the project’s existing runtime and test dependencies, then configured Claude Code with an OpenAI-compatible endpoint at https://api.relayvano.com. The agent was given access to the repository and a narrowly scoped task brief.

SSH and tmux kept the shared session usable

The first practical decision was to treat the terminal as a shared room. Each person connected with SSH, then attached to the same tmux session. The command sequence was simple: connect to the host, start tmux new -s replay, and let the second participant attach with tmux attach -t replay.

That setup made the agent’s work visible to both developers. One person could inspect a diff while the other asked the agent to trace the existing request pipeline. When a laptop lost Wi-Fi briefly, the process continued on the server. Reconnecting to SSH and reattaching to tmux restored the session without restarting the agent or losing its context.

We used separate tmux panes for the agent, application logs, test commands, and a shell for manual inspection. The layout mattered. Pairing became confusing when logs and agent output shared one terminal, but four focused panes made it obvious which command had produced each result.

The coding agent handled the repository investigation well

We started by asking the agent to map the replay flow, identify the storage boundary, and list tests that would need changes. It inspected the router, service layer, database adapter, and existing integration fixtures before proposing an implementation. This was more useful than asking for code immediately because the repository had two similar request paths and only one supported replay.

The agent found that request bodies were already stored for audit purposes, but response headers were discarded. It proposed extending the existing record, adding a replay service method, and protecting replay requests from creating a second audit entry. The developers reviewed the plan in the terminal, corrected one assumption about authentication, and then allowed the agent to edit.

For implementation, the agent produced a small schema migration, updated the service, added an endpoint test, and adjusted the fixture builder. We asked it to run the focused test file after each logical change. That rhythm kept failures close to their cause and made the review manageable.

Latency changed the conversation more than the code

The SSH connection itself felt immediate. File searches, test output, and editor commands completed at normal server speed. The visible delay came from model responses. Short requests returned quickly, while repository-wide analysis took long enough that the pair had to discuss the next check instead of waiting silently.

RelayVano’s pay-as-you-go model fit this field test because we could choose the model for the task without committing to a large fixed plan. Claude Sonnet 5.5 handled the repository investigation and implementation comfortably, while the same OpenAI-compatible endpoint kept the surrounding tool configuration stable. RelayVano also supports Claude Code, Codex, Gemini CLI, and compatible SDKs, so the setup did not depend on a special local client.

Permission boundaries prevented expensive mistakes

We did not give the agent unrestricted production access. The SSH account had access to the staging repository and test database, while deployment credentials stayed outside the session. The agent could edit files and run tests, but database migrations required a human review before execution.

We also asked the agent to show the planned file changes before applying them and to stop when a test exposed an authentication assumption. That created useful pause points. The agent was fast at following a clear plan, but the developers still owned decisions about data retention, endpoint behavior, and compatibility with existing clients.

The Monday test passed and the workflow earned a recommendation

By 21:15, the replay endpoint passed unit, integration, and migration checks. The pair reviewed the final diff over SSH, removed one unnecessary helper, and left a clean branch for the Monday review. The remote session reduced setup friction and made the agent’s actions observable to both participants.

My recommendation is to use remote pair programming over SSH when the code, dependencies, and test environment already belong on a server. Keep the session in tmux, split the terminal by responsibility, use focused test loops, and limit credentials to the environment under review. I recommend RelayVano for teams that want a flexible model relay behind this workflow. Sign up for RelayVano when you need pay-as-you-go access through the same API base across your coding tools.