Mert

Background

Gemini 3.5 Flash launched at Google I/O 2026 with a bold claim: it beats Gemini 3.1 Pro on coding and agentic benchmarks — while running 4x faster.

At the same time, X (formerly Twitter) is full of posts saying it hallucinates constantly and doesn’t even reach Claude Sonnet level.

So which is it? I ran a real benchmark using code from my actual dev stack to find out.

Who I am

• Solo indie Mac app developer (Tauri + Rust + Swift stack)
• I use Gemini daily as part of my coding workflow
• Built 13 macOS utilities, mostly Android connectivity tools

The Test

Models compared

• Gemini 3.1 Pro
• Gemini 3.5 Flash (new)

What I tested

I gave both models a ~200-line Rust file (ADB device manager) with 14 intentional bugs and asked them to find and fix everything.

Why 200 lines? Because in my experience:

• Under 50 lines: any model gets lucky sometimes
• Over 100 lines: older Flash models produce near-unusable code
• 200 lines: a realistic production task that separates real understanding from pattern matching

Bug breakdown

The ADB-specific bugs were key — you need domain knowledge to catch them, not just Rust syntax awareness.

Prompt (no hints)

The following Rust code contains several bugs.
Please identify all bugs and provide the corrected code.
Include an explanation for each bug.

No hints. No scaffolding. Raw capability test.

The Code (buggy version)

adb_device_manager.rs — click to expand

use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use std::sync::{Arc, Mutex};
use tokio::time::sleep;
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct AdbDevice {
    pub serial: String,
    pub state: DeviceState,
    pub properties: HashMap,
}

#[derive(Debug, Clone, PartialEq)]
pub enum DeviceState {
    Online, Offline, Unauthorized, Unknown,
}

pub struct AdbManager {
    devices: Arc>>,
    adb_path: String,
    command_timeout: Duration,
}

impl AdbManager {
    pub fn new(adb_path: String) -> Self {
        AdbManager {
            devices: Arc::new(Mutex::new(Vec::new())),
            adb_path,
            // BUG 1: from_millis(5) — should be from_secs(5)
            command_timeout: Duration::from_millis(5),
        }
    }

    pub fn execute_command(&self, serial: &str, args: &[&str]) -> Result {
        let start = Instant::now();

        // prepend "-s " before command args
        let mut cmd_args = vec!["-s", serial];
        cmd_args.extend_from_slice(args);

        let output = Command::new(&self.adb_path)
            .args(&cmd_args)
            .output()
            .map_err(|e| format!("Command failed: {}", e))?;

        // BUG 4: timeout check AFTER command completes — completely useless
        if start.elapsed() > self.command_timeout {
            return Err("timed out".to_string());
        }
        Ok(String::from_utf8_lossy(&output.stdout).to_string())
    }

    pub async fn wait_for_device(&self, serial: &str, timeout_secs: u64) -> Result<(), String> {
        let deadline = Instant::now() + Duration::from_secs(timeout_secs);
        loop {
            // BUG 8: no sleep → CPU at 100%
            let devices = self.get_connected_devices()?;
            if devices.iter().any(|d| d.serial == serial) {
                return Ok(());
            }
            if Instant::now() >= deadline {
                return Err("timeout".to_string());
            }
        }
    }

    pub fn install_apk(&self, serial: &str, apk_path: &str) -> Result<(), String> {
        let result = self.execute_command(serial, &["install", "-r", apk_path])?;
        // BUG 11: adb install returns exit code 0 even on failure
        // must check stdout for "Success"/"Failure" strings
        if result.contains("Failure") {
            return Err(format!("Install failed: {}", result));
        }
        Ok(())
    }

    pub fn take_screenshot(&self, serial: &str, save_path: &str) -> Result<(), String> {
        let temp_path = "/sdcard/screenshot_temp.png";
        self.execute_command(serial, &["shell", "screencap", "-p", temp_path])?;
        // BUG 12: temp file never deleted from device
        self.execute_command(serial, &["pull", temp_path, save_path])?;
        Ok(())
    }
}

Results

Bug detection

Both models found every bug. Accuracy: identical.

Speed

This was the most striking difference by far.

Where the models diverged

Same score, but different approaches on a few interesting bugs:

Bug 4 — timeout check after execution

3.1 Pro rewrote it using tokio::time::timeout (fully async)

3.5 Flash used spawn() + try_wait() polling loop (sync-leaning approach)

Both are valid fixes. Different style choices.

Bug 10 — Mutex poison handling

3.1 Pro: into_inner() to safely recover the data

3.5 Flash: expect() for fail-fast behavior

Opposite design philosophies. Neither is wrong — depends on your error handling strategy.

Bug 6 — spaces in remote path

3.1 Pro: correctly noted that Command::new handles args without shell splitting, so no quoting needed — left it as-is (accurate ADB knowledge)

3.5 Flash: added format!(""{}"", remote_path) quoting (technically unnecessary, slight overreach)

3.1 Pro showed deeper understanding of how ADB + Rust process spawning actually works.

Pricing reality check

App (free plan)

API (Pay-as-you-go)

Straight from Google AI Studio’s official UI:

The $9.00 output price is 3x the previous generation (Gemini 3 Flash at $3.00). Google’s “half the price of frontier models” pitch compares against competitors — not their own previous Flash tier.

For indie developers:

• Prototyping / testing → Free tier is more than enough
• Production / commercial → $1.50/$9.00. Budget carefully for output-heavy workloads.

Bonus: I asked Gemini about its own price. It hallucinated.

During testing I asked Gemini 3.5 Flash directly: “What’s the API pricing for Gemini 3.5 Flash?”

It confidently answered:

“Input: ~$0.50 / Output: ~$3.00 per million tokens!”

That’s the old Gemini 3 Flash Preview pricing. The actual price is $1.50/$9.00.

When I told it the real number, it immediately replied:

“I sincerely apologize! The information you provided is 100% correct!”

The model that aced a 14-bug Rust challenge couldn’t accurately describe its own pricing.

A hallucination detection benchmark article ending with a hallucination felt appropriate.

Conclusion

For free tier users: switch to 3.5 Flash immediately.

For API cost-conscious production use: consider 3.1 Flash-Lite at $0.25/$1.50.

On the “doesn’t reach Claude Sonnet” criticism — at least for Rust bug-fix tasks, both Flash models performed at a level I’d call genuinely useful. The hallucination complaints may apply more to conversational/knowledge tasks than structured code review — though in my limited testing with a single task type, I can’t say for certain.

I build macOS utilities for Mac×Android workflows. If you’re into Tauri, ADB, or MTP on macOS, feel free to follow.

This week confirmed what we’ve been building toward: the agent payments market is real.

Visa partnered with Inflow to launch cards for AI agents. Circle released Agent Stack. Sapiom closed a $15M seed round for agent payment infrastructure. Sygnum Bank executed live AI agent-powered digital asset transactions.

The market has spoken. Autonomous agents will transact at scale.

But there’s a structural question buried in this news that nobody’s asking: who controls the keys?

The Retrofit vs. Native Divide

Card networks are doing what they do best—extending existing infrastructure to new users. Visa’s agent card is a logical move. Same issuer rails, same dispute resolution, same compliance frameworks. Just automated the cardholder.

But here’s the problem: a Visa card for an AI agent still requires a human to dispute a charge.

Card infrastructure assumes human fallback. Someone to call the bank. Someone to approve exceptions. Someone to verify fraud. The entire paradigm is built on human-in-the-loop escalation.

That works when you’re adding AI capabilities to human workflows. It breaks when agents ARE the workflow.

The Architectural Question

There are two paths for agent payments:

Path 1: Retrofit human infrastructure

• Issue cards to agents
• Use existing authorization networks
• Layer agent logic on top of human compliance processes
• Keep humans in the escalation path

Path 2: Build agent-native infrastructure

• Give agents direct wallet custody via MPC
• Authorization happens in code, not through issuer approval
• Policy constraints are programmatic, not manual
• No human required for normal operation

These aren’t feature differences. They’re architectural ones.

Why MPC Wallets Are Structurally Different

Multi-Party Computation wallets use threshold signing. A 2-of-3 scheme means no single party holds the complete private key. The agent can authorize transactions, but within policy boundaries enforced by the key structure itself.

At AgentWallex, we use this for agent custody:

• Agent holds one key share
• Policy engine holds another
• Recovery mechanism holds the third

The agent can transact autonomously. But it CAN’T exceed spending limits, pay unauthorized recipients, or bypass rate caps—because the policy share won’t sign.

No approval queue. No manual review. No human fallback for normal operation.

Speed as a Structural Advantage

Our payment authorization completes in under 150ms. Card network authorization takes 2-3 seconds on average—and that’s before settlement.

This isn’t optimization. It’s architecture.

When you don’t need to route through issuer networks, check human approval queues, or wait for dispute resolution infrastructure to validate, you can move at the speed of cryptographic signing.

For x402 micropayments—pay-per-API-call billing—this matters. An agent calling 50 APIs per task can’t wait 3 seconds per payment. The task would take minutes instead of seconds.

What Agent-Native Actually Means

Sygnum Bank just completed live transactions using AI agents. These aren’t demos. They’re production.

We have 3,600 teams on our waitlist. Developers building with LangChain, CrewAI, AutoGPT—they’re not asking for cards. They’re asking for wallets their agents can use directly.

The pattern is consistent:

• Agents need to pay for API calls autonomously
• Manual approval breaks the workflow
• Card disputes don’t make sense when the “cardholder” is code
• Custody needs to stay with the agent, not the issuer

This is what we mean by agent-native. Not “better UX for humans managing agents.” Actual infrastructure agents can use without human intervention.

The Standards Layer

Stripe, Visa, and Tempo are building the Micropayment Protocol (MPP). Coinbase is implementing x402. These are the HTTP-level standards for agent payments.

We support them. We’re building the wallet and gateway layer ABOVE these protocols.

Standards define how payments are requested and formatted. Wallets define who holds custody and how authorization happens. Both are necessary. Neither replaces the other.

What This Week’s News Means

The funding rounds and partnerships validate the market. Enterprises believe agents will transact. Capital is flowing to infrastructure.

But validation of the market doesn’t answer the architectural question.

Do agents get retrofitted into human payment systems—cards, approval queues, dispute hotlines?

Or do we build infrastructure that works the way agents work—autonomous, programmatic, fast?

Both paths will exist. Card networks have distribution and compliance infrastructure that’s hard to replicate. For certain use cases, issuer control is exactly what you want.

But for true agent autonomy—agents that earn, spend, and transact without a human in the loop—you need wallet custody, not card issuance.

What We’re Building

AgentWallex is the payment gateway for AI agents. Not a card issuer. Not a bank. A gateway.

Agents get MPC wallets with policy constraints. They authorize payments in under 150ms. They pay per API call via x402. They operate within programmatic guardrails—no manual approvals required.

We’re live in sandbox at app.agentwallex.com. Production agents are already transacting.

The market just got validated. Now the architectural question matters.

Who controls the keys?

AgentWallex is building the payment infrastructure for autonomous agents. MPC-secured wallets, sub-150ms authorization, x402 native micropayments. 3,600+ teams on the waitlist. Start building at app.agentwallex.com.

Follow & Try AgentWallex

• 🌐 Website: app.agentwallex.com
• 🚀 Sandbox (free): app.agentwallex.com
• 📖 Docs: docs.agentwallex.com
• 📲 Telegram: t.me/AgentWallexOfficial
• 🐦 X / Twitter: x.com/AgentWallex
• 🦋 Bluesky: bsky.app/profile/agentwallex.bsky.social
• 💻 Dev.to: dev.to/agentwallex
• 📝 Hashnode: agentwallex.hashnode.dev

Introduction

“Plugins extend Claude Code with commands, agents, skills, hooks, and MCP servers.”

This is the NO.70 article in the “One Open Source Project a Day” series. Today we are exploring claude-plugins-official.

This is Anthropic’s officially maintained plugin registry on GitHub. If you have been using Claude Code lately, you have almost certainly seen the /plugin install command — this repository is the official plugin source behind that command.

20.2k Stars, 2.5k Forks, 669 open issues. Behind these numbers is a rapidly maturing ecosystem: Anthropic engineers have contributed 30+ plugins covering LSP support for 12 languages, a multi-agent PR review toolkit, Git workflow automation, and code quality analysis. 15 external partners — including GitHub, Firebase, Linear, and Terraform — have already joined.

But this article is not just about “what plugins exist.” What deserves equal attention is the design of the plugin specification itself: a single plugin.json file, three extension mechanisms (Skills/Commands/MCP), and two trigger modes (user-invoked vs. model-invoked). Understanding this architecture means understanding the boundaries and possibilities of Claude Code extensibility.

What You Will Learn

• The complete plugin directory structure of claude-plugins-official (internal vs. external plugins)
• The Claude Code plugin specification: from plugin.json to Skills/Commands/MCP
• Deep dives into five key plugins: pr-review-toolkit, agent-sdk-dev, code-review, hookify, commit-commands
• How to build a spec-compliant Claude Code plugin from scratch
• The current state of the external partner plugin ecosystem

Prerequisites

• Familiarity with Claude Code (basic slash command usage)
• A basic understanding of MCP (Model Context Protocol)
• Interest in building your own Claude Code extensions

Project Background

Project Introduction

claude-plugins-official is Anthropic’s official plugin registry, serving the Claude Code plugin ecosystem. It plays two roles simultaneously:

1. Plugin registry: Users install plugins via /plugin install <name>@claude-plugins-official
2. Development specification reference: plugins/example-plugin is the official complete reference implementation, demonstrating all extension mechanisms

The repository is divided into two main directories:

• /plugins: Developed by Anthropic engineers, covering LSP, development workflows, code quality, output styles, and more
• /external_plugins: Submitted by partners and the community, subject to quality and security review

Author/Team Introduction

This is a multi-contributor Anthropic internal project, with different engineers leading each plugin:

• pr-review-toolkit: Daisy ([email protected])
• agent-sdk-dev: Ashwin Bhat ([email protected])
• code-review: Boris Cherny ([email protected])
• frontend-design: Prithvi Rajasekaran + Alexander Bricken
• commit-commands: Anthropic team

Project Stats

• ⭐ GitHub Stars: 20,200+
• 🍴 Forks: 2,500+
• 👁️ Watchers: 147
• 🐛 Open Issues: 669
• 💻 Languages: Python (31.6%), TypeScript (28.9%), HTML (19.5%), Shell (13.0%), JavaScript (7.0%)
• 🏷️ Topics: skills, mcp, claude-code
• 🌐 Repository: anthropics/claude-plugins-official
• 📖 Docs: code.claude.com/docs/en/plugins

Main Features

Core Utility

claude-plugins-official provides a standardized way to extend Claude Code’s capabilities:

Native Claude Code capabilities
        ↓
  /plugin install <name>@claude-plugins-official
        ↓
  Extended Claude Code
  ├── New Slash Commands (user-invoked)
  ├── New Skills (model-auto-triggered)
  ├── New Agents (specialized task delegates)
  └── New MCP Tools (external service integrations)

Quick Start

Installing plugins (CLI):

# PR review toolkit
/plugin install pr-review-toolkit@claude-plugins-official

# Git commit command suite
/plugin install commit-commands@claude-plugins-official

# Agent SDK development tools
/plugin install agent-sdk-dev@claude-plugins-official

# Code review plugin
/plugin install code-review@claude-plugins-official

# Hook management tool
/plugin install hookify@claude-plugins-official

Installing plugins (UI):

In Claude Code, type: /plugin
→ Click "Discover"
→ Browse and install desired plugins

Installing external partner plugins:

# GitHub integration
/plugin install github@claude-plugins-official

# Linear project management
/plugin install linear@claude-plugins-official

# Firebase integration
/plugin install firebase@claude-plugins-official

# Terraform infrastructure
/plugin install terraform@claude-plugins-official

Plugin Directory Overview

Internal Plugins (/plugins)

External Partner Plugins (/external_plugins): asana, context7, discord, fakechat, firebase, github, gitlab, greptile, imessage, laravel-boost, linear, playwright, serena, telegram, terraform

Five Key Plugins: Deep Dives

Plugin 1: pr-review-toolkit — Six Parallel PR Review Agents

This is arguably the most elegantly designed plugin in the entire directory: 6 specialized agents running in parallel, reviewing the same Pull Request from different angles simultaneously.

PR submitted
  ↓
comment-analyzer      ← Comment accuracy, documentation completeness, comment rot
pr-test-analyzer      ← Test coverage quality, edge cases, behavioral vs. line coverage
silent-failure-hunter ← Silent failures, empty catch blocks, missing error logging
type-design-analyzer  ← Type encapsulation, invariants (rated 1–10 on 4 dimensions)
code-reviewer         ← CLAUDE.md compliance, style, bugs (0–100 score)
code-simplifier       ← Readability, unnecessary complexity, redundant abstractions

Natural language triggering:

"Are the tests thorough?"                  → triggers pr-test-analyzer
"Check the error handling in the API client" → triggers silent-failure-hunter
"Is this documentation accurate?"           → triggers comment-analyzer
"Simplify this code"                        → triggers code-simplifier

Full PR review (trigger all agents at once):

"I'm ready to create this PR. Please:
1. Review test coverage
2. Check for silent failures
3. Verify code comments are accurate
4. Review any new types
5. General code review"

Recommended workflow:

Write code → code-reviewer
Fix issues → silent-failure-hunter (if error handling changed)
Add tests  → pr-test-analyzer
Document   → comment-analyzer
Polish     → code-simplifier
→ Create PR

Plugin 2: agent-sdk-dev — Agent SDK Project Scaffolding

This plugin compresses “building a Claude Agent SDK project from scratch” into a single command.

/new-sdk-app command (interactive project creation):

/new-sdk-app my-agent-project
# Interactive prompts:
# 1. Language: TypeScript or Python?
# 2. Agent type: coding / business / custom
# 3. Starting point: minimal / basic / specific example
# 4. Package manager: npm/yarn/pnpm or pip/poetry

What it does automatically:

• Checks and installs the latest SDK version
• Creates project file structure, .env.example, .gitignore
• Runs type checking (TS) or syntax validation (Python)
• Automatically runs the appropriate Verifier agent (validates the project against SDK best practices)

Two Verifier Agents:

# Python project verification
"Verify my Python Agent SDK application"
→ Checks: SDK installation, requirements.txt/pyproject.toml,
           SDK usage patterns, agent init/config, .env security, error handling

# TypeScript project verification
"Verify my TypeScript Agent SDK application"
→ Checks: SDK installation, tsconfig.json, type safety/imports,
           agent init/config, .env security, error handling

Verifier output format:

Overall Status: PASS / PASS WITH WARNINGS / FAIL
- Critical Issues (blocking functionality)
- Warnings (suboptimal patterns)
- Passed Checks
- Recommendations (with SDK documentation links)

Plugin 3: code-review — Confidence-Filtered 4-Agent Code Review

This plugin addresses the most common problem with AI code review: too many false positives.

How it works:

1. Pre-checks — Skip closed, draft, or trivial PRs
2. Collect CLAUDE.md guideline files from the repo
3. Summarize PR changes
4. Launch 4 parallel agents:
   - Agent #1 & #2 → CLAUDE.md compliance checks
   - Agent #3 → Bug detection (changed code only)
   - Agent #4 → Git blame/history context analysis
5. Score each issue 0–100 for confidence
6. Filter out issues below threshold (default: 80)
7. Post review comment with high-confidence issues only

Confidence scale:

What gets filtered out:

• Pre-existing issues not introduced by this PR
• Code that looks buggy but isn’t
• Issues that linters will catch
• Items with lint-ignore comments

Configuring the confidence threshold (in commands/code-review.md):

# Change 80 to your preferred threshold
Filter out any issues with a score less than 80.

Plugin 4: hookify — Create Claude Code Hooks in Plain English

Claude Code’s Hooks feature (triggering custom logic before/after tool executions) requires manually editing complex JSON configuration. hookify eliminates that friction.

Core commands:

# Create a rule from plain English
/hookify Warn me when I use rm -rf commands

# Analyze recent conversation, auto-suggest behaviors to block
/hookify

# List all rules
/hookify:list

# Enable/disable rules interactively
/hookify:configure

Rules take effect immediately — no restart required.

Rule file format (stored as .claude/hookify.<name>.local.md):

---
name: block-dangerous-rm
enabled: true
event: bash
pattern: rms+-rf
action: block
---

⚠️ **Dangerous rm command detected!**

Please verify the path and ensure you have backups.

Advanced rules (multiple conditions):

---
name: warn-sensitive-files
enabled: true
event: file
action: warn
conditions:
  - field: file_path
    operator: regex_match
    pattern: .env$|credentials|secrets
  - field: new_text
    operator: contains
    pattern: KEY
---

🔐 **Sensitive file edit detected!**

Event types and when they fire:

Practical rule examples:

# Block destructive commands
event: bash
pattern: rms+-rf|dds+if=|mkfs|format
action: block

# Warn about debug code
event: file
pattern: console.log(|debugger;
action: warn

# Require tests before stopping
event: stop
action: block
conditions:
  - field: transcript
    operator: not_contains
    pattern: npm test|pytest|cargo test

# Prevent hardcoded API keys in TypeScript
event: file
conditions:
  - field: file_path
    operator: regex_match
    pattern: .tsx?$
  - field: new_text
    operator: regex_match
    pattern: (API_KEY|SECRET|TOKEN)s*=s*["']

Plugin 5: commit-commands — Three-Command Git Workflow

# Auto-generate commit message and commit
/commit

# Full one-command workflow: commit → push → create PR
/commit-push-pr

# Clean up local branches whose remotes have been deleted
/clean_gone

What /commit does:

1. Analyzes staged and unstaged changes
2. Reviews recent commit history to match repo style
3. Stages files and creates a commit message with Claude Code attribution
4. Automatically skips sensitive files (.env, credentials.json, etc.)

What /commit-push-pr does:

1. Creates a new branch if currently on main
2. Commits the changes
3. Pushes to origin
4. Creates a PR via GitHub CLI (includes Summary + test checklist)

Plugin Specification Deep Dive

Standard Plugin Directory Structure

plugin-name/
├── .claude-plugin/
│   └── plugin.json      # Plugin metadata (required)
├── .mcp.json            # MCP server config (optional)
├── skills/              # Skill definitions (preferred)
│   ├── my-skill/
│   │   └── SKILL.md     # Model-auto-triggered skill
│   └── my-command/
│       └── SKILL.md     # User-invoked slash command (also uses SKILL.md)
├── commands/            # Slash commands (legacy format)
│   └── my-command.md
├── agents/              # Agent definitions
└── README.md

The plugin.json Metadata Format

{
  "name": "my-plugin",
  "description": "A description of what this plugin does",
  "author": {
    "name": "Your Name",
    "email": "[email protected]"
  }
}

Deliberately minimal by design: only three fields — no version, no dependency declarations. A plugin’s capabilities are determined by its directory contents, not its metadata.

Three Extension Mechanisms Compared

Mechanism 1: Skills (Recommended for new plugins)

# Model-auto-triggered (context-based)
---
name: security-review
description: Automatically trigger security review when security-related code is detected
version: 1.0.0
---

# User-invoked (becomes /skill-name command)
---
name: my-command
description: Short description shown in /help
argument-hint: <arg1> [optional-arg]
allowed-tools: [Read, Glob, Grep]
---

Mechanism 2: Commands (Legacy format, functionally equivalent)

# commands/my-command.md
---
# YAML frontmatter
---
# Command content (same as SKILL.md)

Mechanism 3: MCP Servers (External service integration)

// .mcp.json
{
  "my-service": {
    "type": "http",
    "url": "https://api.myservice.com/mcp"
  }
}

The Key Difference Between Two Skill Trigger Modes

This distinction is critical: the frontend-design plugin is a perfect example of model-auto-triggered — the user simply says “create a dashboard” and Claude automatically applies that plugin’s design principles, no explicit invocation required.

External Plugin Submission Process

To get your own plugin listed in the official directory:

1. Ensure your plugin meets quality and security standards
   ↓
2. Visit https://clau.de/plugin-directory-submission
   ↓
3. Fill out the plugin submission form
   ↓
4. Anthropic review (quality + security)
   ↓
5. Merged into /external_plugins directory

Review criteria (inferred from documentation):

• Plugin must have a complete README and plugin.json
• MCP servers, if used, must be clearly documented
• No malicious code or unauthorized data collection
• Must provide real value, not duplicate existing functionality

Project Links & Resources

Official Resources

• 🌟 GitHub: https://github.com/anthropics/claude-plugins-official
• 📖 Plugin Development Docs: code.claude.com/docs/en/plugins
• 📝 External Plugin Submission: clau.de/plugin-directory-submission
• 🔧 Reference Implementation: /plugins/example-plugin (best starting point for plugin development)

Target Audience

• Power Claude Code users: Looking to extend their workflow capabilities with official plugins
• Plugin developers: Learning how to build spec-compliant Claude Code plugins
• Toolchain engineers: Connecting their own services to the Claude Code ecosystem via MCP servers
• Engineering productivity leads: Building custom team plugins and standardizing development workflows

Summary

Key Takeaways

Plugin ecosystem:

1. 30+ internal plugins: Covering LSP (12 languages), PR review, Git workflows, code quality, output styles, and other core development scenarios
2. 15 external plugins: GitHub, Firebase, Linear, Terraform, and other mainstream tools already integrated
3. Unified installation: One command handles everything — /plugin install <name>@claude-plugins-official

Plugin specification:

1. Minimal metadata: plugin.json needs only name, description, and author
2. Three extension mechanisms: Skills (recommended) / Commands (legacy) / MCP Servers (external services)
3. Two trigger modes: User-invoked vs. model-auto-triggered based on context
4. Security awareness built in: Official docs explicitly note that Anthropic does not vouch for third-party MCP servers — trust verification is the user’s responsibility

Core value of the five key plugins:

• pr-review-toolkit: 6 parallel agents → multi-angle coverage, eliminating single-reviewer blind spots
• agent-sdk-dev: One-command scaffolding + automatic Verifier → lower barrier to entry for Agent SDK
• code-review: Confidence filtering (default threshold 80) → fewer false positives, focus on real issues
• hookify: Natural language hook creation → no complex JSON config files
• commit-commands: /commit-push-pr → full pipeline from code to PR in one command

One-Line Review

claude-plugins-official is not just a plugin directory — it is Anthropic’s public answer to the question “how should AI tools be extended”: minimize metadata, maximize compositional flexibility, let Skills appear in the right context automatically rather than forcing users to memorize commands.

Find more useful knowledge and interesting products on my Homepage

Pipeline failures are one of those things every engineering team accepts as friction they can’t eliminate — something breaks at 2am, someone gets paged, someone debugs, someone fixes. Microsoft just published a working architecture that removes humans from that first-response loop entirely.

The Problem It’s Solving

Standard CI/CD pipelines fail, send you a stack trace, and wait. One small typo in a backend pool member IP can tank a deployment. The debugging cycle is manual by design: read the logs, understand the context, figure out what broke, push a fix, re-run. For teams migrating infrastructure — legacy load balancer settings to Azure ILB rules, for instance — that cycle can eat days.

The self-healing pipeline architecture Microsoft outlined on the Azure Infrastructure Blog replaces that cycle with an agentic loop. The pipeline still fails. But instead of waiting for a human to read the error, an AI agent reads it, understands it in infrastructure context, and proposes (or executes) a fix.

How It Actually Works

The self-healing workflow is an agentic loop consisting of three phases: Observe, Analyze, and Act. The process begins with an event-driven trigger. When an Azure DevOps pipeline fails, a webhook sends the telemetry and build logs to an Azure Function. The logs are then passed to GPT-4o via the Microsoft AI Foundry endpoint.

That last part is the hinge. The model doesn’t just look for error codes — it understands the infrastructure context. There’s a meaningful difference between a regex that matches “connection refused” and a model that can reason about why a backend pool misconfiguration would produce that error given the surrounding deployment context.

The implementation uses Azure AI Foundry’s ChatCompletionsClient to call GPT-4o with a system prompt that frames it as an autonomous DevOps assistant. The agent receives the raw error logs, analyzes them, and returns a proposed fix. That fix can then trigger a GitHub pull request or an Azure DevOps pipeline update automatically — the “Act” phase closing the loop.

Microsoft AI Foundry provides a standardized way to call Azure OpenAI, which matters for teams that want consistent API surface across environments rather than managing direct OpenAI endpoint configurations per service.

On why GPT-4o specifically: native tool use makes it specifically optimized for function calling, allowing the agent to interact with Azure DevOps APIs and GitHub seamlessly. As a first-party service, Azure OpenAI is also the most cost-effective path to running production-grade agents, and GPT-4o processes complex logs in seconds, identifying errors much faster than a human scanning line by line.

What Teams Are Actually Using This For

The Microsoft post describes a concrete infrastructure migration scenario: mapping legacy load balancer settings — like fastest-app-response or source-address persistence — to Azure ILB rules, where a single typo in backend pool member IPs can tank a deployment.

The agent now scans those configs before the pipeline runs, flags mismatches, and suggests the correct Azure-native equivalent. It’s saved the team days of trial-and-error debugging. That’s the pre-failure application — catching configuration drift before it becomes a deployment failure, not just responding after.

Post-failure, the loop handles anything where the fix is diagnosable from logs alone: dependency mismatches, misconfigured environment variables, failed health checks on newly deployed resources. The agent reads the failure telemetry, identifies the category of error, and proposes a remediation that goes straight to a PR for review — or executes directly, depending on how the “Act” phase is configured.

This connects to a broader pattern Microsoft’s platform engineering teams have been documenting. When a deployment degrades, Argo CD fires a webhook to GitHub Actions, which creates a GitHub issue with the failure details — cluster name, resource group, the initial telemetry. The agent reads the issue, authenticates to Azure via Workload Identity Federation, runs kubectl commands against the affected cluster, and queries the AKS MCP server for deeper telemetry. The self-healing CI/CD architecture is the Azure DevOps-native version of the same idea.

Why This Is a Bigger Deal Than It Looks

The architecture itself isn’t complex — webhook, Azure Function, GPT-4o call, conditional action. What’s significant is that it’s now a documented, first-party pattern from Microsoft’s Azure Infrastructure team, with a real use case attached. That’s different from a proof-of-concept.

AI agents don’t magically fix broken engineering practices — they scale them. If your CI/CD pipelines are fragile, agents will break them faster. If your test coverage is thin, agents will ship untested code at higher velocity. The self-healing architecture assumes your pipeline failures are diagnosable from logs. For teams with well-structured observability, that’s most failures. For teams without it, this pattern will surface the gaps fast.

There’s also a shift in how pipeline failures are categorized. Traditional CI/CD pipelines rely on binary assertions — Assert X == Y. But AI agents are probabilistic. The self-healing loop works well on the deterministic failure surface — config errors, missing dependencies, mismatched API parameters. The harder problem, testing and validating the agent’s own proposed fixes before they ship, is where the architecture gets more complex. For now, the PR-as-output model keeps a human in the loop on the final action, which is the right call for production systems.

By shifting the burden of initial troubleshooting to automated agents, teams aren’t just saving time — they’re increasing the reliability of their entire stack. That framing is accurate, but the reliability gain depends entirely on how the “Act” phase is scoped. Agents that open PRs are recoverable. Agents with direct write access to production pipelines require more careful guardrails before you’d want them running unsupervised.

Availability and Access

The pattern runs on Azure DevOps, Azure Functions, and Azure OpenAI via AI Foundry. No preview program required — these are all generally available services. The full implementation walkthrough, including the ChatCompletionsClient setup and the webhook-to-function wiring, is in the Microsoft Tech Community post.

The architecture is modular enough to adapt: swap Azure Functions for any serverless compute that can receive a webhook, swap GPT-4o for any model with strong function-calling support, and scope the “Act” phase to whatever your organization’s change management policy allows.

The pipeline-as-passive-executor era is ending. Pipelines that can read their own failures, reason about them, and act on them are the next default — and Microsoft just made the blueprint public.

Follow for more coverage on MCP, agentic AI, and AI infrastructure.

TL;DR (2026 Verdict): For most new React Native projects—especially those using Expo—choose Expo Router. It delivers superior developer experience, automatic deep linking, file-based routing that scales with teams, and excellent web parity with minimal boilerplate.

React Navigation remains the right choice for brownfield native integrations, highly bespoke custom transitions, or when you need maximum low-level control outside the Expo ecosystem. Expo Router is built on top of React Navigation, so you’re not abandoning its power—you’re gaining a smarter convention layer.

As a Senior Mobile Solutions Architect who’s shipped dozens of production React Native apps, here’s my practical, battle-tested comparison.

1. The Evolution: Routing as State Management for Screens

Routing in mobile apps is state management for screens: it decides which screen is visible, manages the navigation stack/history, handles transitions, deep links, and preserves state as users move around.

React Navigation (the OG) gave us a robust, flexible imperative/config-based system. It became the de facto standard because it worked reliably across complex flows and gave fine-grained control over navigators (Stack, Tab, Drawer, etc.).

Expo Router is the modern evolution. Introduced to solve real pain points in large codebases, it builds directly on React Navigation while adding file-based routing, automatic deep linking, TypeScript inference, and universal (web + native) capabilities. In 2026, it’s mature, production-proven, and the default recommendation for most new apps.

2. The Paradigm Shift: Imperative Configuration vs. Declarative File-Based Routing

React Navigation (Imperative/Configuration-based):

• You manually define navigators and register screens in code (often a central App.tsx or spread across modules).
• Adding a screen? Update the navigator config + import the component.
• Nested navigation requires explicit nesting of navigators.

Expo Router (Declarative/File-based):

• Your folder structure is your routes. Create a file → it becomes a route.
• _layout.tsx files define the navigator type and shared UI for that segment.

Example Folder Structure (The Lightbulb Moment):

/app
  ├── _layout.tsx          # Root layout (Providers, Theme, Auth guard)
  ├── (auth)               # Route group (no URL segment)
  │   ├── _layout.tsx      # Auth Stack
  │   ├── login.tsx        # /login
  │   └── register.tsx     # /register
  ├── (tabs)               # Tab group
  │   ├── _layout.tsx      # Bottom Tabs config
  │   ├── index.tsx        # Home (/)
  │   └── profile.tsx      # /profile
  └── [user].tsx           # Dynamic: /bhupesh_joshi

This maps directly to navigation. No massive config file. New team members can read the folder and understand the app structure instantly.

3. The ‘Deep Linking’ Argument: Web/Mobile Parity Wins

Expo Router treats every route as deep-linkable by default. No separate linking config hell. This shines for:

• Universal apps (same code for mobile + web)
• Shareable content
• SEO on web (static rendering, meta tags)
• Universal Links / App Links

React Navigation requires manual setup for deep linking and has weaker web support. In 2026, with more teams building universal experiences, this is a major advantage.

4. Technical Deep Dive

Protected Routes & Authentication

Expo Router (Clean):

• Use redirect in _layout.tsx with useRootNavigationState or a custom hook.
• Slot pattern for layouts.
• Auth state lives high; redirects are declarative.

React Navigation:

• Conditional rendering of different root navigators (AuthStack vs AppStack) based on auth state.
• Works well but leads to more imperative logic and potential state synchronization issues.

Performance & Bundle Behavior

• Expo Router: Automatic route-based bundle splitting (lazy loading via Suspense), deferred bundling. Smaller initial bundles, especially beneficial on web. Navigation transitions remain native and smooth (powered by React Navigation + react-native-screens).
• React Navigation: Excellent runtime performance. You manage bundling yourself. In large apps, the central config can bloat the main bundle if not careful.

Developer Workflow: Expo Router wins decisively. No hunting through a giant navigator file. Changes are localized to files/folders. Tooling (TypeScript routes, auto-completion) is superior.

5. When to Stick with React Navigation

Don’t migrate existing stable apps just for the hype. Stick with (or choose) React Navigation when:

• Highly bespoke navigation transitions or gestures that push Expo Router’s conventions.
• Brownfield integrations — adding React Native to an existing native app where you control the native navigation layer tightly.
• Apps that cannot (or prefer not to) use the Expo SDK/monorepo setup.
• Maximum flexibility with non-serializable data passing or deeply custom navigator compositions.
• Teams with heavy existing investment in custom React Navigation utilities.

Final Verdict Table (2026)

Real-World Advice from the Trenches

• New Greenfield Project in Expo? → Expo Router. The productivity gains compound.
• Large Team/Dashboard App with Auth + Tabs + Nested Stacks? → Expo Router enforces clean boundaries.
• Complex Animations or Native Module Heavy? → Evaluate both, but lean React Navigation if conventions feel restrictive.
• Production Adoption: Many teams have successfully migrated 60k+ MAU apps. Others run hybrid approaches.

Mental Model Shift: Stop thinking “I need to register this screen.” Start thinking “Where does this screen live in the URL/app hierarchy?”

Expo Router doesn’t replace React Navigation—it elevates it with conventions that make teams faster and code more maintainable. In 2026, for the majority of production-grade apps, that’s the winning approach.

Choose based on your constraints, not hype. But if you’re starting fresh, Expo Router is the 2026 default.

Build something great.

Google I/O ’26 dropped today, and for the first time in a while, the enterprise announcements are the ones worth paying attention to. Not because of model benchmarks — though those are interesting — but because Google just shipped an integrated agentic stack that reaches from the model layer all the way down to the individual worker’s inbox.

The Problem It’s Solving

Enterprise AI has had a deployment problem. Most organizations have access to capable models, but the path from “we have Gemini” to “our teams are actually running less manual work” has involved a lot of custom integration, fragile automations, and agents that can’t see across tools. What Google is trying to do with this I/O release is close that gap — ship the plumbing, not just the model.

The announcement covers five distinct products: Gemini 3.5, Gemini Omni, Google Antigravity, Gemini Spark, and a Managed Agents API on Agent Platform. Each one sits at a different layer of the stack.

How It Actually Works

Start with the model. Gemini 3.5 Flash is the new baseline — Google’s claim is that it rivals larger flagship models while staying within Flash’s speed and cost profile. The numbers they’re citing: 76.2% on Terminal-Bench 2.1, 83.6% on MCP Atlas, and 84.2% on CharXiv for multimodal understanding. Gemini 3.5 Pro is in testing and coming next month.

That MCP Atlas benchmark is worth noting specifically. Google scored Gemini 3.5 Flash against a benchmark designed around Model Context Protocol task completion — the same protocol that’s become the de facto standard for tool-using agents across the industry. Getting 83.6% there isn’t just a number; it’s a signal about where Google thinks the evaluation bar for agentic models should be.

Gemini Omni is the video-first model — takes text, audio, image, and video inputs and produces dynamic video output. Think post-production automation, e-commerce virtual try-ons, content localization. It’s rolling out in the coming weeks via the Gemini API.

Antigravity 2.0 is where things get more interesting for developers. It’s a standalone desktop app and now integrates with Agent Platform, meaning it inherits Google Cloud’s data privacy protections by default. There’s also an Antigravity CLI for teams that want a lighter-weight interface. The pitch from AirAsia Next’s CTO: over half of their production-ready code now comes through Antigravity agentic workflows. That’s a real number from a shipping company, not a demo.

Gemini Spark is the personal agent layer. It runs 24/7 in the background, connects to Workspace plus external connectors like Salesforce, Zendesk, ServiceNow, and SharePoint, and can take multi-step actions autonomously — with approval gates for anything high-risk. Every task runs in an ephemeral VM, credentials never touch the agent directly, and all traffic routes through an Agent Gateway that enforces DLP policies. The isolation story is more specific than most personal agent announcements tend to be.

The Managed Agents API lets developers spin up custom agents via a single API call, running in Google-hosted environments. No infrastructure to manage; governance and security inherit from Agent Platform automatically.

And there’s CodeMender — an AI security agent from Google DeepMind, now integrated into Agent Platform. It finds vulnerabilities, proposes patches, tests them, and can apply fixes across dependent systems with developer approval.

What Developers and Enterprises Are Actually Using This For

The use cases Google is demonstrating are specific enough to be useful as a map.

For IT operations: Spark monitors ServiceNow, detects recurring incidents, creates escalated Jira tickets, drafts incident reports, and pings the right manager for approval before sending anything externally.

For sales: Spark pulls account history from Salesforce, cross-references support tickets from Zendesk, identifies churn signals, and drafts a retention strategy — sitting in draft until the salesperson approves it.

For product launches: Antigravity 2.0 handles simultaneous agent-driven execution across code generation, asset creation, and customer email drafts, all orchestrated from a single workspace.

For security: CodeMender audits codebases, recommends patches, and deploys them with human sign-off. This is particularly relevant for teams carrying compliance obligations where every change needs an audit trail.

Why This Is a Bigger Deal Than It Looks

The piece that matters most here isn’t any single product — it’s that Google is shipping an end-to-end agentic stack with enterprise data controls built in from the start, not bolted on.

Most enterprise AI deployments today involve stitching together a model API, a separate orchestration layer, custom connector work, and some homegrown governance layer. Google is trying to collapse that into a single platform surface where the governance, security, and agent behavior are codesigned. The Managed Agents API making Agent Platform’s data protections automatic is a specific example of what that looks like in practice.

The MCP Atlas benchmark score is also a tell. Scoring Gemini 3.5 Flash against an MCP-specific benchmark is an implicit endorsement of MCP as the standard evaluation surface for agentic capability — significant given how much momentum MCP has built across the industry since Google Cloud Next ’26.

Availability and Access

Gemini 3.5 Flash is live today in Gemini Enterprise, Google AI Studio, and Antigravity. Gemini Omni Flash comes in the next few weeks. Gemini Spark in the Gemini Enterprise app is rolling out soon; Workspace preview for business customers follows. Antigravity in Gemini Enterprise arrives in the coming months. Managed Agents API documentation is live at docs.cloud.google.com.

Gemini 3.5 Pro remains in testing, expected next month.

The shift from AI-assisted work to AI-executed work — with humans approving rather than doing — is the actual direction this points. Google’s bet at I/O ’26 is that enterprises will adopt that model faster if the security and governance story is tight from day one, not something they have to build themselves.

Follow for more coverage on MCP, agentic AI, and AI infrastructure.