# Optimize Rust Lambda Cold Starts

Rust Lambda functions can suffer slow first responses when binaries are large or initialization is heavy. This skill guides Claude, Codex, and Claude Code through concrete optimizations for build settings, dependencies, and deployment.

## Install

```bash
npx skillstore add emillindfors/cold-start-optimizer
```

## Metadata

- Status: approved
- Slug: emillindfors-cold-start-optimizer
- Version: 1.0.0
- Author version: 1.0.0
- Skillstore revision: r1
- Version status: valid
- Tree hash: b17fd375db2046faec8bbb4381b1f9a4b797c6d1e7e19308e039cdb9b6304e71
- Author: EmilLindfors
- GitHub username: EmilLindfors
- License: MIT
- Repository: https://github.com/EmilLindfors/claude-marketplace/tree/main/plugins/rust-lambda/skills/cold-start-optimizer
- Ref: a06681402992ceae98ba04d54cfd4ab004862696
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: external\_commands
- Quality score: 80
- Quality tier: silver
- Public page: https://skillstore.pages.dev/skills/emillindfors-cold-start-optimizer
- Manifest: https://skillstore.pages.dev/api/skills/emillindfors-cold-start-optimizer/manifest

## Capabilities

- Suggests Rust release profile settings for smaller Lambda binaries.
- Shows lazy initialization patterns using OnceLock.
- Recommends dependency feature reduction and cargo bloat checks.
- Explains ARM64 builds and deployment flags for Cargo Lambda.
- Provides CloudWatch query guidance for measuring init duration.

## Use Cases

- Tune a Rust Lambda Release Build: Review Cargo settings and dependency choices before packaging a Rust function for production Lambda deployment.
- Reduce First Request Latency: Identify eager initialization work and move expensive clients behind lazy creation patterns.
- Plan Cost-Aware Cold Start Mitigation: Compare ARM64, provisioned concurrency, binary size, and dependency changes for an operational service.

## Prompt Templates

### Check Build Settings

```
Review my Rust Lambda build settings for cold start risk. Suggest safe release profile changes and explain the expected impact.
```

### Find Eager Initialization

```
Find eager initialization in this Rust Lambda handler. Recommend lazy alternatives using OnceLock or request-time initialization.
```

### Prioritize Deployment Options

```
Compare ARM64, provisioned concurrency, and dependency reductions for this Rust Lambda service. Prioritize changes by latency impact and cost.
```

### Design a Measurement Plan

```
Create a cold start measurement plan for production. Include CloudWatch metrics, local checks, and rollout criteria.
```

## Limitations

- Does not run benchmarks or inspect AWS accounts by itself.
- Focuses on Rust Lambda functions, not every runtime.
- Example deployment commands require user review before use.
- Recommendations may need adjustment for strict latency or compliance targets.

## Best Practices

- Measure baseline cold starts before changing build or deployment settings.
- Keep main initialization minimal and move expensive clients behind lazy creation.
- Review binary size, dependencies, architecture, and concurrency as one optimization set.

## Anti Patterns

- Treating provisioned concurrency as a replacement for binary and initialization work.
- Adding broad dependency features without measuring the binary size impact.
- Deploying command examples unchanged in production environments.

## Security Audit

- Audited at: 2026-07-06T14:33:50.313\+00:00
- Summary: All static findings are false positives caused by Markdown triple backtick fences and example snippets in SKILL.md. The skill provides Rust AWS Lambda optimization guidance and restricts tools to Read and Grep. No prompt injection, data exfiltration, or executable automation was found.

## Stats

- Views: 162
- Downloads: 8
- Favorites: 0
- Popularity score: 0