SkillAgentSearch skills...

aws-patterns

Lambda best practices, S3 event patterns, SQS/SNS fanout, and DynamoDB access patterns for serverless AWS architectures.

Install / Use

npx skills add vibeeval/vibecosystem --skill aws-patterns

Installs into whichever agent you are using.

About this skill
๐Ÿ“„

SKILL.md

Installable skill definition

Quality Score

84/100

Supported Platforms

Zed

Our assessment of aws-patterns

aws-patterns scores 84/100 on our quality scale, 882nd of 1,148 Content & Media skills we index.

Its SKILL.md is 6.0 KB long, split into 7 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

It has 535 GitHub stars, a meaningful sign that others use it.

Substance
29/30
Structure
18/20
Description
15/15
Adoption
12/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 3 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-10-10 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit โ€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk โ€” read a skill before letting an agent act on it.

aws-patterns compared with similar skills

All 4 of these similar skills score higher than aws-patterns; compare them before choosing.

SkillScoreStarsUpdatedFormat
aws-patterns (this skill)by vibeeval845353mo agoSKILL.md
hyperframesby heygen-com10086.4ktodayCLAUDE.md
rufloby ruvnet10082.0ktodayCLAUDE.md
headroomby headroomlabs-ai10080.1ktodayCLAUDE.md
siyuanby siyuan-note10047.3ktodayMCP Server

Frequently asked questions

How do I install aws-patterns?
Run npx skills add vibeeval/vibecosystem --skill aws-patterns. The install tabs above show the steps for each supported agent.
Which AI agents does aws-patterns work with?
It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
Is aws-patterns safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is aws-patterns still maintained?
The repository was last updated about 3 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: aws-patterns description: Lambda best practices, S3 event patterns, SQS/SNS fanout, and DynamoDB access patterns for serverless AWS architectures.

AWS Patterns

Serverless and managed service patterns for AWS production workloads.

Lambda Best Practices

// Cold start optimization: keep handler thin, initialize outside handler
import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb'

// Initialized ONCE per container (reused across invocations)
const client = DynamoDBDocumentClient.from(new DynamoDBClient({}))

export const handler = async (event: APIGatewayProxyEvent) => {
  try {
    const userId = event.pathParameters?.id
    if (!userId) {
      return { statusCode: 400, body: JSON.stringify({ error: 'Missing user ID' }) }
    }

    const result = await client.send(new GetCommand({
      TableName: process.env.USERS_TABLE!,
      Key: { pk: `USER#${userId}`, sk: `PROFILE` }
    }))

    if (!result.Item) {
      return { statusCode: 404, body: JSON.stringify({ error: 'User not found' }) }
    }

    return {
      statusCode: 200,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(result.Item)
    }
  } catch (err) {
    console.error('Handler error:', err)
    return { statusCode: 500, body: JSON.stringify({ error: 'Internal server error' }) }
  }
}

S3 Event Processing

// S3 โ†’ Lambda: process uploaded files
import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3'

const s3 = new S3Client({})

export const handler = async (event: S3Event) => {
  for (const record of event.Records) {
    const bucket = record.s3.bucket.name
    const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, ' '))
    const size = record.s3.object.size

    // Guard: skip non-image files or oversized uploads
    if (size > 10_000_000) {
      console.warn(`Skipping oversized file: ${key} (${size} bytes)`)
      continue
    }

    const response = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }))
    const body = await response.Body!.transformToByteArray()

    await processImage(body, key)

    console.log(`Processed ${key} (${size} bytes)`)
  }
}

SQS/SNS Fanout Pattern

// SNS โ†’ multiple SQS queues (fanout to parallel consumers)

// Publisher: send to SNS topic
import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'

const sns = new SNSClient({})

async function publishOrderEvent(order: Order): Promise<void> {
  await sns.send(new PublishCommand({
    TopicArn: process.env.ORDER_EVENTS_TOPIC!,
    Message: JSON.stringify(order),
    MessageAttributes: {
      eventType: { DataType: 'String', StringValue: 'order.created' },
      region: { DataType: 'String', StringValue: order.region }
    }
  }))
}

// Consumer: SQS Lambda (one per subscriber: email, analytics, inventory)
export const emailHandler = async (event: SQSEvent) => {
  for (const record of event.Records) {
    const order = JSON.parse(record.body) as Order

    try {
      await sendOrderConfirmation(order)
    } catch (err) {
      console.error(`Failed to send email for order ${order.id}:`, err)
      throw err  // Message returns to queue for retry (DLQ after maxReceiveCount)
    }
  }
}

DynamoDB Single-Table Design

// Access patterns drive table design, not entity relationships

// Table: pk (partition key) + sk (sort key) + GSI1PK + GSI1SK
// Entities: User, Order, OrderItem - all in one table

const AccessPatterns = {
  // Get user profile
  getUserProfile: (userId: string) => ({
    pk: `USER#${userId}`,
    sk: `PROFILE`
  }),

  // Get user's orders (sorted by date)
  getUserOrders: (userId: string) => ({
    pk: `USER#${userId}`,
    sk: { begins_with: 'ORDER#' }     // sk: ORDER#2025-01-15#orderId
  }),

  // Get order with items
  getOrderWithItems: (orderId: string) => ({
    pk: `ORDER#${orderId}`,
    sk: { begins_with: '' }            // sk: METADATA, ITEM#productId
  }),

  // Get orders by status (GSI1)
  getOrdersByStatus: (status: string) => ({
    GSI1PK: `STATUS#${status}`,
    GSI1SK: { begins_with: '' }        // GSI1SK: date#orderId
  })
}

// Write: transactional multi-item write
import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb'

async function createOrder(order: Order): Promise<void> {
  const items = [
    // Order metadata
    {
      Put: {
        TableName: process.env.TABLE!,
        Item: {
          pk: `ORDER#${order.id}`,
          sk: 'METADATA',
          GSI1PK: `STATUS#${order.status}`,
          GSI1SK: `${order.createdAt}#${order.id}`,
          ...order
        }
      }
    },
    // User's order reference
    {
      Put: {
        TableName: process.env.TABLE!,
        Item: {
          pk: `USER#${order.userId}`,
          sk: `ORDER#${order.createdAt}#${order.id}`,
          orderId: order.id,
          total: order.total,
          status: order.status
        }
      }
    }
  ]

  await client.send(new TransactWriteCommand({ TransactItems: items }))
}

Checklist

  • [ ] Lambda: initialize SDK clients outside handler (reuse across invocations)
  • [ ] Lambda: set memory based on profiling (more memory = more CPU = faster)
  • [ ] Lambda: set timeout to 2x expected duration (not max 900s)
  • [ ] SQS: configure Dead Letter Queue with maxReceiveCount: 3
  • [ ] DynamoDB: design table around access patterns, not entities
  • [ ] DynamoDB: use TransactWrite for multi-item atomicity
  • [ ] S3: enable versioning and lifecycle rules for cost optimization
  • [ ] SNS: use message attributes for subscriber filtering

Anti-Patterns

  • Initializing SDK clients inside Lambda handler (cold start penalty every time)
  • Synchronous Lambda chains: A calls B calls C (use Step Functions)
  • DynamoDB scan operations in production (always query with pk/sk)
  • S3 event without idempotency: Lambda can be invoked multiple times per event
  • Oversized Lambda packages (>50MB): use layers or container images
  • Missing DLQ on SQS: failed messages silently disappear after retention period

Related Skills

View on GitHub
GitHub Stars535
CategoryContent
Updated3mo ago
Forks44

Languages

C#

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit โ€” see the Safety scan above for what the skill file itself contains.

1 info
aws-patterns โ€” Zed Skill: Install & Safety Check | SkillAgent