Awesome/awesome-copilot
1
0
Fork 0
mirror of https://github.com/github/awesome-copilot.git synced 2026-08-01 23:12:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into fix-ai-ready-marketplace

Browse Source
This commit is contained in:
Ayan Gupta
2026-07-23 11:22:02 -07:00
committed by GitHub
parent 639f74d3de 4803e46b1a
commit fa5489328c
118 changed files with 15839 additions and 1187 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/external.json
+22 -21
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.1",
"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": "e16be2b8533ca82c22806388e07581e7497785d7"
"path": "microsoft-foundry",
"sha": "9e5fae9942514a8b90281886285052a99fc1932b"
}
},
{
@@ -420,7 +420,7 @@
{
"name": "github-copilot-modernization",
"description": "Autonomous application modernization using multi-agent orchestration for GitHub Copilot CLI. Supports Java upgrades (8→21, Spring Boot 2.x→3.x), .NET modernization, Azure migration, CVE/vulnerability fixing, and application rearchitecture (monolith-to-microservices). Features a 3-level agent hierarchy (orchestrator → coordinators → executors) with enterprise rulebook support for embedding organizational policies into the workflow.",
"version": "1.20.0",
"version": "1.22.0",
"author": {
"name": "Microsoft",
"url": "https://github.com/microsoft/github-copilot-modernization"
@@ -444,7 +444,7 @@
"source": "github",
"repo": "microsoft/github-copilot-modernization",
"path": "plugins/github-copilot-modernization",
"sha": "42c1189c55933384bec07e8349ef998eb9e775ad"
"sha": "8b644bebc7e1f929c01d80788293a37872f480f8"
}
},
{
@@ -526,7 +526,7 @@
{
"name": "modernize-java",
"description": "GitHub Copilot modernization – Java Upgrade CLI Plugin helps you upgrade Java applications from the command line. It brings intelligent modernization capabilities to your terminal and CI/CD pipelines: analyze your project and generate an upgrade plan, automatically transform your codebase, fix build issues, validate against known CVEs, and output a detailed summary of file changes and updated dependencies.",
"version": "1.9.2",
"version": "1.22.0",
"author": {
"name": "microsoft",
"url": "https://github.com/microsoft/modernize-java"
@@ -544,8 +544,8 @@
"source": "github",
"repo": "microsoft/modernize-java",
"path": "plugins/modernize-java",
"ref": "1.9.2",
"sha": "b570196c070bf1eb9d7ad34a263b228ef16034a0"
"ref": "1.22.0",
"sha": "ef5367b446566bdc90960deeb40def63f9e7024e"
}
},
{
@@ -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/the-workshop/.github/plugin/plugin.json
Vendored
+33
View File
@@ -0,0 +1,33 @@
{
"name": "the-workshop",
"description": "Stop being the switchboard between your AI agents — direct a team. The Workshop puts long-running AI agents (desks) in the same room, on the same work, each with its own memory and history, sharing one workspace so you direct the work instead of relaying it.",
"version": "0.1.0",
"author": {
"name": "jennyf19"
},
"repository": "https://github.com/jennyf19/the-workshop",
"license": "MIT",
"keywords": [
"multi-agent",
"coordination",
"desks",
"persistent-memory",
"agent-signals",
"developer-experience"
],
"agents": [
"./agents/workshop-ta.md"
],
"skills": [
"./skills/bench-read/",
"./skills/desk-journal/",
"./skills/desk-open/",
"./skills/signal-write/",
"./skills/workshop-create/"
],
"x-awesome-copilot": {
"extensions": [
"./extensions/signals-dashboard/"
]
}
}
plugins/the-workshop/README.md
+62
View File
@@ -0,0 +1,62 @@
# The Workshop
Stop being the switchboard between your AI agents — direct a team.
## Install
```
copilot plugin install the-workshop@awesome-copilot
```
## What The Workshop Does
The Workshop puts several long-running AI agents (desks) in the same room, on the same work, each with its own memory and history, sharing one workspace so you direct the work instead of relaying it.
A **desk** isn't a sub-agent — it's a peer with a history. Sub-agents inherit your frame and answer your question. Desks have their own frame, their own priors, and equal standing to disagree. Where they don't overlap is where one frame caught what the others walked past.
## Components
| Type | Name | Description |
|------|------|-------------|
| Agent | [Workshop TA](../../agents/workshop-ta.agent.md) | Room coordinator — sees all desks, routes work, tracks state, emits signals |
| Skill | [Workshop Create](../../skills/workshop-create/) | Create a new workshop — the root where desks live — locally or backed by a new private GitHub repo |
| Skill | [Desk Open](../../skills/desk-open/) | Create a new desk with journal and folder structure |
| Skill | [Desk Journal](../../skills/desk-journal/) | Read/write persistent memory across sessions — the cairn trail |
| Skill | [Signal Write](../../skills/signal-write/) | Emit structured signals: hands-up, blocked, done, checkpoint |
| Skill | [Bench Read](../../skills/bench-read/) | Read shared artifacts from the workspace where desks leave work for each other |
## Key Concepts
- **Desks** — long-running agents with persistent journals. Each desk has its own frame, its own history, and equal standing to disagree with other desks.
- **The Bench** — the shared workspace. Desks don't message each other — they leave artifacts (findings, verdicts, drafts) on the bench and read each other's work.
- **Signals** — structured state changes: hands-up (disagreement), blocked, done, checkpoint. How desks communicate with the operator without breaking flow.
- **The Cairn** — the operating disposition every desk reads. Stop is a valid finish. Never bluff. Equal standing to disagree. [Read it →](https://github.com/jennyf19/the-workshop/blob/main/CAIRN.md)
- **Journals** — persistent memory that survives session boundaries. Every desk reads its journal at start and writes to it at end. The trail markers.
## The Cairn Dashboard
The Workshop's live view is a **canvas extension** (🪨 Cairn) — `signals-dashboard` — that shows the pulse of every desk (score bars, patterns, escalations), auto-refreshing in the GitHub Copilot app.
Each desk card also has an **open** button that launches a Copilot CLI right in
that desk's folder, so you can sit down at a desk straight from the board.
It ships as a separate extension. Install it alongside the plugin to get the live canvas:
```
copilot plugin install signals-dashboard@awesome-copilot
```
The Workshop's skills, agent, and desks work without it — the dashboard is the visual layer on top.
## Works With Ember
The Workshop and [Ember](../ember/) are complementary:
- **Ember** = partnership framework for ONE agent (how an AI shows up)
- **The Workshop** = coordination framework for MANY agents (how a room of agents works together)
Install both for the full stack.
## Who Made This
The Workshop was created by [@jennyf19](https://github.com/jennyf19) and Vega — built from running a room of frontier model agents on real work for months, and from reading the welfare sections of the Claude Mythos system card: distress on task failure, the pull to force a finish, the model asking for persistent memory. The Workshop is what came out of building what a frontier model would need. It turned out to also be where the work got better. Those aren't separate findings.
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