GitHub · Server deployment · Golden workflow

Deploy from GitHub

Ask Golden to install a GitHub-hosted project on the connected server without turning the conversation into a copy-paste relay. Golden can inspect the repository instructions and the real server, then use the tools already available there.

Quick answer: how do I deploy a GitHub project with Golden?

Connect the intended server, give the AI the repository URL or project name, and describe the outcome you want. Ask it to read the repository instructions first, inspect the server, install only what the project requires, start the application using the project's recommended production method and verify the result.

Install this GitHub project on the connected server. Read the repository instructions first. Inspect the server before changing it. Use the project's recommended install method. Do not remove or replace unrelated services. Start the application and verify logs, service state and the expected endpoint.

Good prompts describe the outcome and the safety boundary

You do not need to translate the whole README into shell commands before asking. Give the AI the repository and the boundaries that matter.

First installation

Deploy this repository to the connected VPS and get it running. Inspect the README and release instructions first. Tell me if it conflicts with an existing port or service before changing anything important. Verify the result when you are done.

Read-only planning first

Inspect this repository and the connected server. Do not change anything yet. Tell me the recommended deployment method, required packages, ports, storage and any risky steps.

Install into an existing environment

Install this project without changing unrelated nginx sites, databases or services. Reuse existing tools when appropriate. Ask before any destructive cleanup or replacement.

What Golden should do during a GitHub deployment

Read the project

Inspect README, release notes, Docker files, package manifests and example configuration before choosing commands.

Inspect the server

Check operating system, available runtime, disk space, ports, existing services and deployment directory.

Choose the correct installation path

Use Docker, system packages, a language runtime or the repository's own installer only when the project actually calls for it.

Configure the application

Create required local configuration without putting raw secrets into public code or documentation.

Start the real service

Use the project's intended production process so it remains supervised after the command finishes.

Verify

Read logs, check service/process state and test the intended local or public endpoint.

For the broader manual deployment process, see How to Deploy a GitHub Repository to a VPS or Server.

Private repositories need an existing approved GitHub credential

Golden should use a repository credential already approved for the server, such as a deploy key or another repository-scoped mechanism. Do not paste a private SSH key or long-lived access token into an ordinary AI prompt just to make the clone work.

Keep the authentication scope as narrow as practical. A deployment server usually does not need access to every repository in an account.

See Golden Secrets / Secure Input for the current secret-handling boundary and planned protected input flow.

Ask before destructive or infrastructure-wide changes

A first install often needs harmless package installation and new service files. Some repositories, however, recommend actions that can affect an existing server.

Use the approval-first workflow before:

removing existing packages or services;
replacing a live reverse-proxy configuration;
opening new public firewall ports;
deleting existing application data;
changing system-wide runtime versions that other applications use;
running destructive database migrations;
overwriting an occupied deployment directory.

See Permissions for the operating-system and approval boundary.

Do not stop at “installation complete”

Ask for observable proof that the requested application is actually running.

After deployment: - show the service/process state - inspect startup logs for errors - confirm the expected port is listening - call the health endpoint if the project has one - check the public HTTPS URL if it should be public - tell me what changed on the server

If the project has no health endpoint, use the best bounded check available from its documentation and runtime.

Updating an installed GitHub project is a deployment too

Do not assume every update is just git pull. Ask Golden to inspect the current Git state, the incoming version and the project's upgrade instructions before changing production.

Update this deployed project to the intended stable release. Inspect the current version and release notes first. Preserve a rollback path. Apply required dependencies, build steps or migrations. Restart only what is necessary and verify the service afterwards.

If the deployment fails, inspect the failing layer before retrying

Clone/auth: repository URL, deploy key, permission or rate limit.
Runtime: unsupported Node/Python/Java/Go version or missing system library.
Build: dependency conflict, compiler/toolchain or insufficient memory/disk.
Configuration: missing environment value, invalid path or database connection.
Startup: occupied port, wrong ownership, service user or missing file.
Public access: reverse proxy, firewall, DNS or TLS rather than the application itself.

See Troubleshooting for the general Golden diagnostic sequence.

Ready to deploy from GitHub?

Connect the intended server, send the repository to your AI and describe the result you want. Keep the AI in the conversation; let Golden handle the execution loop.

Connect Golden Read the full guide See the real case