AWS Skills for Claude Code

1# AWS Skills for Claude Code
2 
3Claude Code plugins for AWS development with specialized knowledge and MCP server integrations, including CDK, serverless architecture, cost optimization, and Bedrock AgentCore for AI agent deployment.
4 
5## Plugins
6 
7### 0. AWS Common Plugin (Dependency)
8 
9Shared AWS agent skills including AWS Documentation MCP configuration for querying up-to-date AWS knowledge.
10 
11**Features**:
12- AWS MCP server configuration guide
13- Documentation MCP setup for querying AWS knowledge
14- Shared by all other AWS plugins as a dependency
15 
16**Note**: This plugin is automatically loaded as a dependency by other plugins. Install it first if installing plugins individually.
17 
18### 1. AWS CDK Plugin
19 
20AWS CDK development skill with integrated MCP server for infrastructure as code.
21 
22**Features**:
23- AWS CDK best practices and patterns
24- Pre-deployment validation script
25- Comprehensive CDK patterns reference
26 
27**Integrated MCP Server**:
28- AWS CDK MCP (stdio)
29 
30### 2. AWS Cost & Operations Plugin
31 
32Cost optimization, monitoring, and operational excellence with 3 integrated MCP servers.
33 
34**Features**:
35- Cost estimation and optimization
36- Monitoring and observability patterns
37- Operational best practices
38 
39**Integrated MCP Servers**:
40- AWS Pricing
41- AWS Cost Explorer
42- Amazon CloudWatch
43 
44### 3. AWS Serverless & Event-Driven Architecture Plugin
45 
46Serverless and event-driven architecture patterns based on Well-Architected Framework.
47 
48**Features**:
49- Well-Architected serverless design principles
50- Event-driven architecture patterns
51- Orchestration with Step Functions
52- Saga patterns for distributed transactions
53- Event sourcing patterns
54 
55### 4. AWS Agentic AI Plugin
56 
57AWS Bedrock AgentCore comprehensive expert for deploying and managing AI agents.
58 
59**Features**:
60- Gateway service for converting REST APIs to MCP tools
61- Runtime service for deploying and scaling agents
62- Memory service for managing conversation state
63- Identity service for credential and access management
64- Code Interpreter for secure code execution
65- Browser service for web automation
66- Observability for tracing and monitoring
67 
68## Installation
69 
70Add the marketplace to Claude Code:
71 
72```bash
73/plugin marketplace add zxkane/aws-skills
74```
75 
76Install plugins individually:
77 
78```bash
79# Install the common dependency first
80/plugin install aws-common@aws-skills
81 
82# Then install the plugins you need
83/plugin install aws-cdk@aws-skills
84/plugin install aws-cost-ops@aws-skills
85/plugin install serverless-eda@aws-skills
86/plugin install aws-agentic-ai@aws-skills
87```
88 
89## Core CDK Principles
90 
91### Resource Naming
92 
93**Do NOT explicitly specify resource names** when they are optional in CDK constructs.
94 
95```typescript
96// ✅ GOOD - Let CDK generate unique names
97new lambda.Function(this, 'MyFunction', {
98  // No functionName specified
99});
100 
101// ❌ BAD - Prevents multiple deployments
102new lambda.Function(this, 'MyFunction', {
103  functionName: 'my-lambda',
104});
105```
106 
107### Lambda Functions
108 
109Use appropriate constructs for automatic bundling:
110 
111- **TypeScript/JavaScript**: `NodejsFunction` from `aws-cdk-lib/aws-lambda-nodejs`
112- **Python**: `PythonFunction` from `@aws-cdk/aws-lambda-python-alpha`
113 
114### Pre-Deployment Validation
115 
116Before committing CDK code:
117 
118```bash
119npm run build
120npm test
121npm run lint
122cdk synth
123./scripts/validate-stack.sh
124```
125 
126## Usage Examples
127 
128### CDK Development
129 
130Ask Claude to help with CDK:
131 
132```
133Create a CDK stack with a Lambda function that processes S3 events
134```
135 
136Claude will:
137- Follow CDK best practices
138- Use NodejsFunction for automatic bundling
139- Avoid explicit resource naming
140- Grant proper IAM permissions
141- Use MCP servers for latest AWS information
142 
143### Cost Optimization
144 
145Estimate costs before deployment:
146 
147```
148Estimate the monthly cost of running 10 Lambda functions with 1M invocations each
149```
150 
151Analyze current spending:
152 
153```
154Show me my AWS costs for the last 30 days broken down by service
155```
156 
157### Monitoring and Observability
158 
159Set up monitoring:
160 
161```
162Create CloudWatch alarms for my Lambda functions to alert on errors and high duration
163```
164 
165Investigate issues:
166 
167```
168Show me CloudWatch logs for my API Gateway errors in the last hour
169```
170 
171### Security and Audit
172 
173Audit activity:
174 
175```
176Show me all IAM changes made in the last 7 days
177```
178 
179Assess security:
180 
181```
182Run a Well-Architected security assessment on my infrastructure
183```
184 
185### Serverless Development
186 
187Build serverless applications:
188 
189```
190Create a serverless API with Lambda and API Gateway for user management
191```
192 
193Implement event-driven workflow:
194 
195```
196Create an event-driven order processing system with EventBridge and Step Functions
197```
198 
199Orchestrate complex workflows:
200 
201```
202Implement a saga pattern for booking flights, hotels, and car rentals with compensation logic
203```
204 
205### AI Agent Development
206 
207Deploy AI agents with Bedrock AgentCore:
208 
209```
210Deploy a REST API as an MCP tool using AgentCore Gateway
211```
212 
213Manage agent memory:
214 
215```
216Set up conversation memory for my AI agent with DynamoDB backend
217```
218 
219Monitor agent performance:
220 
221```
222Configure observability for my AgentCore runtime with CloudWatch dashboards
223```
224 
225## Structure
226 
227```
228.
229├── .claude-plugin/
230│   └── marketplace.json              # Plugin marketplace configuration
231├── plugins/                          # Each plugin has isolated skills
232│   ├── aws-common/
233│   │   └── skills/
234│   │       └── aws-mcp-setup/        # Shared MCP configuration skill
235│   │           └── SKILL.md
236│   ├── aws-cdk/
237│   │   └── skills/
238│   │       └── aws-cdk-development/  # CDK development skill
239│   │           ├── SKILL.md
240│   │           ├── references/
241│   │           │   └── cdk-patterns.md
242│   │           └── scripts/
243│   │               └── validate-stack.sh
244│   ├── aws-cost-ops/
245│   │   └── skills/
246│   │       └── aws-cost-operations/  # Cost & operations skill
247│   │           ├── SKILL.md
248│   │           └── references/
249│   │               ├── operations-patterns.md
250│   │               └── cloudwatch-alarms.md
251│   ├── serverless-eda/
252│   │   └── skills/
253│   │       └── aws-serverless-eda/   # Serverless & EDA skill
254│   │           ├── SKILL.md
255│   │           └── references/
256│   │               ├── serverless-patterns.md
257│   │               └── eda-patterns.md
258│   └── aws-agentic-ai/
259│       └── skills/
260│           └── aws-agentic-ai/       # Bedrock AgentCore skill
261│               ├── SKILL.md
262│               ├── services/         # Service-specific docs
263│               └── cross-service/    # Cross-service patterns
264└── README.md
265```
266 
267## MCP Server Names
268 
269MCP server names use short identifiers to comply with Bedrock's 64-character tool name limit. The naming pattern is: `mcp__plugin_{plugin}_{server}__{tool}`
270 
271Examples: `awsdocs` (AWS docs), `cdk` (CDK), `cw` (CloudWatch), `sfn` (Step Functions), `sam` (Serverless), etc.
272 
273## Resources
274 
275- [Claude Agent Skills](https://docs.claude.com/en/docs/claude-code/skills)
276- [AWS MCP Servers](https://awslabs.github.io/mcp/)
277- [AWS CDK](https://aws.amazon.com/cdk/)
278- [Amazon Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html)
279- [MCP Protocol](https://modelcontextprotocol.io/)
280 
281## License
282 
283MIT License - see [LICENSE](LICENSE)
284