Cloud Code is a set of plugins that bring Google Cloud into your code editor.

An IDE, short for integrated development environment, is the program where developers write code. Popular examples are Visual Studio Code and the IntelliJ family from JetBrains. Cloud Code is an add-on, often called an extension or plugin, that you install into these editors. Once installed, your editor gains new abilities: creating projects from samples, running them on a cluster, debugging them, deploying them to Google Cloud, and managing related resources.

Google’s documentation describes Cloud Code as providing IDE support for the full development cycle of Kubernetes and Cloud Run applications, from creating an application from sample templates to running the finished application. That sentence contains the whole idea: it supports you from the first day of a new project to the day it is running.

Two words you will hear often

Kubernetes is an open source system that runs and manages containers, which are small, self-contained packages holding an application and everything it needs to run. Google Kubernetes Engine, or GKE, is Google’s managed version of it. Cloud Run is a Google Cloud service that runs containers for you without making you manage servers. Cloud Code is especially focused on these two, because both involve a lot of configuration that is tedious to manage by hand.

Building for the cloud involves many small tools, and switching between them is slow.

To build a cloud application the traditional way, a developer writes code in an editor, builds a container image with a separate tool, writes configuration files in a format called YAML, runs commands in a terminal to deploy, opens a web console to look at logs, and repeats this loop dozens of times a day. Each switch costs a little time and attention, and each handwritten configuration file is a chance to make a typing mistake.

You can use Cloud Code in VS Code, in JetBrains IDEs, and in the browser-based Cloud Shell Editor.

Google lists three supported environments. Their feature sets are similar, but not identical, so it is wise to check the feature table for your chosen editor.

flowchart LR
  VS["VS Code"] --> CC["Cloud Code"]
  IJ["IntelliJ and JetBrains IDEs"] --> CC
  CS["Cloud Shell Editor"] --> CC
  CC --> GKE["GKE clusters"]
  CC --> CR["Cloud Run"]
  CC --> SVC["Secret Manager, Cloud APIs, and more"]
        

Which one should a beginner choose?

A short glossary makes everything else easier to read.

The features fall into a handful of groups, each matching a stage of development.

Based on Google’s documentation, Cloud Code offers these major capabilities: run-ready and debug-ready sample applications, running and debugging Kubernetes applications under development, advanced Kubernetes YAML support, resource inspection and browsing, GKE cluster creation, Cloud Run and Cloud Run functions support, Skaffold configuration editing, Secret Manager support, Cloud APIs browsing, and integration with Gemini Code Assist. Some features also touch other products such as Compute Engine and Cloud SQL, and the exact set depends on your editor.

flowchart LR
  A["Start from a sample"] --> B["Write code and YAML"]
  B --> C["Build the image"]
  C --> D["Run on cluster or emulator"]
  D --> E["Debug"]
  E --> B
  D --> F["Deploy to GKE or Cloud Run"]
  F --> G["Watch logs and resources"]
        

Getting started means installing the plugin, signing in, and choosing a project.

The fastest way to learn is to start from something that already works.

Google describes Cloud Code as providing run-ready and debug-ready sample applications. A sample is a small, complete project in a chosen language that already includes its configuration. When you create a new application, you can pick a sample instead of an empty folder. You then run it immediately and see it working before you change a single line.

Cloud Code makes writing, running, and debugging Kubernetes applications far less painful.

Creating and running on GKE

Per Google’s documentation, you can create and run a new GKE application or work on an existing one, and run applications on any of your GKE clusters. The plugin can also help you create a GKE cluster from within the editor. It works with local tools such as minikube and kubectl, and supports Arm and mixed-architecture clusters.

Smarter YAML

Kubernetes manifests are written in YAML, a format that depends on correct spacing. Cloud Code provides intelligent authoring support for customizing these files. In plain terms, the editor helps you complete fields, warns about problems, and offers snippets, so you make fewer typing mistakes.

Browsing cluster resources

Cloud Code lets you inspect and browse Kubernetes resources, so you can see what is running without switching to a terminal. You can look at workloads, services, and logs from a tree in the editor sidebar.

Modules for bigger applications

Large applications are made of several parts. Cloud Code supports Skaffold modules, which let you define dependencies between configuration files and develop and debug parts of the application independently. This means you can work on one service without rebuilding everything else.

sequenceDiagram
  participant Dev as Developer
  participant IDE as Editor with Cloud Code
  participant SK as Skaffold
  participant K as GKE cluster
  Dev->>IDE: Run on Kubernetes
  IDE->>SK: Start build and deploy
  SK->>K: Deploy the application
  K-->>IDE: Logs and status
  Dev->>IDE: Edit code
  IDE->>SK: Detect change
  SK->>K: Update the running app
  K-->>IDE: Fresh logs
        

Cloud Run support lets you create, test, and deploy services without leaving the editor.

Cloud Run runs your containers and scales them automatically, even down to zero when nobody is using them. Cloud Code adds the ability to create and deploy a service from the editor, to monitor its progress in the Cloud Run Explorer, and to read its logs in the Log Viewer. Google’s overview also lists support for Cloud Run functions.

The built-in Cloud Run emulator

A key feature is a local Cloud Run emulator. It imitates Cloud Run on your own computer, so you can develop and debug a service without deploying it first. This is faster, free of cloud charges for the test runs themselves, and safer for early experiments.

flowchart LR
  A["Write service code"] --> B["Run in local Cloud Run emulator"]
  B --> C{"Works as expected?"}
  C -->|"No"| A
  C -->|"Yes"| D["Deploy to Cloud Run"]
  D --> E["Check Cloud Run Explorer and logs"]
        

Building images without a recipe

Google’s IntelliJ page notes that you can build container images from source with Google Cloud buildpacks, without writing a Dockerfile. A Dockerfile is the recipe for building an image. For beginners, skipping it removes a whole topic to learn at the start, though you can adopt it later if you need finer control.

Debugging means pausing a running program to inspect what it is doing and why.

When software misbehaves, you need to look inside it. A debugger lets you set a breakpoint, a marker on a line of code where the program pauses. When it pauses, you can read variable values, step one line at a time, and discover where things go wrong. The challenge in cloud development is that the program is not on your laptop; it is inside a container in a cluster. Cloud Code connects your editor’s debugger to the remote container, so debugging feels almost the same as debugging local code.

Skaffold is the automation tool that makes the build, deploy, and watch loop work.

Skaffold is an open source command line tool that automates the steps between writing code and seeing it run. It reads a configuration file that describes how to build your images and how to deploy them. Cloud Code provides editing support for that file, and uses Skaffold when you press run or debug. Knowing that Skaffold exists helps you understand what the plugin is doing for you.

Why modules matter

As noted in Google’s documentation, modules allow you to define dependencies between Skaffold configuration files. For a system with a web front end, an API, and a database service, you can run only the pieces you are working on, together with the pieces they depend on. This saves time and computer memory.

Cloud Code also helps with the small supporting tasks around your application.

Secret Manager

Secrets such as passwords and keys must never be written directly into source code, because anyone who sees the code can see the secrets. Cloud Code includes a Secret Manager view where you can create, view, update, and use secrets, so that sensitive values do not need to be stored in your codebase.

Cloud APIs library

Google Cloud offers hundreds of services, each reachable through an API. Cloud Code includes an API library browser. You can browse the available Cloud APIs, enable services in your project, install client libraries, and read guidance on how to integrate them into your application.

Other services

Google’s documentation lists additional integrations in some editors. In IntelliJ, it describes browsing Compute Engine virtual machines, connecting through a terminal, and transferring files, plus running the Cloud SQL Auth proxy, viewing instances, and creating data sources. The overview page also lists support for Apigee API development, Cloud Build, Cloud Storage, and App Engine. Availability differs by editor.

Gemini Code Assist adds AI help to the editor; it is a related but separate product.

Google’s pages say that Cloud Code integrates with Gemini Code Assist Standard and Enterprise to help you solve code problems, generate code for your project, and receive inline suggestions. The pages also stress that Gemini Code Assist is a separate plugin and is not enabled by default. To use it you must connect to Google Cloud, select a project, and enable the required permissions.

flowchart TD
  ED["Your editor"] --> CCP["Cloud Code plugin: build, run, debug, deploy"]
  ED --> GCA["Gemini Code Assist plugin: AI suggestions and chat"]
  CCP --> GC["Google Cloud resources"]
  GCA --> GC
        

How to use AI suggestions wisely

The Cloud Shell Editor is the quickest way to try Cloud Code.

Cloud Shell is a free, browser-based command line environment from Google Cloud that comes with common tools preinstalled. Its Editor is a full code editor in the same browser tab, and Cloud Code is included. You open it from the Google Cloud console and start working immediately, with your credentials already in place.

Cloud Code is for the inner loop; other tools handle the outer loop.

Software teams talk about two loops. The inner loop is what a single developer does many times a day: write, run, test, debug. The outer loop is what the team does to ship: review, build, test automatically, release, and monitor. Cloud Code lives in the inner loop. Cloud Build, Artifact Registry, Cloud Deploy, and monitoring tools live in the outer loop.

flowchart LR
  subgraph Inner["Inner loop: Cloud Code"]
    A["Write"] --> B["Run"] --> C["Debug"] --> A
  end
  C --> D["Commit to repository"]
  subgraph Outer["Outer loop: team pipeline"]
    D --> E["Automated build and test"]
    E --> F["Release"]
    F --> G["Monitor"]
  end
        

Because Cloud Code acts as you, your account’s permissions define what it can do.

When you sign in, Cloud Code uses your Google identity to call Google Cloud services. That means it can do anything your account is allowed to do in the selected project. This is convenient, but it also means a careless action in the editor, such as deleting a cluster, has real effects.

The plugin itself is not where the costs come from; the resources you use are.

Google’s overview pages describe the features of Cloud Code but do not include a price for the plugin. In practice, charges come from the Google Cloud resources you create and use through it: GKE clusters, Cloud Run requests and compute time, storage, builds, and any paid add-on products. Gemini Code Assist has its own plans, described on Google’s Gemini pricing page, and is separate from Cloud Code. Confirm the current terms on the official pages before budgeting.

Habits that keep bills small

Most beginner problems fall into a few familiar groups.

Common problems and first checks

Anti-patterns

Every tool has strengths and limits; knowing both helps you choose well.

Related tools

flowchart TD
  Q["What do you need?"] --> A{"Build apps for GKE or Cloud Run?"}
  A -->|"Yes"| B{"Want integrated editor workflow?"}
  B -->|"Yes"| CC["Use Cloud Code"]
  B -->|"No, prefer terminal"| CLI["Use CLI tools with Skaffold"]
  A -->|"No"| C{"Release to production for a team?"}
  C -->|"Yes"| PIPE["Use Cloud Build and Cloud Deploy"]
  C -->|"No, just inspect"| CON["Use the Cloud console"]
        

Here is how different people typically use Cloud Code day to day.

Follow these habits and most beginner trouble disappears.

Quick answers to questions beginners ask most.

It is a set of plugins for VS Code, JetBrains IDEs, and Cloud Shell that supports creating, running, debugging, and deploying Kubernetes and Cloud Run applications from inside your editor.

No. Cloud Shell is a browser-based command line environment, and its Editor is one of the three places Cloud Code can be used. Cloud Code is the plugin set; Cloud Shell is one of its homes.

Not in depth. Samples and helpful tools let you start quickly, but learning the basic ideas of containers, clusters, and manifests will help you a great deal.

Some local features, such as the Cloud Run emulator, run on your computer. To deploy to Google Cloud, use cloud services, or sign in to the Cloud Shell Editor, you need an account and a project.

It is a built-in local imitation of Cloud Run that lets you develop and debug a service on your own machine before deploying.

Cloud Code uses Skaffold for Kubernetes workflows and helps you edit its configuration file. You mostly interact with it through the editor.

Through a Secret Manager view where you can create, view, update, and use secrets, so sensitive values need not live in your codebase.

They work together but are separate plugins. Google’s pages say Gemini Code Assist is not enabled by default and has its own plans, and they note that individual tiers stopped serving requests on 18 June 2026.

The feature pages I reviewed give no price for the plugin itself. Costs come from the cloud resources you use, such as clusters and Cloud Run. Verify on Google’s official pages.

Google’s IntelliJ page mentions limited support for Android Studio. Check the supported IDEs page for current details.

Generally no. Use the editor for development, and release to production through a reviewed, automated pipeline.

Cloud Code brings Google Cloud into the editor you already use. It supports VS Code, JetBrains IDEs, and the browser-based Cloud Shell Editor, and covers the full development cycle for Kubernetes and Cloud Run applications. Starting from run-ready samples, it helps you write configuration with intelligent YAML support, build images, run on GKE clusters or in a local Cloud Run emulator, debug, and deploy, while Skaffold automates the loop behind the scenes. It also offers Secret Manager, a Cloud APIs browser, and integrations that vary by editor, and it sits beside Gemini Code Assist, which is a separate and changing product. Used with local testing, separate environments, careful permissions, and a proper release pipeline, it makes cloud development calmer and faster.