# What Tools Are Used for Building and Testing google/skills? Cloud-Native CI, IaC, and Language Runtimes Explained

> Discover the tools powering google/skills including Cloud Build CI, Terraform IaC, and language runtimes like npm Go Maven Docker for seamless building and testing.

- Repository: [Google/skills](https://github.com/google/skills)
- Tags: internals
- Published: 2026-08-16

---

**The google/skills repository relies on Google Cloud Build as its primary CI service, Terraform for infrastructure provisioning, and language-specific tools including npm, Go, Maven, and Docker for building and testing individual skills.**

This article examines the complete toolchain referenced throughout the google/skills repository, a collection of markdown-based guides that teach developers how to build, deploy, and test Google Cloud solutions. Rather than containing application code itself, the repository documents the standardized tooling that practitioners use when implementing these skills in production environments.

## Core Cloud-Native Build and CI Tools

### Google Cloud Build

**Google Cloud Build** serves as the managed CI/CD backbone for skills development. According to the repository's main documentation, Cloud Build handles container builds, test execution, and artifact publishing in a serverless environment. In [`README.md`](https://github.com/google/skills/blob/main/README.md) (lines 69-75), the authors explicitly recommend Cloud Build as the primary service for continuous integration workflows.

A typical Cloud Build configuration for a Node.js-based skill follows this pattern:

```yaml

# cloudbuild.yaml

steps:
  - name: 'gcr.io/cloud-builders/npm'
    args: ['install']
  - name: 'gcr.io/cloud-builders/npm'
    args: ['run', 'build']
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-skill:$_TAG', '.']
images: ['gcr.io/$PROJECT_ID/my-skill:$_TAG']

```

This configuration demonstrates Cloud Build's builder pattern, where each step uses a specialized container image to perform build tasks without requiring local toolchain installation.

### gcloud CLI

The **gcloud CLI** provides operational control across all skill implementations. In [`skills/cloud/google-cloud-recipe-foundation-builder/SKILL.md`](https://github.com/google/skills/blob/main/skills/cloud/google-cloud-recipe-foundation-builder/SKILL.md) (lines 284-300), the documentation shows extensive use of gcloud commands for service enablement and resource management.

Deploy a containerized skill to Cloud Run using standard gcloud workflows:

```bash

# Submit build to Cloud Build

gcloud builds submit \
  --tag gcr.io/$PROJECT_ID/my-skill \
  --project $PROJECT_ID

# Deploy to Cloud Run

gcloud run deploy my-skill \
  --image gcr.io/$PROJECT_ID/my-skill \
  --platform managed \
  --region us-central1

```

### Artifact Registry

**Artifact Registry** stores build outputs including container images, language packages, and Helm charts. The repository documentation groups this with Cloud Build in the core toolchain section, establishing it as the canonical destination for build artifacts produced during skill implementation.

## Infrastructure as Code: Terraform

### Terraform for Google Cloud Resources

**Terraform** provisions the underlying infrastructure that skills require. The spanner-basics skill explicitly documents this in [`skills/cloud/spanner-basics/references/terraform-usage.md`](https://github.com/google/skills/blob/main/skills/cloud/spanner-basics/references/terraform-usage.md) (line 3), stating that developers can "use Terraform to build, change, and version Spanner infrastructure."

Standard Terraform configuration for Google Cloud resources:

```hcl
provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_compute_instance" "default" {
  name         = "example-instance"
  machine_type = "e2-medium"
  
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }
}

```

This declarative approach allows skills to define reproducible infrastructure states, a requirement for production-grade Cloud deployments.

## Language-Specific Build Systems

The google/skills repository supports multiple runtime environments, each with established build tooling.

### Node.js and npm

**npm** manages JavaScript and TypeScript dependencies. The gke-app-onboarding skill ships a concrete [`package.json`](https://github.com/google/skills/blob/main/package.json) in [`skills/cloud/gke-app-onboarding/assets/package.json`](https://github.com/google/skills/blob/main/skills/cloud/gke-app-onboarding/assets/package.json), demonstrating real-world Node package management.

### Go

**Go** appears in multi-stage container builds. The same gke-app-onboarding skill includes Go compilation steps in its Dockerfile instructions, referenced in [`skills/cloud/gke-app-onboarding/SKILL.md`](https://github.com/google/skills/blob/main/skills/cloud/gke-app-onboarding/SKILL.md) (lines 42-44).

Standard Go test execution:

```bash
go test ./...

```

### Python

**Python** with **pip** supports analytics and AI/ML skills. The Google Analytics Data API skill references Python client libraries in [`skills/analytics/google-analytics-data-api-basics/references/python.md`](https://github.com/google/skills/blob/main/skills/analytics/google-analytics-data-api-basics/references/python.md).

Python testing workflow:

```bash
pytest -v

```

### Java and Maven/Gradle

**Maven** and **Gradle** handle Java builds. The Google Cloud Storage skill documents Maven dependency syntax in [`skills/cloud/google-cloud-storage-basics/references/client-library-usage.md`](https://github.com/google/skills/blob/main/skills/cloud/google-cloud-storage-basics/references/client-library-usage.md) (line 69), showing the standard `com.google.cloud:google-cloud-storage` artifact.

Java testing with Maven:

```bash
mvn test

```

## Container and Local Development Tools

### Docker

**Docker** provides consistent build environments and production deployment artifacts. The repository contains multi-stage Dockerfile examples, particularly for Go applications that require compilation before containerization.

### Kaniko

**Kaniko** builds container images within Cloud Build without requiring a Docker daemon. While not extensively documented, it represents an alternative for restricted build environments.

## Testing Frameworks by Language

The repository assumes standard language-specific test runners rather than prescribing custom frameworks:

| Language | Test Command | Typical Framework |
|----------|-----------|-----------------|
| Go | `go test` | Standard library testing |
| Python | `pytest` | pytest |
| Java | `mvn test` / `gradle test` | JUnit |
| Node.js | `npm test` | Jest, Mocha, or built-in |

These conventions align with each language's ecosystem standards, reducing friction for developers already familiar with their chosen runtime.

## CI/CD Orchestration Considerations

While the google/skills repository does not currently contain GitHub Actions workflow files, the README's Cloud Build recommendation implies compatibility with GitHub-based CI through official Google Cloud Build GitHub Actions. This allows teams to trigger Cloud Build pipelines from GitHub repository events.

## Summary

- **Google Cloud Build** is the primary managed CI service for building and testing google/skills implementations, with **Artifact Registry** as the destination for build outputs.

- **Terraform** provisions all infrastructure resources, documented explicitly in the spanner-basics skill.

- **Language-specific tools** include npm for Node.js, Go modules and compiler for Go, pip/pytest for Python, and Maven/Gradle for Java.

- **Docker** containerizes applications, with **gcloud CLI** providing operational control across deployment targets.

- Standard testing conventions apply per language; the repository does not ship custom test suites but guides developers to ecosystem-appropriate tools.

## Frequently Asked Questions

### Does google/skills use GitHub Actions for CI/CD?

No. The repository does not contain GitHub Actions workflow files. The README recommends Google Cloud Build as the primary CI service, though teams can integrate Cloud Build with GitHub through official Google Cloud Build GitHub Actions for repository-triggered pipelines.

### What testing framework does google/skills require?

The repository does not mandate a specific testing framework. Instead, it follows language conventions: `go test` for Go, `pytest` for Python, JUnit via Maven or Gradle for Java, and `npm test` for Node.js. Skills reference these standard tools in their documentation.

### Is Terraform required to use google/skills?

Terraform is not strictly required, but it is the documented and recommended approach for infrastructure provisioning. The spanner-basics skill explicitly describes Terraform usage, and most cloud-focused skills assume IaC practices for reproducible deployments.

### How does google/skills handle container builds?

Container builds primarily use **Docker** with multi-stage build patterns, executed through **Google Cloud Build**. The gke-app-onboarding skill demonstrates this with Go-based examples that compile binaries before final image assembly.