Awesome/awesome-copilot
1
0
Fork 0
mirror of https://github.com/github/awesome-copilot.git synced 2026-08-03 07:52:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: publish from main

Browse Source
This commit is contained in:
github-actions[bot]
2026-07-23 17:56:34 +00:00
parent 67b97ccdb7
commit 38eb0a34b0
76 changed files with 10104 additions and 732 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/external.json
+17 -16
View File
@@ -337,9 +337,9 @@
}
},
{
"name": "foundry-agent-canvas",
"description": "Interactive Copilot canvas for designing, configuring, testing, and deploying Microsoft Foundry hosted agents.",
"version": "1.0.2",
"name": "microsoft-foundry",
"description": "Skills and interactive Copilot canvas for designing, configuring, testing and deploying agents to Microsoft Foundry.",
"version": "1.0.3",
"author": {
"name": "Microsoft",
"url": "https://www.microsoft.com"
@@ -359,8 +359,8 @@
"source": {
"source": "github",
"repo": "microsoft/foundry-toolkit",
"path": "foundry-agent-canvas",
"sha": "4f2d5fe02f6d89cac43e1a06de39c127cb53a55d"
"path": "microsoft-foundry",
"sha": "9e5fae9942514a8b90281886285052a99fc1932b"
}
},
{
@@ -655,7 +655,7 @@
{
"name": "ui5",
"description": "SAPUI5 / OpenUI5 plugin for GitHub CoPilot. Create and validate UI5 projects, access API documentation, run UI5 linter, get development guidelines and best practices for UI5 development.",
"version": "0.1.4",
"version": "0.1.7",
"author": {
"name": "SAP SE",
"url": "https://www.sap.com"
@@ -676,13 +676,13 @@
"source": "github",
"repo": "UI5/plugins-coding-agents",
"path": "plugins/ui5",
"sha": "80f2d93287054f9d30dd990e842e15bcfca581c9"
"ref": "v0.1.7"
}
},
{
"name": "ui5-modernization",
"description": "Complete UI5 modernization toolkit with workflow and specialized fix patterns for modernizing SAPUI5/OpenUI5 applications",
"version": "0.1.6",
"version": "0.1.7",
"author": {
"name": "SAP SE",
"url": "https://www.sap.com"
@@ -702,13 +702,13 @@
"source": "github",
"repo": "UI5/plugins-coding-agents",
"path": "plugins/ui5-modernization",
"ref": "v0.1.6"
"ref": "v0.1.7"
}
},
{
"name": "ui5-typescript-conversion",
"description": "SAPUI5 / OpenUI5 plugin for GitHub CoPilot. Convert JavaScript based UI5 projects to TypeScript.",
"version": "0.1.4",
"version": "0.1.7",
"author": {
"name": "SAP SE",
"url": "https://www.sap.com"
@@ -730,19 +730,18 @@
"source": "github",
"repo": "UI5/plugins-coding-agents",
"path": "plugins/ui5-typescript-conversion",
"sha": "80f2d93287054f9d30dd990e842e15bcfca581c9"
"ref": "v0.1.7"
}
},
{
"name": "upgrade-agent",
"description": "GitHub Copilot upgrade is an AI-powered agent that helps you upgrade applications to newer versions of languages, frameworks, and runtimes. It assesses your application, creates an upgrade plan, applies code changes, and validates the results through an interactive upgrade workflow.",
"version": "1.1.222",
"description": "AI-powered upgrade assistant for upgrading and migrating applications. Helps modernize legacy code and upgrade .NET applications to current frameworks.",
"version": "1.1.247",
"author": {
"name": "Microsoft",
"url": "https://www.microsoft.com"
},
"repository": "https://github.com/microsoft/upgrade-agent-plugins",
"license": "MIT",
"homepage": "https://github.com/microsoft/upgrade-agent-plugins",
"keywords": [
"modernization",
"upgrade",
@@ -750,11 +749,13 @@
"dotnet",
"canvas"
],
"license": "MIT",
"repository": "https://github.com/microsoft/upgrade-agent-plugins",
"source": {
"source": "github",
"repo": "microsoft/upgrade-agent-plugins",
"path": "plugins/upgrade-agent",
"sha": "379d344e42823b25223f878c002f38fb3a2c1d2b"
"sha": "a70e1ae1ff63dd19ff874e874b4b587a5291f68a"
}
},
{
plugins/gem-team/.github/plugin/plugin.json
Vendored
+2 -2
View File
@@ -21,5 +21,5 @@
"license": "Apache-2.0",
"name": "gem-team",
"repository": "https://github.com/mubaidr/gem-team",
"version": "1.84.0"
}
"version": "1.87.0"
}
plugins/gem-team/README.md
+67 -443
View File
@@ -1,5 +1,15 @@
# Gem Team
**Turn AI coding into an engineering process.**
> Agent definitions that enforce good software engineering: optimizing cost, time, and quality.
<p align="center">
<a href="https://mubaidr.github.io/gem-team/"><b>Visit Homepage</b></a>
</p>
<br/>
<p align="center">
<img src="https://img.shields.io/badge/APM-mubaidr/gem--team-blue?style=flat-square" alt="APM package: mubaidr/gem-team">
<img src="https://img.shields.io/github/v/release/mubaidr/gem-team?style=flat-square&color=important" alt="Latest release">
@@ -7,21 +17,22 @@
<img src="https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square" alt="Pull requests welcome">
</p>
Turn AI coding into an orchestrated loop: plan, build, review, debug, learn - with smarter tool calling and leaner context.
## The Problem
> Spec-driven multi-agent orchestration for software development, verification, debugging, reusable knowledge, and context-bloat-free execution.
Current AI coding is often one-off and ad-hoc. You get code, but you don't get a repeatable process. This leads to inconsistent quality, wasted tokens, and a lack of long-term learning.
**TL;DR:** Gem Team installs 16 specialist agents that turn AI coding into an engineering process. Plan, implement, review with structured waves, dependency resolution, integration gates, and progressive context management - all while avoiding context bloat, saving tokens via output hygiene and discovery depth scaling, and improving tool-calling precision through model routing and targeted context snapshots. Works with Copilot, Claude Code, Cursor, OpenCode, Codex, Gemini CLI, and Windsurf.
## The Solution
Gem Team wraps your AI with a disciplined engineering delivery system. It enforces good software engineering practices automatically, so you get better results with less effort.
## Why Gem Team?
Gem Team wraps your AI with a disciplined engineering delivery system: plan, build, review, debug, learn. The [Features](#features) section below covers every capability in detail. Here's the gist:
- **Quality by Default**: TDD, code reviews, and security audits happen automatically. No more "vibe coding" that breaks in production.
- **Smart & Efficient**: Optimized for fewer tokens and lower costs. Progressive context management prevents bloat and keeps your AI focused.
- **Works With Your Tools**: Seamless integration with Copilot, Claude, Cursor, Codex, Gemini, and Windsurf. Use your preferred environment.
- **Learns & Improves**: Remembers what works and extracts reusable skills. Your AI gets smarter and more efficient over time.
- **Better delivery flow**: spec-driven execution, wave-based parallelism, verification gates, resumable plans.
- **Better code quality**: 16 specialist agents, TDD by default, diagnose-then-fix, security and accessibility audits.
- **Better context management**: progressive context envelope, three-tier memory, skill extraction, PRD management - context bloat avoidance built in.
- **Better cost control**: model routing, output hygiene, context pruning, discovery depth scaling - fewer tokens, same results.
- **Better tool calling**: targeted context snapshots per agent, output hygiene rules - precision without prompt waste.
**TL;DR:** Gem Team turns AI coding into a structured, repeatable engineering process with built-in quality, efficiency, and learning.
## Quick Start
@@ -54,453 +65,66 @@ After the first install, commit the generated APM files that belong to your repo
> APM can auto-detect targets from existing harness directories, but explicit `--target` is recommended for predictable installs and fresh repositories.
## Contents
## The Process
- [Why Gem Team?](#why-gem-team)
- [Features](#features)
- [Comparison](#comparison)
- [Core Concepts](#core-concepts)
- [Workflow](#workflow)
- [The Agent Team](#the-agent-team)
- [Installation](#installation)
- [Compatible Tools](#compatible-tools)
- [Configuration](#configuration)
- [Operational Notes](#operational-notes)
- [Contributing](#contributing)
- [License](#license)
- [Support](#support)
Gem Team uses a structured workflow to turn AI coding into a reliable engineering process:
1. **Plan**: Analyze the task, break it down, and create a structured plan with verification gates.
2. **Build**: Implement features using TDD, following best practices and design patterns.
3. **Review**: Automated code reviews, security audits, and accessibility checks at every step.
4. **Learn**: Extract reusable skills and patterns from successful tasks to improve future performance.
## Features
### Intelligent Workflow Engine
- **Phase-based predictable pipeline**: Init → Route → Plan → Execute → Output.
- **Complexity-adaptive routing**: TRIVIAL tasks get one-shot delegation. LOW gets in-memory planning. MEDIUM/HIGH get durable plans, validation gates, and DAG-based wave execution.
- **Integration gates**: Reviewer checks wave output before proceeding. MEDIUM gates on risk; HIGH gates every wave.
- **Resumable plans**: Plan IDs, file-based artifacts, and context envelopes make long tasks pause, inspect, and continue cleanly.
### Specialist Agent Team
- **16 focused agents**: Planner, Researcher, Implementer, Implementer-Mobile, Reviewer, Critic, Debugger, Browser Tester, Mobile Tester, Devops, Documentation Writer, Designer, Designer-Mobile, Code Simplifier, Skill Creator: plus the Orchestrator who coordinates them all.
- **TDD by default**: Implementers follow Red-Green-Refactor with 6-category test coverage (happy path, invariants, boundaries, error paths, input variation, state transitions). Bug-fix mode requires debugger diagnosis before touching code.
- **Diagnose-then-fix**: Debugger diagnoses → Implementer fixes → Reviewer re-verifies. Enforced at planner, orchestrator, implementer, and reviewer levels.
### Context & Knowledge Management
- **Context envelope**: Progressive cache shared across all agents. Tech stack, conventions, constraints, architecture snapshot, research digest, prior decisions: enriched after each wave.
- **Three-tier memory**: Repo (workspace-scoped), session (conversation-scoped), global (user-scoped). Confidence-gated persistence (≥0.85).
- **Stable cache**: High-confidence facts (≥0.90, stable, ≥3 uses) promoted to durable cache. Auto-eviction after 90 days unused.
- **Reuse notes**: Trusted file paths and patterns that agents skip re-verifying.
- **Skill extraction**: High-confidence workflows become reusable `SKILL.md` playbooks via gem-skill-creator.
- **PRD management**: Structured product requirements with EARS syntax, acceptance criteria, decisions, and change history.
### Quality & Verification
- **Plan validation**: Reviewer checks plan correctness, temporal paradoxes, wave ordering, and contract integrity.
- **Critic review**: Challenges assumptions, finds edge cases, flags over-engineering: for HIGH complexity and architecture-impacting changes.
- **Per-wave integration checks**: Reviewer verifies contracts, conflicts, and integration points after each wave.
- **Security audits**: OWASP scanning, secrets/PII detection, mobile 8-vector scan (keychain, cert pinning, deep links, biometric auth, network security).
- **Accessibility audits**: WCAG 2.1 AA contrast checks, ARIA labels, focus indicators, touch targets, reduced-motion support.
- **Visual regression**: Screenshot comparison with configurable thresholds.
- **Configurable audit depth**: `none`, `basic`, or `full` a11y scanning.
### 🔧 Testing
- **E2E browser testing**: Flow-based scenarios with setup, assertions, visual evidence, console/network capture.
- **Mobile E2E testing**: iOS + Android with Detox, Maestro, Appium. Gesture testing, lifecycle testing, push notifications, device farm support.
- **Performance testing**: Cold start TTI, memory profiling, frame rate analysis, bundle size tracking.
- **Platform-specific testing**: Safe areas, keyboard behaviors, system permissions, dark mode, haptics, back button, battery optimization.
### Design
- **UI/UX design system creation**: Palettes, typography scales, spacing, shadows, design movements (brutalism, glassmorphism, minimalism, neo-brutalism, claymorphism, retro-futurism, maximalism).
- **Mobile platform design**: iOS HIG, Android Material 3, safe areas, dynamic island, touch targets (44pt/48dp), platform-select pattern.
- **Accessibility-first**: Contrast 4.5:1, touch targets, reduced-motion, semantic HTML/ARIA.
- **Design output**: 9-section `DESIGN.md` with tokens, component specs, responsive behavior, agent prompt guide.
### DevOps & Deployment
- **Infrastructure provisioning**: Docker, Kubernetes, cloud (AWS/GCP/Azure).
- **CI/CD pipeline management**: PR → staging → smoke → production flows.
- **Approval gates**: Configurable per-environment approval requirements.
- **Health checks**: Endpoint verification, resource monitoring, rollback strategies (rolling, blue-green, canary).
- **Mobile deployment**: EAS Build/Update, Fastlane, TestFlight, Google Play phased rollouts.
- **Idempotent operations**: All ops designed to be safe to re-run.
### Cost Control
- **Model routing**: Cheap models for routine work (implementer, docs). Strong models for planning, debugging, review, critique.
- **Output hygiene**: Agents limited to native tool flags, pipe truncation, maxResults on searches.
- **Context reuse**: Envelope filtered per-agent (only relevant sections).
- **Budget controls**: Researcher has `max_searches`, `max_files_to_read`, `max_depth` per task.
### Learning & Reuse
- **Persist high-confidence learnings**: Facts, patterns, gotchas, failure modes, decisions ≥0.95 confidence automatically persisted.
- **Batch delegation**: Product decisions → PRD. Technical decisions → AGENTS.md/architecture docs. Patterns → memory/envelope. Workflows → skills.
- **Git checkpointing**: Optional wave-level commits on integration gate pass for clean audit trail and rollback diagnosis.
## Comparison
gem-team is not trying to replace Copilot, Cursor, Claude Code, Cline, or Roo Code.
It focuses on the missing workflow layer:
- planning
- subagent delegation first policy for parallel work
- context envelope for avoiding repeated source reads
- reviewer/debugger loops
- specialist agents
- repeatable execution artifacts
Use gem-team when you want AI coding to follow an engineering process instead of a single chat prompt.
Vibe with confident, structured delivery and durable knowledge instead of ad-hoc one-off outputs.
## Core Concepts
### System-IQ multiplier
Gem Team wraps your chosen model with a disciplined delivery system: task classification, planning, delegation, verification, debugging, and learning. The goal is to improve the reliability of agentic software work without depending on a single long prompt.
### Knowledge layers
| Layer | Location | Purpose |
| :----------------- | :------------------------------- | :------------------------------------------------------------------------- |
| **PRD** | `docs/PRD.yaml` | Product requirements and approved decisions. |
| **AGENTS.md** | `AGENTS.md` | Stable project conventions, rules, and agent instructions. |
| **Plan artifacts** | `docs/plan/{plan_id}/` | Per-task plans, context envelopes, task registries, evidence, and results. |
| **Memory** | Memory tool / configured backend | Durable facts, decisions, gotchas, patterns, and failure modes. |
| **Skills** | `docs/skills/` | Reusable procedures extracted from successful repeated workflows. |
| **Derived docs** | `docs/knowledge/` | Reference notes, external docs, summaries, and research outputs. |
## Workflow
### Architecture Flow
### Execution Model
Gem Team adapts workflow depth to task complexity:
- **TRIVIAL:** direct execution with a tiny checklist.
- **LOW:** lightweight in-memory planning and execution.
- **MEDIUM/HIGH:** durable planning, context envelope, validation, wave execution, and integration review.
The system batches independent work, serializes only true dependencies, and persists high-confidence learnings for future runs.
```text
User Input
↓
Phase 0: Init & Clarify
• Read provided context
• Load config and relevant memory
• Detect intent and plan state
• Classify complexity
• Ask only for blocking clarification
↓
Phase 1: Route
• Continue existing plan
• Revise existing plan
• Start new task
↓
Phase 2: Plan
• TRIVIAL → tiny checklist
• LOW → lightweight in-memory plan
• MEDIUM/HIGH → durable planner-generated plan
• Analyze requirements for inconsistencies (MEDIUM/HIGH)
• Validate higher-risk plans before execution
↓
Phase 3: Execute
• Prepare context based on complexity
• Run unblocked work in waves
• Delegate tasks to suitable agents
• Respect dependencies and conflicts
• Review/integrate higher-risk waves
↓
Learn & Persist
• Save reusable decisions, patterns, gotchas, and skills
• Update memory, docs, PRD, AGENTS.md, or skills as appropriate
↓
Loop / Replan
• Continue next wave
• Replan if scope changes
• Escalate if blocked
↓
Phase 4: Output
• Present final status using configured output format
```
## The Agent Team
### Recommended model routing
Use a fast cost-efficient model as the default and reserve stronger reasoning models for tasks that need deeper analysis.
| Role | Example model | Recommended use |
| :-------------------------------------- | :------------------------------ | :--------------------------------------------------------------------------------------------- |
| **Default agents** | `mimoi-2.5/deepseek-v4-flash` | Routine implementation, documentation, research summaries, and simple checks. |
| **Planner, Debugger, Critic, Reviewer** | `mimoi-2.5-pro/deepseek-v4-pro` | Planning, root-cause analysis, compliance checks, critical review, and high-risk verification. |
Replace these with equivalent models from your own provider if needed.
### Core agents
| Agent | Description |
| :--------------- | :---------------------------------------------------------------------------------------------------------------------------------------------- |
| **ORCHESTRATOR** | Coordinates the workflow, delegates work, tracks plans, and enforces verification gates. Runs Phase 0–4 pipeline. Never executes work directly. |
| **RESEARCHER** | Explores codebase patterns, dependencies, architecture, and docs. Supports 5 modes (scan, deep, audit, trace, question) with budget controls. |
| **PLANNER** | Creates DAG-based execution plans with task decomposition, wave scheduling, dependency mapping, risk analysis, and acceptance criteria. |
| **IMPLEMENTER** | Implements features, fixes, and refactors using TDD (Red-Green-Refactor). Bug-fix mode requires debugger diagnosis. Surgical edits only. |
### Quality and review
| Agent | Description |
| :------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **REVIEWER** | Reviews implementation quality, security, maintainability, contracts, and test coverage. Plan validation (lightweight/full). Wave integration checks. OWASP + secrets + mobile 8-vector security scan. Accessibility audit (none/basic/full). |
| **CRITIC** | Reviews PRD requirements for inconsistencies & ambiguities. Challenges assumptions, finds edge cases, flags over-engineering or missed constraints. Evaluates decomposition, dependencies, complexity, coupling, and future-proofing. Offers alternatives. |
| **DEBUGGER** | Root-cause analysis, stack trace diagnosis, regression bisection, error reproduction. Asks for clarification when input insufficient. Prove-It pattern (reproduction test first). Never implements fixes. |
| **BROWSER TESTER** | E2E browser checks, UI flow validation, visual regression (screenshot comparison), console/network capture, a11y audit. Configurable thresholds. |
| **CODE SIMPLIFIER** | Removes dead code, reduces cyclomatic complexity, consolidates duplicates, improves naming. Preserves behavior: runs tests after each change. Chesterton's Fence principle. |
### Specialized agents
| Agent | Description |
| :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **DEVOPS** | Infrastructure deployment, CI/CD pipelines, container management (Docker/K8s). Approval gates for prod. Health checks, rollback (rolling/blue-green/canary). Mobile deployment (EAS, Fastlane, TestFlight/Play Store). |
| **DOCUMENTATION** | Technical docs, READMEs, API docs, diagrams, walkthroughs. PRD authoring and maintenance. Context envelope updates. AGENTS.md management. Coverage matrices. |
| **DESIGNER** | UI/UX layouts, themes, color schemes, design systems. Create/validate modes. Design movements (brutalism, glassmorphism, minimalism, etc.). 9-section `DESIGN.md` output. WCAG 2.1 AA. |
| **IMPLEMENTER-MOBILE** | Mobile TDD for React Native, Expo, Flutter. Platform-specific code with Platform.select. SafeAreaView, FlatList, Reanimated. Bug-fix mode. |
| **DESIGNER-MOBILE** | Mobile UI/UX for iOS (HIG) and Android (Material 3). Safe areas, touch targets (44pt/48dp), dynamic island, platform-specific specs. |
| **MOBILE TESTER** | Mobile E2E with Detox, Maestro, Appium. iOS + Android. Gesture, lifecycle, push notification, device farm testing. Performance (cold start, memory, frame rate). |
| **SKILL CREATOR** | Extracts reusable `SKILL.md` files from high-confidence (≥0.95, ≥2 uses) patterns. Creates scripts, references, and cross-linked assets. |
## Installation
### 1. Install APM
```bash
# macOS / Linux
curl -sSL https://aka.ms/apm-unix | sh
# Windows PowerShell
irm https://aka.ms/apm-windows | iex
# Verify
apm --version
```
### 2. Install Gem Team
Project-scoped install, recommended for teams:
```bash
apm install mubaidr/gem-team --target copilot,claude,cursor,opencode,codex,gemini,windsurf
```
Global user-scoped install, useful for personal use:
```bash
apm install -g mubaidr/gem-team
```
Pin a release for reproducible installs:
```bash
apm install mubaidr/gem-team#v1.20.0 --target copilot
```
### 3. Verify the install
```bash
apm list
apm view mubaidr/gem-team
apm audit
```
Tool-specific checks:
```bash
copilot plugin list # GitHub Copilot CLI, if used
/plugin list # Claude Code, inside Claude Code
```
### Useful APM flags
```bash
# Preview without writing files
apm install mubaidr/gem-team --target copilot --dry-run
# Install only selected targets
apm install mubaidr/gem-team --target claude,cursor
# Install all supported harness targets
apm install mubaidr/gem-team --target all
# Exclude one target from auto-detection
apm install mubaidr/gem-team --exclude codex
# Reinstall from the existing apm.yml manifest
apm install
```
- **Automated Quality Gates**: TDD, code reviews, and security/accessibility audits happen automatically.
- **Effortless Context**: Progressive context management prevents bloat and keeps your AI focused.
- **Smart Routing**: Tasks are automatically routed to the right agents based on complexity.
- **Reusable Knowledge**: High-confidence patterns and skills are extracted and reused for future tasks.
- **Cost Efficiency**: Model routing and output hygiene ensure you only use the tokens you need.
## How it Works
Gem Team installs a set of specialized agents that work together under the guidance of an Orchestrator. This team follows a disciplined workflow that includes planning, implementation, verification, and learning.
- **Specialist Agents**: Dedicated agents for planning, research, implementation, review, and more.
- **Orchestration**: An Orchestrator coordinates the team, ensuring tasks are completed in the right order and verified at every step.
- **Context Management**: A shared context envelope ensures every agent has the information it needs without redundant reads or wasted tokens.
### Agent Roles
| Role | Description |
| :--------------- | :---------------------------------------------------------------------- |
| **Orchestrator** | Coordinates the workflow and ensures all tasks are completed correctly. |
| **Planner** | Breaks down complex tasks into manageable steps. |
| **Implementer** | Writes the code using TDD and best practices. |
| **Reviewer** | Verifies code quality, security, and compliance with requirements. |
| **Debugger** | Diagnoses and fixes bugs with root-cause analysis. |
| **Researcher** | Explores the codebase and finds the best patterns to use. |
## Compatible Tools
APM writes different files depending on the selected target and the primitives included in the package.
Gem Team works with your favorite AI coding tools:
| APM target | Tool / harness | Typical output |
| :--------- | :----------------------------------- | :------------------------------------------------------------------------------------------------------ |
| `copilot` | VS Code Copilot / GitHub Copilot CLI | `.github/agents/`, `.github/instructions/`, `.github/prompts/`, and VS Code MCP config when applicable. |
| `claude` | Claude Code | `.claude/agents/`, `.claude/rules/`, commands, skills, hooks, and MCP config when applicable. |
| `cursor` | Cursor | `.cursor/agents/`, `.cursor/rules/`, skills, commands, hooks, and MCP config when applicable. |
| `opencode` | OpenCode | `.opencode/agents/`, commands, skills, MCP, and compiled instructions. |
| `codex` | Codex CLI | `.codex/agents/`, `AGENTS.md`, and Codex config when applicable. |
| `gemini` | Gemini CLI | `GEMINI.md`, skills/instructions where supported, and Gemini config when applicable. |
| `windsurf` | Windsurf / Cascade | `.windsurf/rules/`, skills, commands, hooks, and MCP config where supported. |
> Some harnesses do not support every primitive. For example, not every tool has native agents, hooks, or project-scoped MCP. APM compiles or skips unsupported primitives according to the target.
## Marketplace Installation
APM is the recommended installation path. Direct marketplace installs are optional and require this repository to publish the correct marketplace metadata for the target tool.
### GitHub Copilot CLI
```bash
copilot plugin marketplace add mubaidr/gem-team
copilot plugin marketplace browse gem-team
copilot plugin install gem-team@gem-team
```
GitHub Copilot CLI also includes default marketplaces such as `awesome-copilot`; if Gem Team is published there, install it with:
```bash
copilot plugin install gem-team@awesome-copilot
```
### Claude Code
```bash
/plugin marketplace add mubaidr/gem-team
/plugin
/plugin install gem-team@gem-team
/reload-plugins
```
## Local Development
Clone the repository and install it into a test project:
```bash
git clone https://github.com/mubaidr/gem-team.git
cd gem-team
apm install . --target claude,cursor --dry-run
```
Then run a real install from the local path:
```bash
apm install /absolute/path/to/gem-team --target claude,cursor
```
For package authoring and release validation:
```bash
apm audit
apm compile --target copilot,claude,cursor --validate
apm pack
```
| Tool | Harness | Description |
| :----------- | :------------------ | :----------------------------------- |
| **Copilot** | `.github/agents/` | VS Code Copilot / GitHub Copilot CLI |
| **Claude** | `.claude/agents/` | Claude Code |
| **Cursor** | `.cursor/agents/` | Cursor |
| **OpenCode** | `.opencode/agents/` | OpenCode |
| **Codex** | `.codex/agents/` | Codex CLI |
| **Gemini** | `GEMINI.md` | Gemini CLI |
| **Windsurf** | `.windsurf/rules/` | Windsurf / Cascade |
## Configuration
Gem Team can be configured with `.gem-team.yaml` in your project root.
Gem Team is designed to work out of the box with smart defaults. You can customize behavior by editing the `AGENTS.md` file or specific agent definitions in the `.apm/agents/` directory.
```yaml
orchestrator:
max_concurrent_agents: 2
default_complexity_threshold: auto # auto | TRIVIAL | LOW | MEDIUM | HIGH
git_commit_on_gate_pass: true
## Learn More
planning:
enable_critic_for: [HIGH]
quality:
visual_regression_enabled: true
visual_diff_threshold: 0.95
a11y_audit_level: basic # none | basic | full
devops:
approval_required_for: [production]
auto_rollback_on_failure: false
testing:
screenshot_on_failure: true
```
### Settings reference
#### Orchestrator
| Setting | Type | Default | Description |
| :------------------------------------------ | :----- | :------ | :----------------------------------------------------------------------- |
| `orchestrator.max_concurrent_agents` | number | `2` | Maximum parallel agent executions. |
| `orchestrator.default_complexity_threshold` | enum | `auto` | Force complexity routing: `auto`, `TRIVIAL`, `LOW`, `MEDIUM`, or `HIGH`. |
| `orchestrator.git_commit_on_gate_pass` | bool | `true` | Git commit wave output when integration gate passes. |
#### Planning
| Setting | Type | Default | Description |
| :--------------------------- | :----- | :------- | :------------------------------------------------ |
| `planning.enable_critic_for` | enum[] | `[HIGH]` | Complexity levels that require critic validation. |
#### Quality
| Setting | Type | Default | Description |
| :---------------------------------- | :------ | :------ | :----------------------------------------------------- |
| `quality.visual_regression_enabled` | boolean | `true` | Enable screenshot comparison checks. |
| `quality.visual_diff_threshold` | number | `0.95` | Visual comparison threshold from `0.0` to `1.0`. |
| `quality.a11y_audit_level` | enum | `basic` | Accessibility audit depth: `none`, `basic`, or `full`. |
#### DevOps
| Setting | Type | Default | Description |
| :-------------------------------- | :------ | :------------- | :------------------------------------------- |
| `devops.approval_required_for` | enum[] | `[production]` | Environments that require explicit approval. |
| `devops.auto_rollback_on_failure` | boolean | `false` | Attempt rollback after deployment failure. |
#### Testing
| Setting | Type | Default | Description |
| :------------------------------ | :------ | :------ | :---------------------------------------------- |
| `testing.screenshot_on_failure` | boolean | `true` | Capture screenshots when browser/UI tests fail. |
A fully commented default file is available at [`.gem-team.yaml`](.gem-team.yaml).
## Operational Notes
- Prefer project-scoped installs for teams so `apm.yml` and `apm.lock.yaml` make the setup reproducible.
- Keep `apm_modules/` out of git; it is an install cache.
- Pin releases with `#vX.Y.Z` for stable CI and team onboarding.
- Run `apm audit` before release and in CI.
- Review generated files before committing large updates.
- Treat DevOps, production deployment, data migration, and destructive operations as approval-gated tasks.
- Keep project rules in `AGENTS.md`; keep task-specific context in `docs/plan/{plan_id}/`.
## Contributing
Contributions are welcome. Please read [CONTRIBUTING.md](./CONTRIBUTING.md) before opening a pull request.
Recommended contribution flow:
1. Open or pick an issue.
2. Create a focused branch.
3. Keep changes small and reviewable.
4. Add or update tests/docs where relevant.
5. Run validation before opening the PR.
## License
Gem Team is licensed under the [Apache License 2.0](./LICENSE).
- [Documentation](https://mubaidr.github.io/gem-team/)
- [Contributing](https://mubaidr.github.io/gem-team/5.resources/2.contributing.html)
- [License](LICENSE)
## Support
If you encounter a bug or have a feature request, please [open an issue](https://github.com/mubaidr/gem-team/issues).
If you have questions or need help, please open an issue on [GitHub](https://github.com/mubaidr/gem-team/issues).
plugins/uizze/.github/plugin/plugin.json
Vendored
+24
View File
@@ -0,0 +1,24 @@
{
"name": "uizze",
"description": "Stop generic UI from shipping. Ground GitHub Copilot in 800,000+ real web and iOS screens, write a product-specific design contract, and enforce a hard finish gate.",
"version": "1.0.0",
"author": {
"name": "UIZZE",
"url": "https://uizze.com"
},
"homepage": "https://uizze.com",
"repository": "https://github.com/github/awesome-copilot",
"license": "MIT",
"keywords": [
"ui",
"design",
"frontend",
"ios",
"web",
"design-review",
"quality-gate"
],
"skills": [
"./skills/anti-ui-slop"
]
}
plugins/uizze/README.md
+40
View File
@@ -0,0 +1,40 @@
# UIZZE Plugin
Stop generic UI from shipping. UIZZE gives GitHub Copilot a repeatable workflow for turning real interface evidence into a product-specific design contract, then checking the result against a hard finish gate.
## Installation
```bash
copilot plugin install uizze@awesome-copilot
```
## What's Included
| Skill | Description |
|---|---|
| `anti-ui-slop` | Selects relevant interface references, extracts reusable design decisions, writes an implementation-ready design contract, and blocks completion until specificity, interaction states, responsiveness, accessibility, and design-system integrity pass review. |
## How It Works
1. Inspect the target product, task, and existing design system.
2. Search [UIZZE](https://uizze.com) for three to five relevant examples from its public catalogue of 800,000+ real web and iOS screens.
3. Convert the evidence into a design contract before implementation.
4. Run the finish gate and fix every blocking issue before calling the UI complete.
The skill remains usable when catalogue browsing is unavailable: it can work from user-provided references or repository evidence and will state which evidence is missing.
## Requirements and Scope
- No account, credential, token, or external server is required.
- No MCP server is bundled with this plugin.
- The skill is MIT licensed and useful on its own.
UIZZE maintains the public catalogue referenced by the skill.
## Source
This plugin is part of [Awesome Copilot](https://github.com/github/awesome-copilot).
## License
MIT
plugins/uizze/skills/anti-ui-slop/SKILL.md
+109
View File
@@ -0,0 +1,109 @@
---
name: anti-ui-slop
description: 'Stop Codex, GitHub Copilot, Claude Code, and Cursor from shipping generic UI. Use UIZZE’s public catalogue of 800,000+ real web and iOS screens to extract product-specific design decisions and enforce a hard finish gate for web and iOS interfaces.'
---
# Anti UI Slop
Use this skill when building, refactoring, or reviewing a web or iOS interface. The goal is not to make a generic layout prettier. The goal is to make the interface visibly belong to this product, support its real user job, and behave correctly in every important state.
Browse 800,000+ real web and iOS screens at https://uizze.com before choosing a layout.
The workflow is instruction-only. It does not execute third-party code or require credentials.
## 1. Inspect the Product Before Designing
Read the repository and identify:
- the primary user and the job this screen must complete;
- the single primary action and the information needed before taking it;
- the existing component library, design tokens, typography, and layout conventions;
- real product nouns, workflows, constraints, and data already present in the codebase;
- required loading, empty, error, partial, success, disabled, and permission states;
- relevant mobile, tablet, desktop, keyboard, and assistive-technology behavior.
Do not invent product requirements, analytics, user research, or hidden states.
## 2. Collect Real Interface Evidence
Search the public catalogue at https://uizze.com and select three to five relevant web or iOS screens. Prefer references that match the target workflow, information density, navigation model, or interaction pattern—not merely its industry or color palette.
For each reference, record:
1. the screen or flow and its source link;
2. the structural decision worth transferring;
3. why that decision fits this product;
4. what must not be copied.
Transfer hierarchy, workflow shape, density, navigation, control behavior, responsive treatment, and state handling. Never copy another product’s branding, proprietary text, imagery, or exact layout.
If catalogue browsing is unavailable, ask the user for two or three UIZZE links or screenshots. If they cannot provide them, continue from repository evidence and label the missing reference evidence explicitly.
## 3. Write a Design Contract
Before changing code, write a short contract with these fields:
| Field | Decision |
| --- | --- |
| Screen job | The one outcome this screen enables |
| Primary user and action | Who acts, and what they do |
| Content hierarchy | What must be understood first, second, and third |
| Navigation and controls | Product-specific structure and interaction model |
| Visual language | Type, spacing, density, surfaces, imagery, and motion rules |
| Required states | Loading, empty, error, partial, success, disabled, permission |
| Responsive behavior | What changes across supported widths and input modes |
| Evidence used | Reference links and transferable decisions |
| Forbidden defaults | Generic patterns that would erase product specificity |
| Acceptance criteria | Observable conditions required before shipping |
The contract must name concrete choices. “Clean,” “modern,” “intuitive,” and “premium” are not design decisions.
## 4. Build in the Product’s Language
- Reuse the repository’s components and semantic tokens before adding new ones.
- Make the primary action visually and structurally obvious.
- Use product-specific labels and information rather than placeholder metrics or generic copy.
- Keep repeated cards only when the content is genuinely a repeated collection.
- Add decoration, motion, badges, or elevation only when they communicate state or hierarchy.
- Implement every required interaction and state; do not leave convincing-looking inert controls.
- Preserve accessibility semantics, focus order, contrast, touch targets, and reduced-motion behavior.
## 5. Run the Finish Gate
Render the result at every supported breakpoint and block completion when any item fails:
### Product specificity
- Could this interface belong to an unrelated product after changing the logo?
- Does the hierarchy reflect the real user job and product data?
- Are there interchangeable dashboard cards, filler metrics, vague headings, or generic calls to action?
### Interaction completeness
- Do all visible controls have a real outcome?
- Are loading, empty, error, success, disabled, and permission states implemented where applicable?
- Are destructive, irreversible, or sensitive actions confirmed appropriately?
### Responsive and accessible behavior
- Does the layout remain usable without merely stacking every region vertically?
- Do keyboard navigation, focus visibility, semantics, contrast, and touch targets pass inspection?
- Does content remain readable at zoom and with longer real-world text?
### Design-system integrity
- Are local tokens and components used consistently?
- Is every new visual rule justified by the design contract?
- Is borrowed evidence transformed into this product’s own visual language?
Fix every blocking failure and re-run the gate before declaring the UI complete.
## 6. Handoff Format
Report the finished work in this order:
1. **Evidence:** the references and decisions that influenced the result.
2. **Contract:** the final product-specific design rules.
3. **Implementation:** the meaningful interface and behavior changes.
4. **Verification:** breakpoints, interaction states, and accessibility checks performed.
5. **Remaining risks:** anything that could not be verified, without overstating completion.