Skip to content
Get packs

Guide · Agent skill

How to use the Genkit Go Developer agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The developing-genkit-go skill teaches an AI coding agent how to build AI-powered applications in Go with Genkit, Google's AI toolkit. This guide is for Go developers who want to add features such as chat, summarization or tool-using assistants to a backend service, and it assumes you have never used an agent skill before. By the end you will know what the skill does, how to install it, how to ask for work that triggers it, and what it needs to run.

Genkit Go Developergoogle/skills · Apache-2.0

Quick start

  1. 1Download and unzip the skill. Download the developing-genkit-go ZIP from our page and unzip it so the folder contains SKILL.md.
  2. 2Place it where your agent looks. Copy the folder to ~/.claude/skills/ for personal use, or to a project's .claude/skills/ folder. In the Claude apps, upload the ZIP under Settings → Capabilities → Skills instead.
  3. 3Install Go, Genkit and the CLI. Make sure a Go toolchain is installed, then install the Genkit CLI with the curl command in this guide and confirm it with genkit --version.
  4. 4Add your model provider credentials. Set up the credentials for the provider you plan to use, such as a Google AI API key or Vertex AI.
  5. 5Ask for the feature in plain language. Describe the Go feature you want, such as a flow or a tool-calling assistant, and mention Genkit.
  6. 6Run the app through the Genkit CLI. Start the app with genkit start -- go run . so traces are captured, or use genkit flow:run for a one-off check.
  7. 7Inspect the traces. Use the Developer UI or the trace output to confirm which tools were called and what the model received and returned.

What is an agent skill and what does this one do?

An agent skill is a folder of instructions and reference files that an AI coding agent loads when a task matches it. Once this skill is installed, the agent knows how to set up Genkit in a Go program, call language models from several providers through one interface, stream responses, call tools, and define flows (server endpoints).

The skill also covers conversational agents: persistent sessions, approval steps, background tasks and multi-agent setups. It explains how to run your app through the Genkit CLI so that AI calls can be traced and inspected. Its scope is the Go SDK only.

  • Set up Genkit with genkit.Init and plugins
  • Generate text and structured output, including streaming
  • Call tools and define flows served over HTTP
  • Build agents with sessions, human-in-the-loop approval and background tasks (experimental API)
  • Run and trace your app with the Genkit CLI

Install the skill from the ZIP download

Download the ZIP for developing-genkit-go from our page, then unzip it. The skill is a folder, so the unzipped folder should contain SKILL.md and a references folder.

For a personal install, place the folder in ~/.claude/skills/. To scope it to one project, place it in that project's .claude/skills/ folder instead. In the Claude apps, you can instead upload the ZIP under Settings → Capabilities → Skills.

  • Personal install: ~/.claude/skills/developing-genkit-go
  • Project install: .claude/skills/developing-genkit-go inside your project
  • Claude apps: Settings → Capabilities → Skills, then upload the ZIP
~/.claude/skills/developing-genkit-go/SKILL.md

Install the Go and Genkit prerequisites

The skill needs a Go toolchain and the Genkit Go libraries (github.com/firebase/genkit/go). Your code imports packages such as github.com/firebase/genkit/go/genkit and github.com/firebase/genkit/go/ai, so the agent will add these to your module.

For the recommended tracing workflow you also need the Genkit CLI. The source gives this install command. Because it pipes a script into bash, read it first if your environment requires that.

  • Go toolchain
  • Genkit Go libraries: github.com/firebase/genkit/go
  • Model provider credentials, such as a Google AI API key or a Vertex AI setup, depending on the provider you use
  • Genkit CLI (recommended for tracing)
  • Optional: PostgreSQL, only if you use the PostgreSQL session store
curl -sL cli.genkit.dev | bash

How do you trigger the skill with a natural request?

You do not need to name the skill. The skill's description says it applies when you ask to build AI features, agents, flows or tools in Go using Genkit, or when you work on Genkit Go code involving generation, prompts, streaming, tool calling or model providers. Describe the goal in plain language and mention Go and Genkit so the match is clear.

Ask for an outcome rather than a file layout. The agent will load the reference that fits the task, such as generation, flows, or agents.

  • "Add a Genkit flow in Go that summarizes a support ticket and returns text."
  • "Give my Go API a tool-calling assistant built with Genkit that can look up order status."
  • "Stream model output from a Genkit Go handler to the client."
  • "Build a multi-turn Genkit agent in Go with saved sessions and a human approval step."

Run and trace your app with the Genkit CLI

Running go run . works, but it skips trace capture, so you cannot see which tools were called or inspect model input and output. The recommended pattern is to put genkit start -- in front of your normal run command. It forwards stdin and stdout, so interactive command-line tools still work.

genkit start keeps running until you press Ctrl+C. That is correct for a server your app calls, but it will not exit on its own. For a quick check that runs one flow and exits, use genkit flow:run, which prints a Trace ID.

  • Default: genkit start -- go run . (starts the Developer UI, usually http://localhost:4000)
  • Without the Developer UI: genkit start --noui -- go run .
  • Open the browser too: genkit start -o -- go run .
  • One-off flow run: genkit flow:run myFlow '{"data": "input"}' -- go run .
  • Check the install: genkit --version
genkit start -- go run .

Use non-interactive mode in scripts and CI

Do not use genkit start as a blocking step in automated or non-interactive contexts. Use flow:run for that. To stop the CLI from waiting on a prompt such as the first-run analytics notice, add the global --non-interactive flag before the --.

The skill also notes that the experimental agent API must be turned on at startup, or its constructors panic.

  • Add --non-interactive before -- so the CLI uses defaults
  • Works with flow:run too
  • Agent API needs genkit.WithExperimental() in genkit.Init
genkit flow:run myFlow '{"data": "input"}' --wait -- go run .

Safety notes before you run the code

The skill's metadata says it does not run scripts, and it does use the network. The generated code will call model providers and needs credentials for them, so keep API keys in environment configuration rather than in source files. The network use is expected: the app talks to whichever provider you configure.

Review the code the agent writes before you deploy it, especially tool implementations, since tools can take actions on your behalf. The skill's agent features are marked experimental, and the source says their API may change.

  • Runs scripts: no
  • Uses network: yes (calls to model providers)
  • Keep provider credentials out of source control
  • Treat experimental agent APIs as subject to change

What people use it for

  • Adding a summarization or chat endpoint to a Go backend, served through genkit.Handler
  • Building a tool-using assistant that calls your own Go functions
  • Creating a multi-turn support agent with saved sessions and human approval before actions
  • Running a background research task that the user checks later, using the agent API's background execution
  • Debugging model calls during development by reading Genkit traces instead of guessing

Frequently asked questions

Is the Genkit Go Developer skill free?

The skill is published under the Apache-2.0 licence. The source does not state pricing for Genkit or for model providers, so check those separately, since providers require their own credentials.

What do I need to use the developing-genkit-go skill?

You need a Go toolchain, the Genkit Go libraries (github.com/firebase/genkit/go), and credentials for a model provider such as a Google AI API key or Vertex AI. The Genkit CLI is recommended for tracing, and PostgreSQL is optional for the PostgreSQL session store.

Where do I put the skill folder?

Put it in ~/.claude/skills/ for a personal install, or in .claude/skills/ inside a project to limit it to that project. In the Claude apps, upload the ZIP under Settings → Capabilities → Skills.

Why does my genkit start command never finish?

That is expected. genkit start runs until you press Ctrl+C, including with --noui. For a command that runs once and exits, use genkit flow:run, and add --non-interactive when running in scripts or CI.

Does this skill work with JavaScript, Python or Dart?

No. The skill covers only the Go SDK. Use a Genkit skill for another language if you need one.

Should I use this for a simple one-off model call?

Probably not. The skill steers conversational work toward its experimental agent API, and for a single stateless generation a plain model SDK or a plain flow is enough.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you build AI features in Go with Genkit and want your agent to follow the framework's patterns for flows, tools, streaming and tracing. Skip it if you work in another language, need a simple one-off model call, or must ship a production agent system on a stable API, since the agent features are experimental.

Download the skill