Building with Claude on Google Cloud

Summary of the video (tech + product concepts)

The talk shows an end-to-end demo of using Claude on Google Cloud (via Cloud Code / Cloud Code components) to move through the typical software development lifecycle for an enterprise team. The demo builds and deploys a simple feedback application that collects user scores/comments, updates a dashboard in real time, and then uses AI to produce a feedback summary.

---

1) Enterprise SDLC personas + how Claude/Cloud Code can assist

The workflow is framed around five roles:

• PM: proposes/visualizes product ideas
• UI/UX designer: turns ideas into prototypes/wireframes
• Software engineer: implements application logic and deployment
• Security engineer: runs security review before release
• Data persona (growth marketer / data analyst): analyzes feedback data and provides insights back to PM

---

2) Setting up Claude with Google Cloud in Cloud Code

Key setup methods are discussed, with emphasis on the simplest workflow:

• Use Application Default Credentials (ADC) so Cloud Code can automatically find credentials based on environment.
• A Cloud Code wizard helps:
  • detect your project and region
  • check which models are available
  • “pin” models for use

---

3) Why use Claude via Google Cloud (Cloud models) instead of local/other setups

Main reasons highlighted:

• Pay per token (no message cap)
• Provisioning throughput available for production/enterprise needs
• Easy setup using ADC (less credential/API friction)
• Data stays in your project
• Models are served across multiple regions with global/regional endpoints
• Google Cloud emphasizes strong availability/performance infrastructure

---

End-to-end demo: feedback app built with Cloud Code components

A) PM → prototype from an image (Cloud Code UI + model prompt)

The PM starts from a simple picture/wireframe idea, and Cloud Code renders a prototype UI quickly (to hand off to UX). The message: AI can reduce back-and-forth cycles for the first usable prototype.

B) Transition prototype → production-ish plan (Plan Mode)

The speaker uses Plan Mode, where the model plans before coding.

• Mentions a simulated input from Figma/design doc (via a design doc / MCP concept)
• Cloud Code generates a plan; the developer reviews/accepts it
• Cloud Code then implements the app components accordingly
• Positioned as a way to enforce standards and make iteration safer

C) Software engineer → cloud-native architecture + implementation (MCP server + Skills)

This step focuses on deployment knowledge and includes two newly released capabilities integrated with Cloud Code:

1. Developer Knowledge API + MCP server

   • provides up-to-date Google Cloud documentation
   • via MCP, Cloud Code can propose best architecture/implementation for deployment

2. Google Cloud Skills

   • lets Cloud Code implement individual architecture blocks (not just suggest overall structure)

Concrete architecture for the feedback app:

• Backend/API on Cloud Run (serverless)
• Ingestion/storage of raw responses in Firestore
• Analytics pipeline storing/processing data in BigQuery
• Dashboard consumption via a Looker-style reporting workflow

This combination demonstrates “cloud-native” design without the engineer needing deep prior deployment knowledge.

D) Parallel development using sub-agents

Cloud Code sub-agents are used to parallelize work:

• one agent for API
• one agent for ingestion pipeline
• one agent for the dashboard

Cloud Code also “manages testing” after implementation and produces code ready for deployment.

E) Security review gate before deployment (pre-built security review)

Before release, the demo runs a pre-built security review inside Cloud Code:

• references common checks (e.g., OWASP-style issues)
• mentions service account permissions limiting (least privilege for DB read/write roles)
• in the demo, Cloud Code detects a potential issue, auto-fixes it, then proceeds to deploy

F) Live deployment + real-time feedback updates

The deployed app is shown:

• running on Cloud Run
• users submit scores in real time
• UI updates include:
  • response count
  • score
  • visualizations

A “for fun” feature is also included:

• a feedback analyzer that uses Cloud Code/Cloud on Google Cloud to generate a summary from feedback comments.

---

Data analysis + reporting with MCP servers (BigQuery + Looker)

For the ongoing improvement stage (the “data persona”):

• BigQuery is used as the analytical warehouse for aggregated feedback data
• Looker is the reporting/dashboard layer

Cloud Code + MCP are used again to avoid requiring hand-coded BigQuery/Looker expertise:

• Mentions the Agent platform:
  • an agent registry listing MCP servers supported on Google Cloud
  • includes examples such as:
    • Developer Knowledge MCP server
    • BigQuery MCP server
  • provides setup guidance + observability info
• Mentions an MCP toolbox of DB (open-source) including Looker integration
• Points viewers to a quick start and documentation; code is said to be released after the session.

---

What the speaker claims is delivered (key takeaways)

• Cloud Code components (skills, MCP servers, sub-agents, plan mode) can accelerate the whole dev lifecycle:

  • idea → prototype
  • planned implementation
  • cloud-native deployment
  • security review
  • analytics/dashboard + insight generation

• Code and resources will be released, with quick start and documentation on both Google Cloud and Anthropic sides.

---

Main speakers / sources

• Speaker: Ivan Nardini — Developer Advocate at Google Cloud (working with Anthropic)
• Primary technologies/sources referenced: Anthropic Claude, Google Cloud (Cloud Code, MCP, Skills, sub-agents, Plan Mode), and services Cloud Run, Firestore, BigQuery, Looker (plus OWASP/security-review concepts)