Skip to content
Back to search

gem-team

MarketplaceWorks with Claude CodeGitHub

Turn AI coding into an engineering process.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mubaidr/gem-team with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mubaidr/gem-team'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mubaidr--gem-team/badge.svg)](/listings/mubaidr--gem-team)

HTML

<a href="/listings/mubaidr--gem-team"><img src="/api/listings/mubaidr--gem-team/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Install [APM](https://microsoft.github.io/apm/) first:

# macOS / Linux
curl -sSL https://aka.ms/apm-unix | sh

# Windows PowerShell
irm https://aka.ms/apm-windows | iex

# Verify
apm --version

Install Gem Team into your current project:

apm install mubaidr/gem-team --target copilot,claude,cursor,opencode,codex,gemini,windsurf

Or install for one target only:

apm install mubaidr/gem-team --target copilot

Install globally for personal use:

apm install -g mubaidr/gem-team

APM records the resolved commit in `apm.lock.yaml`. Repeating `apm install` replays that lockfile; it does not silently upgrade an existing installation. Refresh Gem Team explicitly when desired:

# Project-scoped installation
apm update mubaidr/gem-team --yes

# Global installation
apm update -g mubaidr/gem-team --yes

To check for an update to the APM CLI itself, use `apm self-update --check`.

For reproducible environments, pin a release tag:

apm install 'mubaidr/gem-team#gem-team-v<version>' --target copilot

Replace `<version>` with a published version from the [GitHub Releases](https://github.com/mubaidr/gem-team/releases) page.

After the first install, commit the generated APM files that belong to your repo, especially `apm.yml`, `apm.lock.yaml`, and the generated harness directories such as `.github/`, `.claude/`, `.cursor/`, `.opencode/`, `.codex/`, `.gemini/`, or `.windsurf/`. Do **not** commit `apm_modules/`.

> APM can auto-detect targets from existing harness directories, but explicit `--target` is recommended for predictable installs and fresh repositories. > > Direct Git installs use the canonical sources in `.apm/`. Maintainers do not > need to commit `build/`; release archives and checksums are generated and > attached automatically to each GitHub Release.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 30 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "gem-team",
  3. "owner": {
  4. "name": "mubaidr",
  5. "email": "mubaidr@gmail.com",
  6. "url": "https://github.com/mubaidr"
  7. },
  8. "metadata": {
  9. "homepage": "https://github.com/mubaidr/gem-team"
  10. },
  11. "plugins": [
  12. {
  13. "name": "gem-team",
  14. "description": "Self-Learning Multi-agent orchestration harness for spec-driven development and automated verification",
  15. "tags": [
  16. "multi-agent",
  17. "orchestration",
  18. "tdd",
  19. "testing",
  20. "e2e",
  21. "devops",
  22. "security-audit",
  23. "code-review",
  24. "prd",
  25. "mobile"
  26. ],
  27. "source": "./"
  28. }
  29. ]
  30. }
README.md · README · 244 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Gem Team
  2. **Turn AI coding into an engineering process.**
  3. > Agent definitions that enforce good software engineering: optimizing cost, time, and quality.
  4. <p align="center">
  5. <a href="https://mubaidr.github.io/gem-team/"><b>Visit Homepage</b></a>
  6. </p>
  7. <br/>
  8. <p align="center">
  9. <img src="https://img.shields.io/badge/APM-mubaidr/gem--team-blue?style=flat-square" alt="APM package: mubaidr/gem-team">
  10. <img src="https://img.shields.io/github/v/release/mubaidr/gem-team?style=flat-square&color=important" alt="Latest release">
  11. <img src="https://img.shields.io/badge/license-Apache%202.0-green?style=flat-square" alt="Apache-2.0 license">
  12. <img src="https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square" alt="Pull requests welcome">
  13. </p>
  14. ## Real-world performance
  15. > Sub-$0.001 per API call on 100K+ token contexts. 82.8M+ tokens processed across 666 agent runs, with typical responses completing in 2-5 seconds. Prompt caching turns large contexts into sub-penny operations - a 10x cost reduction vs. uncached input.
  16. _Observed during Gem-Team development using DeepSeek V4.1 Flash via CommandCode._
  17. ## The Problem
  18. 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.
  19. ## The Solution
  20. 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.
  21. ## Why Gem Team?
  22. - **Quality by Default**: TDD and acceptance checks always apply; reviews and security audits run when risk requires them. No more "vibe coding" that breaks in production.
  23. - **Smart & Efficient**: 40-60% less context per task through scoped handoffs and proportional architecture. Cached tokens and compact evidence paths keep costs predictable and your AI focused.
  24. - **Works With Your Tools**: Seamless integration with Copilot, Claude, Cursor, Codex, Gemini, and Windsurf. Use your preferred environment.
  25. - **Learns & Improves**: Remembers what works and extracts reusable skills. Your AI gets smarter and more efficient over time.
  26. - **Resumable Plans**: Every MEDIUM/HIGH task gets a persistent plan ID. Pause, resume, or extend work without losing context or re-discovering what you already know.
  27. - **Works With Any Model**: Hardened output contracts and relational invariant fallbacks mean every agent works across commercial and open models - not just the ones that memorized your schema.
  28. ### Intelligent Model Routing
  29. Gem Team automatically uses the right model for each kind of work:
  30. - **Premium models** handle planning, debugging, and review where deeper reasoning matters.
  31. - **Explore models** handle research, implementation, testing, documentation, and other bounded tasks efficiently.
  32. - **Configurable tiers** let you choose the models and providers that fit your budget and workflow.
  33. This gives you stronger verification where it matters without paying the highest model cost for every task. Configure it once in `.gem-team.yaml`:
  34. ```yaml
  35. model_routing:
  36. enabled: true
  37. tiers:
  38. premium: "your-strong-model (provider)"
  39. explore: "your-fast-model (provider)"
  40. ```
  41. **TL;DR:** Gem Team turns AI coding into a structured, repeatable engineering process with built-in quality, efficiency, and learning.
  42. ## Quick Start
  43. Install [APM](https://microsoft.github.io/apm/) first:
  44. ```bash
  45. # macOS / Linux
  46. curl -sSL https://aka.ms/apm-unix | sh
  47. # Windows PowerShell
  48. irm https://aka.ms/apm-windows | iex
  49. # Verify
  50. apm --version
  51. ```
  52. Install Gem Team into your current project:
  53. ```bash
  54. apm install mubaidr/gem-team --target copilot,claude,cursor,opencode,codex,gemini,windsurf
  55. ```
  56. Or install for one target only:
  57. ```bash
  58. apm install mubaidr/gem-team --target copilot
  59. ```
  60. Install globally for personal use:
  61. ```bash
  62. apm install -g mubaidr/gem-team
  63. ```
  64. APM records the resolved commit in `apm.lock.yaml`. Repeating `apm install`
  65. replays that lockfile; it does not silently upgrade an existing installation.
  66. Refresh Gem Team explicitly when desired:
  67. ```bash
  68. # Project-scoped installation
  69. apm update mubaidr/gem-team --yes
  70. # Global installation
  71. apm update -g mubaidr/gem-team --yes
  72. ```
  73. To check for an update to the APM CLI itself, use `apm self-update --check`.
  74. For reproducible environments, pin a release tag:
  75. ```bash
  76. apm install 'mubaidr/gem-team#gem-team-v<version>' --target copilot
  77. ```
  78. Replace `<version>` with a published version from the
  79. [GitHub Releases](https://github.com/mubaidr/gem-team/releases) page.
  80. After the first install, commit the generated APM files that belong to your repo, especially `apm.yml`, `apm.lock.yaml`, and the generated harness directories such as `.github/`, `.claude/`, `.cursor/`, `.opencode/`, `.codex/`, `.gemini/`, or `.windsurf/`. Do **not** commit `apm_modules/`.
  81. > APM can auto-detect targets from existing harness directories, but explicit `--target` is recommended for predictable installs and fresh repositories.
  82. >
  83. > Direct Git installs use the canonical sources in `.apm/`. Maintainers do not
  84. > need to commit `build/`; release archives and checksums are generated and
  85. > attached automatically to each GitHub Release.
  86. ## The Process
  87. Gem Team uses a structured workflow to turn AI coding into a reliable engineering process:
  88. 1. **Route**: Classify the request from supplied evidence and select only the workflow depth it needs.
  89. 2. **Plan**: Use an in-memory wave plan for TRIVIAL/LOW work or a persistent, planner-confirmed wave plan for MEDIUM/HIGH work.
  90. 3. **Build**: Execute every wave plan through the same ordered-wave loop, using TDD and specialist agents.
  91. 4. **Verify**: Check every task and run reviewer integration checks only when changed-scope risk requires them.
  92. 5. **Learn**: Promote only stable, high-confidence patterns after successful execution.
  93. ## Features
  94. - **Risk-Based Quality Gates**: TDD and deterministic verification always apply; specialist reviews and audits run when the plan or changed scope requires them.
  95. - **Effortless Context**: Progressive context management prevents bloat. Scoped handoffs, context-coalesced tasks, verbatim cluster `shared_context`, a cache-lifetime payload order, and evidence-by-reference keep each agent's token footprint minimal while maximizing cached token reuse across waves.
  96. - **Smart Routing**: Tasks are automatically routed to the right agents based on complexity.
  97. - **Parallel Execution**: Independent tasks run in parallel within waves; overlapping ownership is serialized to prevent conflicts.
  98. - **Resumable Plans**: Every MEDIUM/HIGH task gets a persistent plan ID and `plan.yaml`. Pause, resume, or extend work without losing context.
  99. - **Reusable Knowledge**: High-confidence patterns and skills are extracted and reused for future tasks.
  100. - **Cost Efficiency**: Model routing, output hygiene, and compact handoffs ensure you only use the tokens you need. Evidence travels by reference, not by copy - keeping context usage low and cache hits high across waves.
  101. - **Failure Classification**: Every failure is classified (retry, fixable, replan, flaky, regression, platform-specific, test-bug) so the Orchestrator routes it to the right agent instead of blindly retrying.
  102. - **Verification Boundary**: The Orchestrator never re-verifies or second-guesses specialist output. Verification is owned exclusively by the specialist responsible for the work.
  103. - **Quality Directives**: Every agent follows specific rules that prevent common AI coding issues: no dead buttons, no buzzwords, no template filler, and every decision has a reason.
  104. ## How it Works
  105. 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.
  106. - **Specialist Agents**: Dedicated agents for planning, research, implementation, review, and more.
  107. - **Orchestration**: One wave loop coordinates ordered work, parallel tasks, bounded retries, and final acceptance checks at every complexity level.
  108. - **Context Management**: Execution agents receive an authoritative `task_definition` with a nested `handoff`; constraints, evidence, and prior-wave outputs travel through it. Planner receives a bounded `planning_context`; reviewer uses a dedicated review `handoff`; every delegate receives only a role-scoped configuration snapshot.
  109. ### Agent Roles
  110. | Role | Description |
  111. | :------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  112. | **Orchestrator** | Classifies intent, routes work, tracks state, and enforces verification gates. Never re-verifies specialist output. |
  113. | **Planner** | Creates bounded wave plans with YAGNI/KISS scope reduction and concern-separated slices: milestones, routing, handoffs, risks, and criteria. |
  114. | **Implementer** | Implements features, fixes, and refactors with TDD. Covers happy paths, boundaries, errors, and state transitions. Applies SOLID, fail-fast, and least-surprise. Every major decision has a one-line reason. No dead buttons. |
  115. | **Reviewer** | Independent reviews for quality, security, and compliance. Read-only critic mode for decisions. Verifies every decision has a reason. Flags dead buttons and external script patches as blocking issues. |
  116. | **Debugger** | Root-cause analysis, stack traces, regression bisection. Adds a reproduction test; never implements fixes. |
  117. | **Researcher** | Codebase exploration in five budgeted modes: scan, question, audit, trace, deep. |
  118. | **Browser Tester** | E2E browser tests with visual, accessibility, performance, network, and regression checks. |
  119. | **Mobile Tester** | Mobile E2E on iOS/Android with Detox, Maestro, Appium, or e2e. |
  120. | **DevOps** | Infrastructure, CI/CD, containers, health checks, rollback, and production approvals. |
  121. | **Documentation** | Technical docs, READMEs, API references, diagrams, and walkthroughs. No buzzwords. Every section exists because the product needs it. No fabricated statistics. |
  122. | **Code Simplifier** | Removes dead code, reduces complexity, consolidates duplicates, and improves naming. Every refactoring has a one-line reason. No buzzwords. Removes AI-slop comments. |
  123. | **Skill Creator** | Extracts high-confidence patterns into reusable `SKILL.md` files and assets. |
  124. ## Compatible Tools
  125. Gem Team works with your favorite AI coding tools:
  126. | Tool | Harness | Description |
  127. | :----------- | :------------------ | :----------------------------------- |
  128. | **Copilot** | `.github/agents/` | VS Code Copilot / GitHub Copilot CLI |
  129. | **Claude** | `.claude/agents/` | Claude Code |
  130. | **Cursor** | `.cursor/agents/` | Cursor |
  131. | **OpenCode** | `.opencode/agents/` | OpenCode |
  132. | **Codex** | `.codex/agents/` | Codex CLI |
  133. | **Gemini** | `GEMINI.md` | Gemini CLI |
  134. | **Windsurf** | `.windsurf/rules/` | Windsurf / Cascade |
  135. ## Configuration
  136. 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.
  137. ### Reviewer and critic modes
  138. `gem-reviewer` uses three independent axes:
  139. - `review_mode`: `standard`, `high`, or `critic` controls review intensity.
  140. - `review_target`: `plan`, `task`, `code`, `decision`, `docs`, `config`, or `integration` selects what is reviewed.
  141. - `review_scope`: `changed`, `affected`, or `full` limits the evidence breadth.
  142. TRIVIAL/LOW work does not invoke the planner or reviewer during planning.
  143. MEDIUM/HIGH work receives one pre-execution plan review: standard for MEDIUM,
  144. high for HIGH or high-risk work, and critic for architecture, breaking-change,
  145. or cross-domain signals. Later integration review is risk-triggered, not a
  146. routine wave gate.
  147. Discussion is answered directly. A requested evaluation or decision becomes a
  148. read-only challenge with `review_mode: critic`, `review_target: decision`, and
  149. `review_scope: full`. Critic mode does not mutate files or claim implementation.
  150. Its subject and context are passed through `handoff`:
  151. ```yaml
  152. review_mode: critic
  153. review_target: decision
  154. review_scope: full
  155. handoff:
  156. critic_subject:
  157. objective: str
  158. proposal: str
  159. constraints:
  160. - str
  161. alternatives:
  162. - str
  163. evidence:
  164. - str
  165. decision_needed: str
  166. critic_context:
  167. audience: str
  168. time_horizon: str
  169. success_criteria:
  170. - str
  171. known_unknowns:
  172. - str
  173. ```
  174. ## Learn More
  175. - [Documentation](https://mubaidr.github.io/gem-team/)
  176. - [Contributing](https://mubaidr.github.io/gem-team/5.resources/2.contributing.html)
  177. - [License](LICENSE)
  178. ## Support
  179. If you have questions or need help, please open an issue on [GitHub](https://github.com/mubaidr/gem-team/issues).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.