three-medium-extension

Guide provider extensions using Three-Medium Architecture with Python, YAML, and Markdown.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/mowree/next-gen-amp-gitHub-copilot-provider --skill three-medium-extension
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: three-medium-extension
Source: https://github.com/mowree/next-gen-amp-gitHub-copilot-provider/tree/main/.amplifier/skills/three-medium-extension
Command: npx skills add https://github.com/mowree/next-gen-amp-gitHub-copilot-provider --skill three-medium-extension

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a clear, structured methodology for extending existing providers by adhering to the Three-Medium Architecture, ensuring maintainability and clarity.

Core Features & Use Cases

  • Structured Extension: Guides users on how to add new features following a defined process (Contracts first, then Policy, then Mechanism).
  • Best Practices: Highlights anti-patterns to avoid, such as hardcoding policy in code or skipping contract documentation.
  • Use Case: A developer needs to add a new capability to the provider-github-copilot. This Skill outlines the exact steps and principles to follow to integrate the new feature without compromising the provider's architecture.

Quick Start

Follow the outlined steps to add a new feature to the provider, starting with writing the contract.

Frequently Asked Questions about three-medium-extension

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is contract-driven development in provider extension?

Contract-driven development is an approach to provider extension where you write Markdown contracts first, then YAML policy, and finally Python mechanism, ensuring strict separation of concerns and maintainability.

How do I extend a software provider following the Three-Medium Architecture?

To extend a software provider, you follow the Three-Medium Architecture sequence: write Markdown contracts first, define YAML policy second, and implement Python mechanism third, strictly avoiding hardcoded policy in code.

What are the anti-patterns to avoid when adding new features to a software provider?

Common anti-patterns to avoid during provider extension include hardcoding policy directly in Python mechanism code and skipping Markdown contract documentation, both of which compromise architectural separation and maintainability.

Does the Three-Medium Architecture require specific languages for mechanism, policy, and contracts?

Yes, the Three-Medium Architecture requires Python for mechanism, YAML for policy, and Markdown for contracts to enforce a clear separation of concerns and maintainable provider extension development.

When do I need to use the Three-Medium Architecture for my software design?

You need the Three-Medium Architecture when extending existing software providers with new capabilities, providing a structured development methodology that integrates features without compromising the provider's original architecture.