AutoGineer
Generated banner for Amplitude Experiment Implementation
Generated logo for Amplitude Experiment Implementation

Amplitude Experiment Implementation

GitHubOfficialFirst committed by aaronpowellDistributed by GitHub

  • Custom agent
  • Workflow
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

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.
— the description by aaronpowell

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for AI agents to implement feature experiments within a codebase. By integrating with Amplitude's MCP tools, the agent automates the lifecycle of an experiment, from analyzing requirements in a GitHub issue to implementing the feature code and wrapping it in the appropriate Amplitude experiment variants.

What it does

  • Analyzes feature requirements and instrumentation needs from GitHub issues.
  • Creates new experiments directly in Amplitude using MCP tools.
  • Wraps new feature code in experiment variants following existing application paradigms.
  • Ensures treatment variants are correctly mapped to the new feature implementation.
  • Provides a summary of the implementation and links to the created experiment.

When to use it

  • When you need to implement a new feature that requires A/B testing or gradual rollout.
  • When you want to automate the creation of Amplitude experiments based on documented requirements.
  • When your team uses Amplitude Experiment for feature flagging and needs a consistent implementation process.

Advantages

  • Reduces manual overhead in setting up experiments and feature flags.
  • Ensures consistent implementation of experiment variants across the codebase.
  • Integrates requirement analysis directly with technical implementation.
  • Maintains alignment between feature requirements and experiment configuration.

Usage examples

“Implement the new checkout flow experiment based on issue #123.”
The agent reads issue #123, analyzes the codebase, creates the experiment in Amplitude, and wraps the checkout code in the new experiment variants.

Install

  1. Download the custom agent as a ZIP:

    https://autogineer.com/agent-skills/github/amplitude-experiment-implementation/download

  2. Extract the agent file into .github/agents, then commit it:

    mkdir -p .github/agents && unzip -j amplitude-experiment-implementation.zip 'amplitude-experiment-implementation/amplitude-experiment-implementation.agent.md' -d .github/agents

  3. Keep the LICENSE and ATTRIBUTION.md files from the ZIP with your copy.

Documentation by aaronpowell

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.

Files

Requirements and compatibility

Written for: GitHub Copilot

Works with: GitHub Copilot

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of aaronpowellaaronpowell
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · agents/amplitude-experiment-implementation.agent.md · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
aaronpowell

AutoGineer is not affiliated with or endorsed by aaronpowell or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download amplitude-experiment-implementation.zip