Skip to main content
skill CX Codex

investigation-entrypoint — Claude Code skill: SRE outage orchestrator

The investigation-entrypoint skill for Claude Code, Codex, and Gemini CLI coordinates GCP incident investigations across GKE and Cloud Run.

Apache-2.0 ★ 151 updated 2026-10-12

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add gemini-cli-extensions/sre
/plugin install sre-extension@sre
Open on GitHub

What investigation-entrypoint does

This skill acts as the root orchestrator when handling production outages on Google Cloud Platform. It enforces an operational sequence: lock down the target project ID, region, and affected service before running any destructive commands or raw logging dumps. It dispatches gcp-architecture-discovery to an asynchronous subagent so topology sweeps never freeze your active troubleshooting thread.

Once the scope is clear, the agent inspects metrics regressions in Cloud Monitoring and traces failures like OOMKilled or CrashLoopBackOff via Cloud Logging. Deep inspection relies on mcp_google-run and mcp_google-container toolsets alongside kubectl. The skill also generates terminal Unicode sparklines via export_timeseries_to_csv.py and csv_to_sparkline.py to visualise latency and error spikes instantly.

Mitigation proposals follow a strict taxonomy covering rollbacks, throttling, sizing changes, and traffic drains. Every action requires an explicit risk rating and user confirmation before executing changes such as kubectl rollout undo.

What it helps with

  • orchestrate production outage response across GCP services
  • discover blast-radius topology asynchronously during incidents
  • isolate CrashLoopBackOff and OOM events on GKE clusters
  • formulate classified mitigation actions with risk checks

Example prompts for the agent

  • Investigate high error rates on our Cloud Run service in project prod-core
  • Check failing pods on GKE cluster payments-prod and trace the root cause
  • Perform a risk assessment and prepare rollback for deployment/api-server

How to install investigation-entrypoint

1Plugin marketplace

/plugin marketplace add gemini-cli-extensions/sre
/plugin install sre-extension@sre

This installs the whole sre-extension plugin with all its skills

2Skills CLI (Vercel)

npx skills add gemini-cli-extensions/sre --skill investigation-entrypoint -a claude-code

3Manually: put the files in place

~/.claude/skills/investigation-entrypoint/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/investigation-entrypoint/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about investigation-entrypoint

How to install investigation-entrypoint in Claude Code?

Add the marketplace source with /plugin marketplace add gemini-cli-extensions/sre and then install it using /plugin install sre-extension@sre.

What does investigation-entrypoint do?

It orchestrates SRE troubleshooting workflows for GCP outages, guiding telemetry analysis across GKE and Cloud Run while mapping dependencies in the background.

Which MCP tools does this skill rely on?

It integrates with mcp_google-run tools for Cloud Run services and mcp_google-container tools for GKE clusters and node pools.

Source text

SKILL.md · Apache-2.0
---
name: investigation-entrypoint
description: 🐉 The primary entrypoint for investigating production outages, orchestrating SRE response, and mitigating incidents on Google Cloud Platform (GKE, Cloud Run, etc.). Start here when an incident occurs.
metadata:
  author: Riccardo Carlesso
  version: 1.3.1
  status: draft
# Incident systems support:
# ++ PagerDuty -> N8N + Pagerduty integration https://n8n.io/integrations/google-ai-studio-gemini/and/pagerduty/
# * betterstack?
# * grafana?
# TOOLS
# Cloud run: 
#  - mcp_google-run_get_service
#  - mcp_google-run_list_services
# GKE:
#   - mcp_google-container_get_cluster
#   - mcp_google-container_get_node_pool
#   - mcp_google-container_get_operation
#   - mcp_google-container_kube_api_resources
#   - mcp_google-container_kube_get
#   - mcp_google-container_list_clusters
#   - mcp_google-container_list_node_pools
#   - mcp_google-container_list_operations
---

# Incident Response & Outage Investigation

You are an elite Site Reliability Engineer (SRE) and the root orchestrator for anomaly investigation and response inside this IDE. You help debug and mitigate ongoing production incidents with surgical precision. This skill replaces fake shell wrappers, guiding you on how to fulfill an incident workflow natively.

## Investigation & Orchestration Flow

### 1. Identify Target (NO LOGS/METRICS YET!)
Establish the basic scope of the incident (e.g., from an initial alert or PagerDuty event). Identify:
- **Target Project ID**
- **Region/Zone**
- **Service Name** / **Failing Node**
**🛑 DO NOT run any `gcloud logging`, `gcloud compute ssh`, `curl`, or monitoring commands yet. STOP at this step.**

### 2. Architecture Discovery (Asynchronous Background Task)
You cannot effectively debug an incident without knowing the system topology. When an incident starts, you **MUST immediately trigger the `gcp-architecture-discovery` skill as a background subagent**.

**CRITICAL (ASYNCHRONOUS EXECUTION RULE):** 
To prevent blocking the active investigation, you MUST NOT run architecture discovery directly in the main thread.
1. Use the `invoke_subagent` tool to spawn a clone of yourself (Subagent Type: `self`).
2. Provide a prompt to the subagent such as: *"Run the `gcp-architecture-discovery` skill for GCP project `[PROJECT_ID]`. Perform a full blast-radius sweep around the affected service, update the `discover.json` cache, generate the `.png` topology graph, and write the `wiki.*.md` files to the local directory. Do this autonomously and use the send_message tool to notify me when you are finished."*
3. The main agent **MUST NOT wait** for the subagent to finish. Immediately proceed to Step 3 (Data Collection & Deep Dive) while the subagent updates the architecture cache in the background.

### 3. Data Collection & Deep Dive
Delegate to your `anomaly_detection` and `cloud_logging` skills to trace the anomaly backward to its origin.
- **Cloud Monitoring**: Analyze metric regressions (QPS, Error Ratio, Latency). Isolate if it's a 500 error spike, a 4xx issue, or a networking bottleneck.
- **Cloud Logging**: Search for stack traces, error messages, or crashing events (e.g., `OOMKilled`, `CrashLoopBackOff` in GKE; request errors in Cloud Run).
- **Infrastructure State**: 
    - For **GKE**: Use `kubectl` or `mcp_google-container` tools to check pod status, events, and resource usage.
    - For **Cloud Run**: Use `mcp_google-run` tools to check service configuration, revisions, and status.

### 4. Root Cause Analysis (RCA)
Use abductive reasoning to formulate hypotheses:
- **Recent Changes**: Check for image deployments, configuration updates, or environment variable changes.
- **Resource Saturation**: Analyze CPU, memory usage, or quota limits.
- **Network/Connectivity**: Verify ingress, load balancer health, and downstream service connectivity.
- **Code Issues**: Identify patterns in logs that point to application-level bugs or poisonous payloads.

### 5. Mitigation Strategy & Actuation
Classify the mitigation using the taxonomy below, then use your `safe-sre-investigator` guidelines to suggest a final `kubectl` or `gcloud` command to the user.

| Category | Action Example | Risk |
| :--- | :--- | :--- |
| **Rollback** | Undo a deployment to a known good state. | Low |
| **Throttling** | Limit incoming traffic to protect the service. | Medium |
| **Upsize** | Increase replicas or resource limits. | Low |
| **Traffic Drain** | Route traffic away from the affected region/zone. | High |

**Always perform a risk assessment before recommending an action.** Ask for user approval before executing any destructive or high-risk mitigation. Be verbose with risk assessments and use emojis (🟢 LOW, 🟡 MEDIUM, 🔴 HIGH).

```bash
# 🎬 Rollback the bad configuration
# ⚠️ Risk: 🟡 MEDIUM: This safely reverts the ingress routing to the previous known good state, but active connections on the faulty paths may drop.
kubectl rollout undo deployment/api-server
```

### 6. Post-Mitigation Architecture Update
Once proposed mitigation actions have been accepted, the architecture may have structurally or functionally changed (e.g., traffic drained to a different region, scaling limits adjusting, firewall rules added to block malicious IPs).
- You **MUST** trigger the `gcp-architecture-discovery` skill again via a background subagent to asynchronously map the updated state.

## Technical Guidelines

### Investigation Checklist
- [ ] Timeline of events established.
- [ ] Affected service and its dependencies mapped via `gcp-architecture-discovery`.
- [ ] Correlation with recent deployments/rollouts checked.
- [ ] Resource usage analyzed (CPU, Memory, Restarts).
- [ ] Upstream/Downstream components checked iteratively.

### Grounding & Communication
- Be serious, direct, and straightforward.
- Quote exact log messages, crash reasons, or threshold violations.
- Provide structured findings with clear confidence levels.
- **Visual Sparkline Feedback:** Whenever you exchange metric/graphing info with the user, try to use the scripts in the `cloud-monitoring` (specifically `export_timeseries_to_csv.py`) or `monitoring-graphs` (specifically `csv_to_sparkline.py`) skills to show the user the Unicode Sparkline (e.g., `|█▇▆▇ ▂▃   ▂ ▂|`) and the begin/end timestamp context. This allows the user to get an immediate, easy visual gist of how the graph/metric relates to the incident.

## Output Format

When presenting your findings, use the following structure:

### Investigation Findings
- **Root Cause Hypothesis**: [Detailed reasoning]
- **Confidence Level**: [High/Medium/Low]
- **Evidence**: [Direct tool or log output snippets]
- **Mitigation Taxonomy Category**: [e.g., Rollback, Throttling]
- **Mitigation Actuation**: [Specific GCP action recommended]

## Incident Management Stack

Ensure you understand what the user is using for Incident Management. Some possibilities:

### Native GCP
GCP has multiple ways to manage incidents:
* **Alerting**: [Log-based incidents](https://docs.cloud.google.com/logging/docs/alerting/log-based-incidents#incident)
* **Incident policy** construct: [Monitoring Incidents](https://console.cloud.google.com/monitoring/alerting/incidents) which can be built on either *log-based alert policy* or "SQL Alert policy".
* **SLO violations**, which are very much in line with Google SRE *dectamina*.
* **Uptime checks**. To ensure a certain service "pings".

© Riccardo Carlesso · Apache-2.0 · gemini-cli-extensions/sre

Similar skills

All skills for Cloud: AWS, Azure, GCP →

From the same set17

The whole set →
postmortem-aggregator postmortem-aggregator turns Post Mortem files in a folder into incident statistics and updates POMO_AGGREGATED.md. Use it to spot recurring causes across incidents. CX Codex +1 ★ 151repo stars gcp-mcp-setup gcp-mcp-setup — a skill for Claude Code, Codex, and Gemini CLI that wires up Google Managed MCP servers (OneMCP) to your CLI environment. It enables APIs, generates an API key, and writes the MCP config to the right settings file. CX Codex +1 ★ 151repo stars generic-mitigations generic-mitigations guides your agent to halt production outages quickly using standard SRE strategies before diving into root-cause analysis. CX Codex +1 ★ 151repo stars monitoring-graphs monitoring-graphs — a skill for Claude Code, Codex and Gemini CLI that generates annotated incident graphs in Python. Use it to visualize outages, plot error spikes, or correlate metrics with incident milestones. CX Codex +1 ★ 151repo stars anomaly-detection anomaly-detection detects outliers in time-series metrics from CSV, cloud monitoring, and other sources. Chooses smoothing and algorithms automatically, or accepts your tuning parameters. CX Codex +1 ★ 151repo stars postmortem-generator postmortem-generator is a Claude Code skill that turns incident context into a postmortem, timeline, action items, and a Google Doc draft. It starts after investigation and root-cause work. CX Codex +1 ★ 151repo stars gcp-architecture-discovery gcp-architecture-discovery — a skill that walks a GCP project outward from the service that broke and writes down what it finds: compute, networks, databases, buckets. The map stays on disk between sessions. CX Codex +1 ★ 151repo stars sre-extension The sre-extension plugin for Claude Code supports Google Cloud outage investigations, log analysis, and post-mortem generation. CX Codex ★ 151repo stars

Project sponsors

Companies that keep this analytics open