Hands-On: Build a Claude Code Plugin, an OpenAI App, and a Gemini Agent

Three platforms, one mental model

Each ecosystem has a way to extend its agent surface with your own capabilities, and they rhyme. A Claude Code plugin is a git-distributable folder bundling skills, slash commands, sub-agents, hooks and MCP servers. An OpenAI app is an MCP server plus UI metadata that ChatGPT renders inline (and the same server plugs into Codex). A Gemini agent built with ADK is a Python or Java object graph of agents and tools with a local dev UI and a managed deployment target. In all three, MCP is the tool boundary and a markdown instructions file is the knowledge boundary.

Part 1 — A Claude Code plugin

A plugin is the unit of distribution for everything Claude Code can be taught. Skills teach procedure; commands give users a /slash entry point; agents define sub-agents with their own prompt and tool allowlist; hooks run shell commands on lifecycle events (pre/post tool use, session start); .mcp.json attaches tool servers. Only the manifest is required — start with one skill and grow.

Testing loop: run claude --plugin-dir ./my-plugin to load it without installing, invoke the command, iterate. Distribution: add a marketplace.json to any git repo (your plugin repo can be its own marketplace), then teammates run /plugin marketplace add your-org/your-repo and /plugin install release-tools@your-org. Version the plugin in plugin.json and Claude Code handles updates.

release-tools/
├── .claude-plugin/
│   └── plugin.json
├── skills/
│   └── release-notes/
│       └── SKILL.md              # from lesson 2 — unchanged
├── commands/
│   └── ship.md                   # becomes /release-tools:ship
├── agents/
│   └── changelog-reviewer.md     # a sub-agent
├── hooks/
│   └── hooks.json
└── .mcp.json

# .claude-plugin/plugin.json
{
  "name": "release-tools",
  "version": "1.0.0",
  "description": "Release notes, ship checklist and changelog review.",
  "author": { "name": "Your Team" }
}

# commands/ship.md
---
description: Run the ship checklist for the current branch
allowed-tools: Bash(git *), Read
---
Run the release checklist: confirm CI is green for $ARGUMENTS, load the
release-notes skill, draft notes from `git log main..HEAD`, and stop for
approval before tagging.

# agents/changelog-reviewer.md
---
name: changelog-reviewer
description: Reviews draft release notes for missing breaking changes. Use after drafting notes.
tools: Read, Grep
model: haiku
---
You review release notes against the diff. Flag any public API change not
listed under Breaking. Return a checklist, nothing else.

# hooks/hooks.json — block tagging without notes
{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{ "type": "command",
                  "command": "${CLAUDE_PLUGIN_ROOT}/scripts/guard-tag.sh" }]
    }]
  }
}

# .mcp.json — tools the plugin brings with it
{ "mcpServers": { "orders": { "type": "http", "url": "https://mcp.example.com/orders" } } }

# Try it:      claude --plugin-dir ./release-tools
# Distribute:  add .claude-plugin/marketplace.json listing the plugin, push, then
#              /plugin marketplace add your-org/release-tools
#              /plugin install release-tools@your-org

Part 2 — An OpenAI app (and Codex plugin)

The original ChatGPT plugins (OpenAPI manifests, 2023) were retired. Today’s path is the Apps SDK: you build an MCP server, and ChatGPT becomes the client. Tools work as normal MCP tools; the addition is metadata under the openai/* namespace in each tool’s _meta that points at an HTML resource ChatGPT renders inline as a widget — a table of orders, a map, a form. The widget talks back to your server through the same MCP connection.

Development loop: run the server locally, expose it over HTTPS (ngrok or a tunnel), enable developer mode in ChatGPT, add the server as a connector by URL, and chat. Authentication for real users is OAuth 2.1 with dynamic client registration — the MCP standard — so the same server is installable in Codex, Claude and Gemini CLI with no code change. A Codex plugin wraps that server with skills and prompts for the coding harness, exactly as the Claude plugin does.

# The same server is a plain MCP server for Claude — the openai/* metadata
# is simply ignored. Attach it in Claude Code:
#
#   claude mcp add --transport http orders https://your-tunnel.example/mcp
#
# or in a plugin's .mcp.json (Part 1), or via the Messages API mcp_servers
# connector (lesson 5). The widget HTML is not rendered; the model uses the
# structured tool result, which is why the tool must return real data and
# not only a UI.

Part 3 — A Gemini agent with ADK

ADK is Google’s code-first agent framework: an LlmAgent has a model, instructions, tools and optional sub-agents; workflow agents (SequentialAgent, ParallelAgent, LoopAgent) compose them deterministically; a Runner executes an agent against a SessionService that persists state across turns. The killer feature for learning is adk web — a local UI that shows every event, tool call and state change in the loop.

Project layout is a package with an agent.py exporting root_agent. Run adk web from the parent directory and pick your agent. Deployment: adk deploy agent_engine pushes it to Vertex AI Agent Engine, which gives you a managed endpoint, sessions and memory. Expose it to other agents with the A2A card (to_a2a) when another team’s agent needs to call yours.

# pip install claude-agent-sdk
import asyncio
from claude_agent_sdk import (ClaudeSDKClient, ClaudeAgentOptions,
                              tool, create_sdk_mcp_server)

@tool("order_status", "Look up the shipping status of an order by ID (ORD-123456).",
      {"order_id": str})
async def order_status(args):
    status = lookup(args["order_id"])               # your data layer
    return {"content": [{"type": "text", "text": f"{args['order_id']}: {status}"}]}

tools_server = create_sdk_mcp_server("support", tools=[order_status])

options = ClaudeAgentOptions(
    system_prompt="You are a support agent. Use order_status for any order query.",
    mcp_servers={"support": tools_server},
    allowed_tools=["mcp__support__order_status"],
    model="claude-sonnet-4-5",
)

async def main():
    async with ClaudeSDKClient(options=options) as client:   # one session, many turns
        await client.query("Where is ORD-482913?")
        async for m in client.receive_response(): print(m)
        await client.query("And has that order been paid?")  # context carries over
        async for m in client.receive_response(): print(m)

asyncio.run(main())

# Hosting: run this anywhere Python runs, or use Anthropic's Managed Agents
# for a server-hosted sandboxed runtime.

What to build this weekend

Pick one internal procedure your team repeats — release notes, on-call triage, a data-quality check. Write it as a SKILL.md. Wrap the systems it touches in one MCP server. Then package it three ways: a Claude Code plugin, a ChatGPT app / Codex plugin, and an ADK agent with a Gemini CLI extension. You will end with one skill, one server and three thin wrappers — and a very concrete answer to every "have you built agents?" interview question.

• •Day 1: SKILL.md + MCP server with two tools; test in Claude Code with --plugin-dir and in Gemini CLI via settings.json
• •Day 2 morning: plugin manifest + marketplace.json; ChatGPT developer-mode connector with one widget
• •Day 2 afternoon: ADK agent using the same server via MCPToolset; adk web, then adk deploy agent_engine
• •Write down what differed between the three — that list is your interview story