serverless-engineering

v0.1.1

Serverless engineering team — agents for building on serverless the provider-neutral way. serverless-architect owns the design side: event-driven decomposition, FaaS-vs-containers-vs-managed-services and when serverless is the WRONG choice, sync/async, orchestration-vs-choreography, event contracts, the dual-write/outbox problem, and serverless-friendly storage. serverless-runtime-and-ops-engineer owns the runtime side: cold starts, concurrency & throttling, idempotency & exactly-once-effect, DLQs & poison messages, retries, per-invocation cost & the scale crossover, tracing in ephemeral runtimes, and local emulation. skills, a knowledge bank (a Mermaid decision tree + a dated 2026 patterns reference), templates. Provider-neutral PATTERNS only — distinct from aws-cloud/gcp-cloud/azure-cloud (provider IaC/specifics), data-streaming-engineering (Kafka/Kinesis), devops-cicd (deploy pipeline), backend-engineering (the serverful alternative), observability-sre (SLOs). Requires ravenclaude-core@>=0.7.0.

Claude Code3 Skills

By Matt CorbettLicense: MIT7 GitHub starsUpdated last week

Directory evidence

Runtimes: Claude Code
Parsed components: 3 skill or MCP entries
Source updated: Sep 15, 2026
Manifest status: Canonical path parsed

The directory validates manifest shape and source location. It does not execute the plugin or provide a security endorsement. Review the indexing methodology →

Install serverless-engineering for Claude Code

Installs for the current user

claude plugin marketplace add IchenDEV/agent-plugin-mkt
claude plugin marketplace update agent-plugin-marketplace
claude plugin install serverless-engineering@agent-plugin-marketplace

Paste and run these commands in a terminal with Claude Code. They add and refresh the PluginsMP catalog, then install this plugin.

The installer fetches third-party code from the source repository shown on this page. This directory validates manifest structure and source location, but does not perform a security audit; review the manifest, components, and source before installing.

Get the source manually

$ git clone https://github.com/mcorbett51090/RavenClaude

Clone the source repository, then follow its setup instructions to add the plugin to a compatible client. The plugin root is plugins/serverless-engineering/.

Plugin files

plugins/serverless-engineering/

├── .claude-plugin/plugin.json
├── skills/design-event-driven-architecture/SKILL.md
├── skills/harden-serverless-runtime/SKILL.md
└── skills/model-serverless-cost-and-scale/SKILL.md

Included Skills3

design-event-driven-architectureskills/design-event-driven-architecture/SKILL.md

Decompose a workload into functions and events for a serverless/event-driven design — the serverless-vs-container-vs-managed-service call (and where serverless is the WRONG choice: steady high-throughput, long-running, tight-latency, pooled-RDBMS), sync-vs-async boundaries per interaction, orchestration (state machine/saga) vs choreography (event bus), the event schemas & contracts, serverless-friendly storage vs a connection-pool-hostile RDBMS, and the dual-write/outbox fix — designed around events and contracts so it never becomes a distributed monolith (lambda pinball). Reach for this on 'serverless vs containers vs managed service?', 'decompose this into functions/events', 'state machine vs event bus?', or 'can our RDBMS sit behind these functions?'. Driven by `serverless-architect` (primary).

harden-serverless-runtimeskills/harden-serverless-runtime/SKILL.md

Harden a serverless function/pipeline for the runtime & ops realities — cold starts (causes, the provisioned/warm-concurrency vs package-slimming trade-off against the latency budget, and what NOT to over-provision), concurrency & account/region limits & throttling with downstream (RDBMS) protection, idempotency keys + exactly-once-EFFECT (delivery is at-least-once), DLQ + poison-message policy, and retry/backoff/visibility-timeout so a queue is never an infinite-retry outage. Reach for this on 'fix our cold starts', 'this queue double-processes / retries forever', or 'we're getting throttled — plan our concurrency'. Driven by `serverless-runtime-and-ops-engineer` (primary).

model-serverless-cost-and-scaleskills/model-serverless-cost-and-scale/SKILL.md

Model serverless cost and scale — a per-invocation cost model (invocations × duration × memory + requests + data-transfer + downstream), the serverless-vs-container crossover point where steady high-throughput makes always-on cheaper (and 'serverless is cheaper' stops being true at scale), and concurrency/quota/limit planning (account/region caps, reserved/provisioned concurrency, throttle headroom). Reach for this on 'is serverless actually cheaper here?', 'where do we cross over to containers?', or 'plan our concurrency/quota headroom'. Driven by `serverless-runtime-and-ops-engineer` (primary), consulted by `serverless-architect` for the cost side of the serverless-vs-not call.

Plugin manifests1

plugins/serverless-engineering/.claude-plugin/plugin.json

{
  "name": "serverless-engineering",
  "version": "0.1.1",
  "description": "Serverless engineering team — agents for building on serverless the provider-neutral way. serverless-architect owns the design side: event-driven decomposition, FaaS-vs-containers-vs-managed-services and when serverless is the WRONG choice, sync/async, orchestration-vs-choreography, event contracts, the dual-write/outbox problem, and serverless-friendly storage. serverless-runtime-and-ops-engineer owns the runtime side: cold starts, concurrency & throttling, idempotency & exactly-once-effect, DLQs & poison messages, retries, per-invocation cost & the scale crossover, tracing in ephemeral runtimes, and local emulation. skills, a knowledge bank (a Mermaid decision tree + a dated 2026 patterns reference), templates. Provider-neutral PATTERNS only — distinct from aws-cloud/gcp-cloud/azure-cloud (provider IaC/specifics), data-streaming-engineering (Kafka/Kinesis), devops-cicd (deploy pipeline), backend-engineering (the serverful alternative), observability-sre (SLOs). Requires ravenclaude-core@>=0.7.0.",
  "author": {
    "name": "Matt Corbett"
  },
  "homepage": "https://github.com/mcorbett51090/RavenClaude",
  "license": "MIT",
  "keywords": [
    "serverless",
    "faas",
    "event-driven",
    "cold-start",
    "concurrency",
    "idempotency",
    "dead-letter-queue",
    "orchestration",
    "outbox",
    "serverless-cost",
    "distributed-monolith"
  ],
  "requires": {
    "plugins": [
      "ravenclaude-core@>=0.7.0"
    ]
  }
}