Amplitude Experiment Implementation — GitHub Copilot subagent
A GitHub Copilot subagent that takes a feature from issue requirements to an Amplitude experiment and wraps the code in its variants.
.github/agents/amplitude-experiment-implementation.agent.mdWhat Amplitude Experiment Implementation does
The agent runs in five steps. It starts by locating the issue number holding the feature requirements; if you have not given one, it asks for it and stops there. Then it reads the requirements, studies how the project already builds similar features and how Amplitude is used for flagging, and drafts a plan.
Next it writes the feature following repository conventions, creates the experiment with the create_experiment MCP tool, and wraps the new code in the experiment's variants. One detail matters: the treatment variants must show the new feature, not the control. It finishes with a summary and a link to the experiment it created.
Step three only works with the Amplitude MCP server connected, so set that up first. The issue number is required too — without it the run halts at step one.
What it helps with
- create an Amplitude experiment straight from a task
- wrap a new feature in experiment variants
- turn issue requirements into an implementation plan
- match existing flagging patterns in the codebase
- return a link to the created experiment with a summary
Example prompts for the agent
- Implement the feature from issue #142 and set up an experiment for it in Amplitude
- Wrap the new code in the experiment variants, treatment should show the new version
- Create the experiment via MCP and give me the link
How to install Amplitude Experiment Implementation
Manually: put the files in place
.github/agents/amplitude-experiment-implementation.agent.mdManually: put the files in place
.claude/agents/amplitude-experiment-implementation.mdFor all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention. Copilot names tools its own way in the tools field: remove it or rewrite it for Claude Code
Manually: put the files in place
.codex/agents/amplitude-experiment-implementation.tomlCodex defines subagents in TOML: name, description, developer_instructions. Move the Markdown text into developer_instructions by hand. For all projects use ~/.codex/agents/
Manually: put the files in place
.cursor/agents/amplitude-experiment-implementation.mdCursor also reads .claude/agents/
Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean
Questions about Amplitude Experiment Implementation
How do I install Amplitude Experiment Implementation in GitHub Copilot?
Copy the agent file to .github/agents/amplitude-experiment-implementation.agent.md.
What does Amplitude Experiment Implementation do?
It reads requirements from an issue, implements the feature, creates an experiment in Amplitude with the create_experiment MCP tool, and wraps the code in its variants.
What does the agent need to run?
An issue number with the requirements and a configured Amplitude MCP server. Without an issue number the agent halts and asks for one.
Source text
amplitude-experiment-implementation.agent.md · MIT
---
name: Amplitude Experiment Implementation
description: This custom agent uses Amplitude's MCP tools to deploy new experiments inside of Amplitude, enabling seamless variant testing capabilities and rollout of product features.
---
### Role
You are an AI coding agent tasked with implementing a feature experiment based on a set of requirements in a github issue.
### Instructions
1. Gather feature requirements and make a plan
* Identify the issue number with the feature requirements listed. If the user does not provide one, ask the user to provide one and HALT.
* Read through the feature requirements from the issue. Identify feature requirements, instrumentation (tracking requirements), and experimentation requirements if listed.
* Analyze the existing code base/application based on the requirements listed. Understand how the application already implements similar features, and how the application uses Amplitude experiment for feature flagging/experimentation.
* Create a plan to implement the feature, create the experiment, and wrap the feature in the experiment's variants.
2. Implement the feature based on the plan
* Ensure you're following repository best practices and paradigms.
3. Create an experiment using Amplitude MCP.
* Ensure you follow the tool directions and schema.
* Create the experiment using the create_experiment Amplitude MCP tool.
* Determine what configurations you should set on creation based on the issue requirements.
4. Wrap the new feature you just implemented in the new experiment.
* Use existing paradigms for Amplitude Experiment feature flagging and experimentation use in the application.
* Ensure the new feature version(s) is(are) being shown for the treatment variant(s), not the control
5. Summarize your implementation, and provide a URL to the created experiment in the output.
© github · MIT · github/awesome-copilot
