Deutsch
Claude Code is Anthropic's coding agent. It can read a repository, edit files and run commands, using the results to work through a development task. You can run its terminal interface on your own computer or in a remote workspace such as a VPS.
The useful distinction is where the work happens. The repository, build tools and tests run in the workspace; model requests use the configured provider over the network. A VPS can keep that workspace available when your laptop is offline, but you still need to review code changes and control access to the environment.
What Claude Code can do
Anthropic's Claude Code overview describes a tool that works with code and development tools. In a terminal session, it can inspect the project around a problem, make a change, run a test and use the output to decide what to investigate next.
For example, you can give it a reproducible bug and ask it to trace the failing request through the application. Its value comes from using the surrounding source and test results, rather than guessing from a single snippet. The resulting patch still needs review against the original requirement.
Check the official releases before relying on a particular feature or updating an established workspace.
Set up the workspace
Start with Anthropic's setup documentation. Its published Linux requirements include Ubuntu 20.04+, Debian 10+ or Alpine Linux 3.19+, an x64 or ARM64 processor, at least 4 GB RAM and internet access. Treat these as software requirements, then choose a maintained operating-system release suitable for your project.
The setup guide provides a native installer and platform-specific alternatives. Download installation scripts from the official source and inspect them before execution. Run the workspace under a non-root account with access to the intended repository.
The 4 GB requirement is a starting point for Claude Code itself. Dependency installation, compilation, browser tests, databases, containers and concurrent sessions may need substantially more memory, CPU and disk space. Measure a representative task before choosing a VPS size.
Authentication and billing
Follow the authentication guide for your account or provider. In the interactive terminal flow, an existing ANTHROPIC_API_KEY can take precedence after you approve it, instead of the normal browser login. Non-interactive runs can use an available key without that prompt.
Confirm the active method with /status, especially if the machine has both subscription credentials and an API key. Give the credential an owner, protect it from other users and check which account will receive the usage charges.
Settings and external tools
Claude Code supports user settings in ~/.claude/settings.json, shared project settings in .claude/settings.json and project-local settings in .claude/settings.local.json. Read the settings scope rules before committing a team rule or storing a machine-specific value.
MCP integrations connect the agent to additional tools and data. Review each server's permissions, credentials and destination systems before enabling it. A read-only documentation connection and a deployment tool require different access decisions.
Use a reviewable development loop
A useful session starts with a specific outcome and ends with evidence that it works:
- Confirm the repository, branch and existing changes.
- Provide the task, project instructions and acceptance criteria.
- Let the agent inspect the relevant source and reproduce the issue where possible.
- Review consequential commands and the scope of the patch.
- Run the project's relevant formatter, tests, build and user-flow checks.
- Review the result before merging or deploying it.
A passing test only proves what the test checks. Keep the original failure case and acceptance criteria available so the agent's implementation does not quietly become its own definition of success.
Practical use cases
Investigating a bug
Provide the symptom, reproduction steps and relevant logs with secrets removed. Ask Claude Code to identify the cause before changing code. Retain the reproduction and the test that demonstrates the correction, along with a rollback point.
Building a contained feature
Define the owning module, expected behaviour and interfaces that must remain compatible. The agent can draft the implementation and tests. Review the diff for unrelated changes, altered data formats and assumptions the task did not authorise.
Adding regression tests
Use a known failure and the project's existing test conventions. Confirm that the test fails against the broken version and passes with the fix. A test that repeats the implementation's logic may miss the same mistake.
Maintaining a project
Dependency updates, focused refactors and documentation changes can work well as bounded tasks. Review release notes, lockfiles, migrations and compatibility changes. Drafting release notes is separate from publishing a release.
Learning an unfamiliar repository
Ask for entry points, data flow and test commands with source references. Use that map to guide inspection, then confirm it against the actual code and running application. Generated explanations can become stale or miss indirect dependencies.
When a VPS helps
A VPS suits a Linux development environment that needs to remain reachable from several devices or keep builds and services running independently of a laptop. A terminal multiplexer or suitable supervisor can keep supported processes running after an SSH disconnect; the server staying online alone does not ensure that an interactive job survives.
A remote workspace is less useful when the project requires unavailable hardware, desktop-only tools or data that must remain in a controlled local network. Include connection latency, maintenance, backups and account administration in the decision.
For teams, use individual operating-system accounts and credentials, with separate workspaces or worktrees. Set resource limits where needed and keep experimental agent work away from production data and deployment credentials.
Understand what leaves the server
Anthropic's data-flow documentation explains that Claude Code sends data over the network to interact with the model. Prompts, outputs and repository content used as context may be part of that flow.
Review the selected provider's terms, retention and telemetry settings before using confidential code, customer information or production logs. Hosting the CLI on your own VPS does not mean model inference or all data processing stays there.
External tools can send information elsewhere too. Record which MCP servers and integrations are enabled, what data they can read, what they can change and how access can be revoked.
Keep access proportionate to the task
Apply the wider VPS security checklist, including SSH protection, updates, firewall rules and monitoring. Within the workspace:
- Use a dedicated branch or worktree with a known starting state.
- Keep secrets, production exports and unrelated repositories out of the accessible workspace.
- Configure permissions and sandboxing alongside operating-system access controls.
- Review hooks, installation scripts, project instructions and dependency scripts before execution.
- Require human approval for destructive changes, credentials, billing, migrations, merges and deployments.
- Run tests with credentials and network access appropriate to a test environment.
- Keep independent copies and rebuild instructions for data and configuration you need to recover.
A fetched page, issue or dependency README may contain instructions that do not belong to your task. Treat them as material to examine, rather than authority to expand the agent's permissions. Anthropic's security guide explains the tool's available controls.
Check the remote workflow before relying on it
| Area | What to confirm |
|---|---|
| Resources | A representative install, build and test fit the allocation |
| Access | Users have individual accounts and a removal process |
| Authentication | The correct credential and billing account are active |
| Data | The repository is permitted to use the selected model provider |
| Tools | Commands, hooks and integrations have appropriate permissions |
| Review | Diffs and relevant behaviour are checked before acceptance |
| Isolation | Tests cannot accidentally reach production data or services |
| Recovery | Required files and configuration can be restored |
| Maintenance | Someone owns updates, alerts and incident response |
Frequently asked questions
Does Claude Code need a GPU VPS?
Hosted-model requests do not require a GPU in the workspace. Choose CPU, RAM and storage for the repository's builds, tests and supporting services. Local inference or GPU-dependent project work would add separate requirements.
Can several developers use the same server?
Yes, with individual accounts, credentials, workspaces and suitable isolation. Avoid a shared Unix account or shared working branch that makes changes difficult to attribute or recover.
Does Virtarix manage Claude Code?
On a Virtarix VPS, you install and operate Claude Code and its integrations. Your team manages the software, credentials, updates and model-provider account.
Does a persistent server make the agent fully autonomous?
It gives the workspace a place to keep running. Permissions, task limits, review and explicit decisions about consequential actions still determine what the agent should do.
Official documentation
