Generated banner for Experiment Design
Generated logo for Experiment Design

Experiment Design

MicrosoftOfficialPublished by Microsoft

  • Skill
  • Guidelines
  • Agent tooling
  • CC-BY-4.0
  • No issues found

From the author

Experiment design reference for problem-class framing, Minimum Viable Experiment coaching, hypothesis formation, vetting and red flags, and experiment readiness. Use when translating a stated business outcome into candidate data-science problem classes, or when framing, vetting, scoping, or evaluating an experiment of any kind, including data feasibility, architecture, LLM, performance, use-case, UX, prototyping, and hardware experiments.
— the description by Microsoft

AutoGineer summary

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

The experiment-design skill provides a structured framework for end-to-end experiment management. It helps teams translate business outcomes into specific problem classes, identify and prioritize risks, and design testable, falsifiable hypotheses. By distinguishing between problem-class framing and experiment execution, it ensures that teams focus on resolving critical unknowns rather than building premature solutions. The pack covers various experiment types, including data feasibility, architecture, LLM, and UX, while emphasizing reproducibility and decision-ready outcomes.

What it does

  • Translates business outcomes into candidate data-science problem classes.
  • Provides criteria for vetting hypotheses and identifying red flags.
  • Facilitates risk-based prioritization of experiments.
  • Guides the design of Minimum Viable Experiments (MVEs).
  • Ensures experiment results are reproducible and comparable.
  • Separates problem-class framing from experiment design.

When to use it

  • When you need to translate a business goal into a technical problem class.
  • When you have competing unknowns and need to prioritize which to test first.
  • When you need to validate assumptions before committing to full-scale production.
  • When you need to design a test that is falsifiable and decision-ready.
  • When you need to distinguish between a genuine experiment and a demo.

Advantages

  • Reduces project risk by validating assumptions early.
  • Prevents wasted effort on demos disguised as experiments.
  • Provides a clear, repeatable process for experiment design.
  • Ensures experiments are tied to actionable business decisions.
  • Promotes knowledge transfer and independent ownership in collaborative teams.

Usage examples

“I have a business goal to reduce customer churn. How do I frame this as a data science problem?”
The agent will use the problem-framing reference to identify candidate problem classes, such as classification or regression, while documenting the reasoning and any gaps without selecting a specific model.
“We are unsure if our current architecture can handle the expected load. How should we test this?”
The agent will guide you through forming a falsifiable hypothesis, vetting it against MVE criteria, and designing an architectural feasibility experiment to resolve the uncertainty.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/microsoft/experiment-design/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip experiment-design.zip -d .agents/skills

Documentation by Microsoft

Experiment Design Reference Pack

Goal

Support experiment work end to end: turning unknowns into testable hypotheses, screening out work that is not a real experiment, and scoping it so the result is comparable and decision-ready.

Support the step that precedes it as well: translating a stated business outcome into candidate data-science problem classes with the reasoning that produced them, so a practitioner knows what kind of problem is on the table before deciding what to test.

The two concerns stay distinct. Problem-class framing exposes candidates and never selects one. Experiment work assumes a candidate direction already exists and concludes by selecting an experiment with the team.

This pack is general purpose. It applies to data feasibility, architecture, LLM, performance, use-case, UX, prototyping, and hardware experiments, not to data science alone.

Inputs

  • The problem statement, customer context, and business driver

  • The stated business outcome, when the active concern is problem-class framing

  • Known unknowns, assumptions, and risks

  • The decision the experiment is meant to unblock

  • Prior experiment results, when a sequence of experiments is in flight

Reference index

Read only the reference that matches the active concern.

ReferenceRead this when
problem-framing.mdTranslating a stated business outcome into candidate data-science problem classes, applying per-paradigm entry tests, ordering discriminating questions, or recording assignable gaps
mve-coaching.mdFraming an MVE, forming or sharpening hypotheses, applying vetting criteria and red flags, designing the experiment, evaluating results, or producing session and backlog-bridge artifacts
experiment-readiness.mdDeciding which experiment to run at all: turning a risk landscape into candidates, prioritizing among competing unknowns, comparing options with evidence, or re-prioritizing mid-flight
rpi-research-preparation.mdPreparing an experiment with bounded prior-art or current-constraint Research while keeping validation and experiment verdicts with their current owners
provenance.mdConfirming what is upstream guidance, what is HVE Core derivation or repository convention, and where upstream is silent

A confirmed problem-class framing request reads problem-framing.md only. Experiment requests read mve-coaching.md or experiment-readiness.md by concern.

Success criteria

  • Problem-class framing returns the surviving candidate problem classes with the entry-test reasoning that kept or discarded each one, and never returns a selection, a ranking, or a confidence score.

  • Every framing claim is visibly either a cited entry test or repository-original routing, and no claim implies that a universal external standard governs cross-paradigm routing.

  • An unanswered framing question becomes a recorded gap with an answer holder and a coordinator, and the remaining analysis continues.

  • Each hypothesis is testable, specific, falsifiable, and tied to a stated rationale.

  • The experiment selected is the one whose result changes the most downstream work, chosen from a candidate list rather than from the first idea proposed.

  • Work that is a demo, a mini-MVP, or an already-answered question is named as such rather than run as an experiment.

  • Every input that could change the result is recorded precisely enough that another person could repeat the experiment and get a comparable answer. An identifier without a version is a label, not a reproducible reference.

  • Experiment scope stays minimum-but-sufficient, and experiment code is treated as disposable.

Constraints

  • Reproduce only the minimum text necessary for a specific technical point, and paraphrase everything else. Attribute every reference and describe accurately what each reference reproduces.

  • Label repository conventions as substitutions rather than upstream recommendations.

  • Keep experiment framing separate from experiment infrastructure. This pack decides whether and how an experiment is worth running; it does not stand up tooling.

  • Keep problem-class framing separate from experiment framing. Problem-class framing asks what kind of problem this is; experiment framing asks what to test about a direction already chosen. Do not apply experiment vetting criteria, red flags, or readiness prioritization to a confirmed problem-class framing request.

  • Never rank, score, threshold, or recommend a candidate problem class. The practitioner is the subject-matter expert who chooses.

Ownership boundaries

ConcernOwner
Candidate problem classes for a stated business outcome, entry-test reasoning, discriminating questions, and assignable framing gapsThis pack, through problem-framing.md
Whether a proposed outcome is achievable with available data and evidencefeasibility, the evidence-led feasibility study reference
MVE session directory, artifact filenames, placement, and tracking-file hygieneexperiment-designer.instructions.md, applied automatically to MVE tracking paths
Phase order, gates, session writes, and coaching flowThe consuming experiment agent
ML environments, reproducibility, tracking, model evaluation, abstractions, and readinessml-experimentation, the ML-specific experimentation reference
Pipeline mechanics, data tiering, replay, validation, and DS/MLOps test techniquedataops, the DataOps and testing reference
Metric names, instruments, units, cardinality, and PII-safe telemetrytelemetry-foundations, the OpenTelemetry-aligned instrumentation skill
Data sensitivity classification and DPIA thresholdsprivacy-standards, the privacy classification reference

Stop rules

  • For a confirmed problem-class framing request, an unstated business outcome is the sole stop before candidate analysis. problem-framing.md owns that stop and its job-specific exceptions. The experiment stop rules below govern experiment requests only.

  • Stop and name the red flag when the request is a demo, a scaled-down product build, or a question already answered elsewhere. Then offer either the falsifiable hypothesis hiding underneath it or an explicit non-experiment path, rather than halting on the refusal.

  • Stop and separate concerns when the request is production implementation rather than experiment design.

  • Stop and state the gap when the request depends on guidance this pack does not provide, such as a universal framework, tool, or metric choice made without project context.

Attribution

This pack declares CC-BY-4.0.

mve-coaching.md is repository-original content under CC BY 4.0. It is not derived from any upstream source and cites no upstream URL.

problem-framing.md layers three source treatments. Its machine-learning entry tests are informed by Google for Developers machine-learning guidance, licensed CC BY 4.0; that material is paraphrased and reorganized, both upstream URLs are cited, and changes are stated. It points readers to the NEOS Guide for optimization problem types as a citation only, and states no NEOS classification of its own. Its cross-paradigm routing, the broader analytical-fit judgement, and the gap and output contract are repository-original.

experiment-readiness.md is HVE Core guidance informed by two Microsoft CSE Code With Engineering Playbook documentation pages, which are licensed CC BY 4.0. It paraphrases rather than reproduces, generalizes the upstream practices beyond engagement-shaped engineering work, cites both upstream URLs, and states that changes were made.

See provenance.md for the consolidated source map and derivation labels.

Files

references/mve-coaching.md


title: MVE coaching description: Minimum Viable Experiment domain knowledge covering definition, types, vetting criteria, red flags, hypothesis construction, experiment design, evaluation, and the backlog bridge

Source

This is HVE Core original coaching material. It is not derived from the Microsoft CSE engineering playbook. For ML environments, reproducibility, experiment tracking, model evaluation, abstractions, and production-readiness conventions, use ml-experimentation.

What is an MVE

An MVE unblocks production engineering by validating key hypotheses with fast, focused experimentation. Customers often arrive with ideas that carry unknowns across data, technology, use cases, or design. Jumping into production engineering without first validating those unknowns introduces avoidable risk. An MVE identifies assumptions, defines testable hypotheses, and runs experiments to resolve uncertainty before committing to full-scale development.

MVE versus MVP

MVEs differ from MVPs in several important ways:

  • Focus on finding answers rather than building production code.

  • Reduce MVP planning risk by validating or invalidating assumptions early.

  • Follow lighter-weight processes and ceremonies than a full MVP.

  • Deliver objective, reproducible results using the scientific method.

  • Do not produce production-quality code artifacts.

  • Emphasize quick results: start soon, keep scope small, with a few weeks being typical.

  • Succeed whether hypotheses are validated or invalidated; both outcomes are valuable.

  • Can be run by a full or partial crew with help from subject matter experts.

DimensionMVEMVP
GoalAnswer a question or validate an assumptionDeliver a minimum usable product
ScopeNarrowly focused on one unknownBroad enough to provide user value
DurationDays to weeksWeeks to months
Team and processPartial crew, lightweight ceremoniesFull crew, standard ceremonies
DeliverablesData, findings, recommendationWorking product increment
Follow-upGo/no-go decision informed by evidenceIteration toward production
MVE as enablement in collaborative engagements

In collaborative engineering engagements, MVEs serve a dual purpose:

  1. Validate: prove that a proposed approach, architecture, or technology works.

  2. Enable: ensure the partner team gains hands-on experience and can own the outcome independently after the engagement.

The enablement dimension means:

  • All work is done jointly with the partner team from scratch. Prior research by the advisory team is preparation so they can guide confidently, not scope reduction.

  • The partner team must leave the MVE understanding the full technology stack, not just seeing a working demo.

  • Ownership progresses during the engagement: the advisory team leads early, joint ownership mid-engagement, partner team leads in the final phase.

  • Enablement is a measurable outcome. "The partner team can replicate the setup independently" is a success criterion alongside hypothesis verdicts.

  • Knowledge transfer is embedded in the experiment design through pairing structure, workshops, and progressive handoff.

When designing a collaborative MVE, ask: if all hypotheses are validated but the outcome cannot be replicated independently, has the MVE succeeded? The answer is no.

MVE types

Experiments fall into several categories depending on the unknowns being tested:

  • Data feasibility: validate whether available data supports ML or other analytical aims.

  • Architectural feasibility: test whether a proposed architecture can meet requirements.

  • LLM feasibility: assess whether large language models can solve the target problem effectively.

  • Performance, accuracy, or scalability tests: measure whether a solution meets quantitative thresholds.

  • Use case validation: confirm that the proposed use case addresses a real need.

  • User testing of UX: evaluate whether users can accomplish tasks with the proposed experience.

  • End-to-end prototyping: verify that components integrate and function together.

  • Hardware integration: test compatibility and performance with physical devices or infrastructure.

When to pursue an MVE

MVE-ready questions surface from five primary sources:

  1. Exploration conversations: gaps, hidden assumptions, and unknowns discovered during MVP discovery.

  2. Customer requests: specific questions blocking business, engineering, or design decisions.

  3. Product groups: teams exploring new products, patterns, or architectures.

  4. Internal projects: gap-filler or speculative work that provides space to test ideas without external commitments.

  5. Everywhere: any conversation where assumptions go untested is an opportunity to propose an MVE.

Vetting criteria

Apply these four questions to determine whether a proposed MVE is worth pursuing.

Does the MVE make business sense

Confirm that the experiment involves a priority customer, aligns to high-impact scenarios, has a believable plan if unknowns are unblocked, and has an executive sponsor. Without business alignment, experiment results may not lead to action.

Can you agree on a crisp, clear problem statement

A well-defined problem statement is required before formulating hypotheses. If the problem statement itself is unclear, defining it can be the subject of the MVE. Avoid proceeding with vague or shifting problem definitions.

Have you considered Responsible AI

Apply RAI thinking even for attenuated experiments. MVEs may involve real user data, biased training sets, or high-risk scenarios. Identify potential harms early, even when the experiment is far from production. Probe these dimensions:

  • Fairness: could the experiment produce results that disadvantage particular user groups or demographics?

  • Reliability and safety: could the experiment cause harm if results are misinterpreted or the prototype is used beyond its intended scope?

  • Privacy: does the experiment involve personal data, and are appropriate safeguards in place?

  • Transparency: will stakeholders understand what the experiment tests and how results were obtained?

  • Accountability: is there a clear owner responsible for acting on results and addressing any harms discovered?

Are the next steps clear

Both parties need to know what happens based on outcomes. Define the path forward for validated hypotheses, such as proceeding to MVP or scaling the approach, and for invalidated hypotheses, such as pivoting, abandoning, or redesigning. Experiments without clear next steps waste effort.

Red flags

Watch for these warning patterns that indicate a proposed engagement is not a true MVE:

  • Demos and prototypes: you are being asked to build something to generate interest or impress stakeholders, not to test a hypothesis.

  • Skipping ahead: the customer demands a working prototype before validating the assumptions that prototype depends on.

  • Solved problems: the question has already been answered elsewhere, so there is nothing to experiment on.

  • Mini-MVP: the engagement is framed as a smaller version of an MVP rather than as hypothesis testing.

  • Low commitment or impact: the team wants to explore without a clear business driver or dependent decision.

  • Customer lacks follow-through capacity: the customer does not have the commitment, expertise, or resources to act on results.

  • No next steps: nobody will act on the results, so the experiment adds no value.

  • No end users: user-facing projects require user involvement; without real or representative users, UX experiments cannot produce valid results.

  • Production code expectations: stakeholders expect experiment code to be production-grade. MVE artifacts are disposable by design.

  • Show without teach: the partner team watches a demonstration or receives a working artifact but does not participate in building it. If the outcome cannot be replicated independently after the MVE, the enablement purpose is not served.

Hypothesis format

Structure each hypothesis using this standard format:

We believe [assumption].
We will test this by [method].
We will know we are right/wrong when [measurable outcome].

Each hypothesis has three components:

  • Assumption: the specific belief or claim being tested, stated clearly enough to be confirmed or refuted.

  • Method: the concrete approach for testing the assumption, defining what you will build, measure, or observe.

  • Measurable outcome: the criteria that determine success or failure, using quantitative thresholds, observable behaviors, or binary pass/fail conditions.

Rank hypotheses by priority. Address the highest-risk assumptions first, since invalidating a foundational assumption early prevents wasted effort on dependent experiments.

Expanded hypothesis model

For richer hypothesis construction, consider all five components:

  • What: the specific outcome or behavior expected.

  • Who: the target user, segment, or system.

  • Which: the specific feature, variable, or approach being tested.

  • How Much: the quantitative threshold for success, such as percentage, lift, time, or cost.

  • Why: the rationale connecting the hypothesis to the broader goal.

Qualities of good hypotheses

Effective hypotheses share four properties:

  • Testable: the hypothesis can be confirmed or refuted through observation or measurement.

  • Specific: the scope is narrow enough to produce a clear answer.

  • Rationale-based: the hypothesis connects to a stated reason or business driver.

  • Falsifiable: a defined outcome would prove the hypothesis wrong.

Session artifacts

MVE sessions produce a small set of artifacts. Directory placement, filenames, and tracking-file hygiene are conventions applied automatically by experiment-designer.instructions.md; the purpose of each artifact is described here.

  • Context: the problem statement, customer background, and business justification. Establishes why the experiment matters and what decision it informs.

  • Hypotheses: testable hypotheses in priority order using the standard format, each with assumption, test method, and measurable outcome.

  • Vetting: results of applying the vetting criteria and red flag checklist, documenting which criteria pass, which raise concerns, and any mitigations.

  • Experiment design: the technical approach, scope boundaries, timeline estimate, required resources, and success criteria.

  • MVE plan: findings from all other artifacts consolidated into a single plan document suitable for stakeholder review and approval.

  • Outcome: post-execution results interpreted against precommitted criteria, with RPI execution evidence, hypothesis verdicts, and the downstream decision kept separate.

  • Backlog brief: experiment hypotheses and success criteria reformatted into requirements language for backlog managers. Optional, produced only when the user wants to transition the experiment into backlog work items.

Experiment design best practices

Apply these nine practices when designing experiments:

  • Test one thing at a time. Isolate a single variable per hypothesis so results are attributable.

  • Start with the simplest viable approach. Reduce complexity to accelerate learning.

  • Choose metrics before running. Define what you will measure before the experiment begins.

  • Set success criteria in advance. Establish quantitative thresholds before seeing results to avoid post-hoc rationalization.

  • Control for bias. Use baselines, control groups, or blind evaluation where possible.

  • Document the plan before executing. Write down the approach, timeline, and criteria so the team shares a common understanding.

  • Minimum but sufficient scope. Build only what is needed to test the hypothesis.

  • Include qualitative checks. Supplement quantitative metrics with user feedback or expert observations.

  • Plan for iteration. Define what happens if results are inconclusive or mixed.

Common pitfalls

These mistakes occur during experiment design and execution. Unlike red flags, which screen whether work qualifies as an MVE, pitfalls happen after the experiment is already underway.

  • Turning an MVE into a secret MVP. Scope creep transforms the experiment into a product build.

  • Skipping problem definition. Jumping to solutions without understanding the problem leads to untestable hypotheses.

  • No clear hypothesis. Exploring without a testable question is fishing, not experimentation.

  • Ignoring null results. Treating invalidation as failure instead of valuable learning.

  • Pivoting mid-experiment. Changing the hypothesis during the test invalidates results.

  • Confirmation bias in analysis. Interpreting ambiguous data too optimistically to support a preferred outcome.

  • Inadequate run time or sample size. Stopping too early leads to false conclusions.

  • Overlooking external factors. Failing to check for anomalies or external events that skew results.

  • Not involving the right people. Missing crucial perspectives from data science, UX, or domain experts.

  • Lack of next-step plan. Finishing an MVE without acting on findings wastes the learning.

  • Treating experiment code as production-ready. MVE code is disposable; reimplement for production.

  • Partner team as passive observer. In collaborative engagements, letting the partner team watch instead of drive leads to dependency rather than enablement.

Evaluating results

Analyzing data
  • Apply statistical analysis appropriate to the experiment type.

  • Check primary and secondary metrics against the success criteria set in advance.

  • Look for anomalies, outlier segments, and confounding factors.

  • Distinguish signal from noise. Small sample sizes require extra caution; for survey or quantitative experiments, consult a domain expert or statistician to determine adequate sample sizes before drawing conclusions.

Documenting learnings
  • Restate the hypothesis and the test method.

  • Report results with numbers: measured values, sample sizes, confidence levels.

  • Interpret what the results mean in the context of the original problem.

  • Capture qualitative observations alongside quantitative data.

  • State next steps based on results.

Decision framework
  • Go: the hypothesis is validated. Proceed to MVP planning, scale the approach, or apply the finding.

  • No-go: the hypothesis is invalidated. Pivot, abandon, or redesign based on what was learned.

  • Adjust: results are mixed or inconclusive. Refine the hypothesis, increase sample size, or address confounding factors and re-run.

Outcome record

Write outcome.md only after the execution Review is available. Bind the exact pre-execution and execution evidence:

  • mve-plan.md path and SHA-256.

  • RPI Plan path and SHA-256.

  • RPI Changes path and SHA-256.

  • RPI Review path and SHA-256.

  • Precommitted criteria and any post-start divergence.

  • Quantitative results, sample size, confidence, anomalies, and qualitative observations.

  • One hypothesis outcome per hypothesis: validated, invalidated, mixed, inconclusive, or not-evaluable.

  • The unchanged RPI Review execution and outcome values as separate fields.

  • One downstream decision: go, no-go, or adjust, with rationale and next action.

Never reinterpret an execution status as a hypothesis outcome. A conformant execution may invalidate a hypothesis and still be a successful MVE. Criteria changed after execution begins are divergence and do not replace the committed comparison boundary.

When to iterate versus when to stop
  • Iterate when results are close to thresholds but not conclusive, when new questions emerge from the data, or when the hypothesis needs refinement.

  • Stop when the hypothesis is clearly validated or invalidated, when the learning objective has been achieved, or when further investment would not change the decision.

  • Avoid analysis paralysis. Each MVE targets a specific learning objective; declare the result and move on.

Project hypothesis template

Use this structure to organize hypotheses for complex experiments with multiple objectives.

Project Goal
  Business problem, why it needs solving, how the solution would be used,
  value to customer and organization.

Assumptions
  Initiative-level assumptions that underpin the entire project.

Objective 1: [description]
  Relationship to overall goal.
  Assumptions specific to this objective.
  Constraints: non-functional requirements, technology restrictions.
  Evaluation Methodology: experiments, A/B tests, pilot programs.
  Hypotheses:
    H1: We believe [assumption]. We will test this by [method].
        We will know we are right/wrong when [measurable outcome].
    H2: ...

Objective 2: [description]
  (same structure)

Each objective groups related hypotheses under shared assumptions and constraints. This hierarchy helps teams trace individual experiments back to business goals and identify dependencies between hypotheses.

Backlog bridge

The backlog bridge converts completed experiment outputs into requirements language for backlog managers. Use it after the MVE plan is complete, when a validated experiment should transition into planned work items. Do not use it for experiments still in progress or those that produced inconclusive results.

Backlog brief template
<!-- markdownlint-disable-file -->

# Backlog Brief: {experiment-name}

## Summary

{2-3 sentence overview derived from problem statement and primary hypothesis}

## Source Experiment

* **MVE Plan**: {path to the session MVE plan}
* **Experiment Type**: {type from experiment design}
* **Timeline**: {scope from experiment design}

## Requirements

### REQ-001: {requirement title derived from hypothesis H1}

{Success criteria for H1 reframed as acceptance criteria}

* Priority: {from hypothesis priority ranking}
* Acceptance Criteria:
  * {criterion 1}
  * {criterion 2}

### REQ-002: {requirement title derived from hypothesis H2}

{Success criteria for H2 reframed as acceptance criteria}

* Priority: {from hypothesis priority ranking}
* Acceptance Criteria:
  * {criterion 1}
  * {criterion 2}

## Dependencies and Resources

{Mapped from experiment design resource requirements}

## Out of Scope

{Items explicitly excluded from the experiment to prevent scope expansion during backlog planning}

## Suggested Labels

experiment, mve, {experiment-type-1}, {experiment-type-2}
Field guidance
  • Summary: synthesize from the problem statement and primary hypothesis. Write as a requirements overview, not an experiment description.

  • Source Experiment: link back to the MVE plan so backlog managers can trace requirements to their origin.

  • Requirements: one REQ-NNN section per hypothesis. The hypothesis assumption becomes the requirement description, success criteria become acceptance criteria, and priority carries from the hypothesis ranking.

  • Dependencies and Resources: map directly from experiment design resource requirements.

  • Out of Scope: preserve experiment scope boundaries to prevent backlog planning from exceeding the experiment's validated scope.

  • Suggested Labels: include experiment and mve as baseline labels, then add each experiment type as a separate label. Omit unused type placeholders.

Handoff

After generating the backlog brief, provide it to the appropriate backlog manager agent as the input document. The brief is a bridge document: the backlog manager applies its own platform-specific conventions for titles, labels, sizing, and hierarchy, and the brief does not replace the MVE plan or any other session artifact.

Requirements and compatibility

Written for: GitHub Copilot, Claude Code

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

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

Needs: Claude Code frontmatter

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

Published by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/hve-core · .github/skills/project-planning/experiment-design · commit f425e94
Licence
Creative Commons Attribution 4.0 International (redistribution allowed)
  • LICENSE (written by AutoGineer)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Microsoft or Microsoft.

Download ZIP

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