Grassroots AI Skills Marketplace: Scaling AI Capabilities Through Bottom-Up Engineering

uber · Tech · 2026 · source Agentic: yes · promotional bias: high · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: enterprise agentic engineering enablement

Uber needed to scale AI-assisted engineering across a large global SDLC without creating chaos, stale skills, unsafe code changes, or a top-down adoption program that engineers would ignore.

Constraints:

• the source reports Uber runs 200+ microservices with thousands of engineers spread globally
• AI experiments could not break production
• skill growth created risk of overlapping tools, stale code, and conflicting prompts
• company-wide skills needed governance, review, CI/CD checks, and evaluation
• team-specific and experimental skills needed low-friction sharing
• skills touching code needed deterministic outputs and human final review
• the marketplace had to encode tribal knowledge from senior engineers

Architecture

The source describes Uber's AI skills marketplace as a two-tier system. A Golden Marketplace auto-loads curated skills for all engineers and requires manual code review, CI/CD checks, and LLM-as-judge evaluation before deployment; a Personal Sandbox lets teams share experimental skills by URL without central governance. Claude acts as the general agent, skills provide task specialization, and verification skills run simulators, tests, CI/CD telemetry, and deterministic output reporting so engineers remain final reviewers.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  uber_engineer["Uber engineer"] --> claude_general_agent["Claude general agent"]
  claude_general_agent --> skill_cartridges["Skill cartridges"]
  uber_engineer --> personal_sandbox["Personal Sandbox"]
  personal_sandbox --> skill_cartridges
  uber_engineer --> golden_marketplace["Golden Marketplace"]
  skill_cartridges --> golden_marketplace
  governance_pipeline["Governance pipeline"] --> golden_marketplace
  llm_as_judge_evaluator["LLM-as-judge evaluator"] --> governance_pipeline
  ci_cd_checks["CI/CD checks"] --> governance_pipeline
  skill_cartridges --> verification_skills["Verification skills"]
  verification_skills --> ci_cd_checks
  skill_cartridges --> tribal_knowledge_skills["Tribal knowledge skills"]
  recall_graph_memory["Recall graph memory"] --> skill_cartridges

Components

Data flow

An engineer creates or uses a Claude skill inside the existing workflow. Experimental skills can live in team repos and be shared manually; mature skills can be promoted into the Golden Marketplace, where manual review, CI/CD checks, and LLM-as-judge evaluation run before company-wide auto-loading. At execution time, a skill performs a bounded task such as code review, CI triage, simulator testing, or tribal-knowledge guidance, then reports what it attempted, what succeeded, what failed, and the exact diff for engineer review.

"The Golden Marketplace

- Auto-loaded for all engineers, works out of the box"

Why this architecture

The architecture separates safe defaults from exploration. The Golden Marketplace gives every engineer a curated baseline of reviewed skills, while the Personal Sandbox lets bottom-up teams experiment quickly. Deterministic output contracts, CI/CD verification, LLM-as-judge checks, and human final review address production-risk concerns without blocking the grassroots demand loop that made skills spread.

Models used: Claude · Claude Code · LLM-as-a-Judge

Scale

• The source reports the marketplace grew from two custom Claude skills to 500+ specialized AI skills in five months.
  “Five months ago, one engineer at Uber pushed a repo with two custom Claude skills.”article, stated

  “That repo now powers 500+ specialized AI skills across Uber’s engineering org”article, stated
• The source says Uber runs 200+ microservices with thousands of engineers globally.
  “Uber runs 200+ microservices with thousands of engineers spread globally.”article, stated
• By March 2025, the article reports 200+ curated skills and 300+ experimental tools.
  “March 2025: 200+ curated skills in the main hub. 300+ experimental tools in team repos.”article, stated
• The source reports roughly twenty new skills added per week.
  “Twenty new skills added per week.”article, stated
• The Golden Marketplace is capped at 100-200 essential skills.
  “Capped at 100–200 essential skills”article, stated

Alternatives considered (roads not taken)

Run AI adoption through top-down mandates

Rejected because: The source argues leadership-driven licenses and mandates stall, while Uber's adoption spread from engineers solving immediate workflow problems.

Put all skills under strict central governance

Rejected because: Strict governance is appropriate for company-wide defaults, but experimental and team-specific skills need low-friction creation.

Use one generic code review skill

Rejected because: Uber reportedly built a tiered code-review family so trivial fixes and payment-processing changes receive different scrutiny.

Build bespoke AI agents from scratch for every capability

Rejected because: The source frames the emerging model as a general agent plus specialized skills loaded on demand.

Patterns

multi-agent-orchestration (skill-based specialization)

Uber's reported model combines a general Claude agent with many specialized skills, plus a second AI evaluator for governed marketplace deployment.

eval-driven-development (skill governance)

Golden Marketplace skills require manual review, CI/CD checks, LLM-as-judge evaluation, expected-baseline tests, and deterministic result reporting before deployment.

structured-output-contract (deterministic skill reporting)

Enterprise skills must report attempted actions, successes, failures, and exact diffs rather than vague qualitative claims.

human-in-the-loop-gate (engineering review)

Engineers remain the final reviewers of AI-generated skill outputs, especially for code changes.

safety-policy-enforcement (marketplace governance)

The two-tier marketplace enforces compliance at the curated core while allowing ungoverned experimentation at the edges.

agent-memory (corporate memory)

The experimental Recall skill uses Graph RAG over architectural decisions, failed experiments, and Slack debates to help new hires query organizational memory.

tool-use-orchestration (verification automation)

Verification skills operate external developer tools such as iOS simulators, mode/language toggles, and tests to prove generated code works.

Tradeoffs

Adopt bottom-up skill creation.

Chose Engineer-led marketplace growth from immediate workflow pain over Top-down AI mandate and steering committee rollout.

Rationale: The source attributes adoption to engineers using skills to finish work that previously took hours, not to centralized planning.

Split governed and experimental skills.

Chose Golden Marketplace plus Personal Sandbox over One marketplace policy for every skill.

Rationale: A curated default experience protects production workflows, while open team repos preserve speed and creativity.

Use general agent plus skills.

Chose Claude as general intelligence with skill cartridges over Bespoke custom agents built from scratch.

Rationale: Skills provide specialization on demand and are easier to scale across domains than building separate agents with complex SDKs.

Govern code-touching skills with deterministic reporting.

Chose Exact attempted/succeeded/failed/diff output over Natural-language confidence or generic success statements.

Rationale: Deterministic outputs make skill behavior auditable and keep engineers in control of production-impacting changes.

Gotchas (what bit them)

A fast-growing skill ecosystem can become chaotic.

Root cause: Hundreds of skills create overlapping tools, stale code, and conflicting prompts if all of them are treated as equal defaults.

Resolution: Use a two-tier marketplace with a curated Golden Marketplace and a free-form Personal Sandbox.

AI code generation is not useful if engineers cannot tell whether the result works.

Root cause: The model can write code but correctness is hidden unless verification runs against actual environments and tests.

Resolution: Assign AI to verification through simulator runs, UI mode/language checks, tests, CI/CD checks, and exact outcome reporting.

Vague AI success claims are unsafe for production engineering.

Root cause: A skill saying code looks good gives no audit trail of what changed, what failed, or what was attempted.

Resolution: Require deterministic outputs with exact diffs and success/failure reporting.

Tribal knowledge remains trapped in senior engineers' heads.

Root cause: Specialized debugging frameworks and mental models often live with a few experts rather than the whole organization.

Resolution: Encode senior-engineer expertise into Markdown-based skills that junior engineers can run.

Skills can go stale when internal APIs and environments change.

Root cause: Code breaks when environments change, and skill instructions can fail when dependencies are deprecated.

Resolution: Experiment with self-healing skills that monitor CI/CD failure rates, analyze errors, and rewrite their own instructions.

Evaluation

The source describes marketplace growth metrics, Golden Marketplace governance checks, LLM-as-judge evaluation against expected baselines, CI/CD verification, deterministic output contracts, and human reviewer oversight.

Metrics: growth from 2 skills to 500+ skills in five months · 20 skills by December 2024 · 200+ curated skills and 300+ experimental tools by March 2025 · 20 new skills per week · Golden Marketplace cap of 100-200 essential skills · CI/CD checks before deployment · LLM-as-judge tests against expected baselines

Outcomes

• The source reports Uber's internal marketplace grew from two skills to 500+ skills in five months.
• The main hub reached 200+ curated skills while team repos held 300+ experimental tools.
• The system supports code review, CI log triage and repair, mobile verification, tribal-knowledge transfer, data science skill packs, Graph RAG corporate memory, and self-healing skill experiments.
• A two-tier marketplace keeps default skills governed while allowing rapid team-specific experimentation.
• Enterprise skills must expose exact attempted actions, successes, failures, and diffs, with engineers as final reviewers.

The article claims adoption across thousands of engineers, 200+ microservices, 500+ skills, and about twenty new skills per week, but it is a secondary writeup and should be treated as high-promotional-bias evidence until corroborated by primary Uber materials.