Discover AWS CodeWhisperer, Amazon's AI-powered coding companion. Learn how it compares to GitHub Copilot, best practices for AI-assisted development, and tips to maximize your productivity.
AI coding assistants are changing how we write code, and AWS has entered the arena with CodeWhisperer. After using it for months in production, here's everything you need to know.
What is AWS CodeWhisperer?
CodeWhisperer is Amazon's AI-powered code generator that provides real-time code suggestions directly in your IDE. Think GitHub Copilot, but with deep AWS integration and security scanning built-in.
Key Features:
- Real-time suggestions - As you type
- Multi-language support - Python, Java, JavaScript, TypeScript, C#, Go, Rust, PHP, Ruby, Kotlin, SQL, Scala
- AWS-optimized - Knows AWS SDK patterns and best practices
- Security scanning - Detects security vulnerabilities
- Reference tracking - Shows when suggestions match public code
- Free tier - Individual developers can use it free
Getting Started
Installation
# VS Code
# Install the "AWS Toolkit" extension
# Then enable CodeWhisperer in the extension settings
# JetBrains IDEs (IntelliJ, PyCharm, etc.)
# Install the "AWS Toolkit" plugin
# Enable CodeWhisperer in plugin settings
# AWS Cloud9
# Built-in, just enable it in preferences
Authentication
# Option 1: AWS Builder ID (Free, no AWS account needed)
# Click "Start" in CodeWhisperer panel
# Select "AWS Builder ID"
# Follow browser authentication
# Option 2: IAM Identity Center (For organizations)
# Use your organization's SSO
CodeWhisperer in Action
Example 1: Lambda Function
Type a comment describing what you want:
# Function to upload a file to S3 and return the URL
# CodeWhisperer suggests:
import boto3
from datetime import datetime
def upload_file_to_s3(file_path, bucket_name):
"""Upload a file to S3 and return the URL"""
s3_client = boto3.client('s3')
try:
# Generate unique key
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
file_name = file_path.split('/')[-1]
s3_key = f"{timestamp}_{file_name}"
# Upload file
s3_client.upload_file(file_path, bucket_name, s3_key)
# Generate URL
url = f"https://{bucket_name}.s3.amazonaws.com/{s3_key}"
return url
except Exception as e:
print(f"Error uploading file: {e}")
raise
Example 2: DynamoDB Query
# Function to query DynamoDB table by user_id and get last 10 orders
# CodeWhisperer suggests:
import boto3
from boto3.dynamodb.conditions import Key
def get_user_orders(user_id, table_name):
"""Get last 10 orders for a user"""
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(table_name)
response = table.query(
KeyConditionExpression=Key('user_id').eq(user_id),
ScanIndexForward=False, # Descending order
Limit=10
)
return response['Items']
Example 3: API Error Handling
# Add try-except block for API Gateway Lambda function with proper error responses
# CodeWhisperer suggests:
from typing import Dict, Any
import json
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
try:
# Your business logic here
result = process_request(event)
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json',
'Access-Control-Allow-Origin': '*'
},
'body': json.dumps(result)
}
except ValueError as e:
return {
'statusCode': 400,
'body': json.dumps({
'error': 'Bad Request',
'message': str(e)
})
}
except KeyError as e:
return {
'statusCode': 400,
'body': json.dumps({
'error': 'Missing Required Field',
'message': f'Missing field: {str(e)}'
})
}
except Exception as e:
print(f"Unexpected error: {str(e)}")
return {
'statusCode': 500,
'body': json.dumps({
'error': 'Internal Server Error',
'message': 'An unexpected error occurred'
})
}
CodeWhisperer vs. GitHub Copilot
| Feature | CodeWhisperer | GitHub Copilot |
|---|---|---|
| Price | Free (Individual) | $10/month |
| AWS Integration | ⭐⭐⭐⭐⭐ Excellent | ⭐⭐⭐ Good |
| General Code | ⭐⭐⭐⭐ Very Good | ⭐⭐⭐⭐⭐ Excellent |
| Security Scanning | ✅ Built-in | ❌ Separate tool |
| Reference Tracking | ✅ Yes | ❌ No |
| IDE Support | VS Code, JetBrains, Cloud9 | VS Code, JetBrains, Neovim |
| Languages | 15+ | 40+ |
My Take: If you're primarily working with AWS, CodeWhisperer is fantastic and free. For general development, Copilot has slightly better suggestions.
Security Scanning
CodeWhisperer includes built-in security scanning!
# In VS Code
# Right-click in editor → "Amazon Q: Security Scan"
# Or run from command palette
# Scans for:
- SQL injection
- Path traversal
- Hardcoded credentials
- Insecure cryptography
- Cross-site scripting (XSS)
- And 10+ more categories
Example Security Detection
# ❌ CodeWhisperer will flag this
password = "hardcoded_password_123" # Security issue detected!
# ✅ Better approach suggested
import os
password = os.environ.get('DB_PASSWORD')
Best Practices
1. Write Descriptive Comments
CodeWhisperer works best with clear, specific comments.
# ❌ Vague
# Save data
# ✅ Specific
# Save user data to DynamoDB table with error handling and retry logic
2. Accept Suggestions Selectively
Don't blindly accept everything! Review each suggestion:
# CodeWhisperer might suggest:
dynamodb = boto3.resource('dynamodb') # Inside function
# But you should do:
dynamodb = boto3.resource('dynamodb') # Outside, for connection reuse
3. Use It for Boilerplate
CodeWhisperer excels at repetitive code:
# Type: "Add CloudWatch logging for"
# It generates the entire logging setup
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
logger.info(f"Received event: {json.dumps(event)}")
# ...
4. Leverage AWS Patterns
CodeWhisperer knows AWS patterns well:
# Type: "Create S3 presigned URL"
# It generates the complete, correct implementation
import boto3
from botocore.exceptions import ClientError
def create_presigned_url(bucket_name, object_name, expiration=3600):
s3_client = boto3.client('s3')
try:
response = s3_client.generate_presigned_url(
'get_object',
Params={'Bucket': bucket_name, 'Key': object_name},
ExpiresIn=expiration
)
except ClientError as e:
logging.error(e)
return None
return response
5. Reference Tracking
CodeWhisperer tells you if suggestions match public code:
# When you see a reference notification:
# - Review the referenced code
# - Check the license
# - Decide if you want to use it
Real-World Productivity Gains
After 3 months using CodeWhisperer:
- 40% faster at writing AWS SDK code
- Fewer docs lookups - Correct patterns suggested
- Better error handling - Comprehensive try-catch blocks
- Consistent code style - Suggestions follow patterns
- Less context switching - Stay in flow state
Limitations and Gotchas
1. Not Always Perfect
# Sometimes suggests outdated patterns
# Always verify against current AWS docs
2. Context Window
CodeWhisperer sees limited context (current file mostly). For complex, multi-file projects, it might miss dependencies.
3. Over-Reliance Risk
Don't stop learning! Use CodeWhisperer as a tool, not a crutch.
4. Privacy Considerations
For organizational use:
- Code snippets are NOT stored by AWS (Individual tier)
- Professional tier has admin controls
- Read the privacy policy for your use case
Advanced Tips
1. Function Signatures Drive Suggestions
def process_sqs_messages(queue_url: str, max_messages: int = 10) -> List[Dict]:
# CodeWhisperer sees the signature and suggests appropriate implementation
# Type hints help it understand what you want!
2. Multiline Comments for Complex Logic
"""
Function to:
1. Fetch user data from DynamoDB
2. Enrich with data from external API
3. Cache in ElastiCache
4. Return formatted response
Includes error handling and retry logic
"""
# CodeWhisperer will suggest the entire implementation!
3. Use Examples in Comments
# Parse date string like "2023-06-14T10:30:00Z" to datetime object
# CodeWhisperer: Better suggestions with examples
Integration with CDK
CodeWhisperer knows AWS CDK patterns:
# Type: "Create Lambda function with DynamoDB table"
from aws_cdk import (
Stack,
aws_lambda as lambda_,
aws_dynamodb as dynamodb,
)
class MyStack(Stack):
def __init__(self, scope, id, **kwargs):
super().__init__(scope, id, **kwargs)
# CodeWhisperer suggests complete, correct CDK code
table = dynamodb.Table(
self, "MyTable",
partition_key=dynamodb.Attribute(
name="id",
type=dynamodb.AttributeType.STRING
),
billing_mode=dynamodb.BillingMode.PAY_PER_REQUEST
)
function = lambda_.Function(
self, "MyFunction",
runtime=lambda_.Runtime.PYTHON_3_9,
handler="index.handler",
code=lambda_.Code.from_asset("lambda"),
environment={
"TABLE_NAME": table.table_name
}
)
table.grant_read_write_data(function)
The Future of AI-Assisted Coding
AI coding assistants like CodeWhisperer are here to stay. They're not replacing developers—they're making us more productive.
My prediction: In 2-3 years, NOT using an AI assistant will be like refusing to use an IDE today.
Getting Started Checklist
- Install AWS Toolkit in your IDE
- Set up AWS Builder ID (free)
- Try it on a simple AWS Lambda project
- Run security scan on existing code
- Configure reference tracking preferences
- Experiment with comment-driven development
- Share findings with your team
Conclusion
AWS CodeWhisperer is a game-changer for AWS developers. It's:
- Free for individual developers
- AWS-optimized with great SDK knowledge
- Secure with built-in security scanning
- Transparent with reference tracking
Try it for a week. You won't want to go back.