DEV Community: Andre Luiz Rosa

Kiro with MCP for GitHub Integration, Docs, Diagrams and AWS Recommendations

Andre Luiz Rosa — Sat, 15 Nov 2025 23:14:06 +0000

How I Used Kiro + MCP to Document, Analyze, Improve and Visualize My AWS Linktree-Style Project

As an AWS Community Builder, I love experimenting with new developer workflows that combine automation, cloud architecture and AI tooling. This article describes how I used Kiro equipped with Model Context Protocol (MCP) servers to automatically analyze, document, diagram, audit and improve a real production project I run on AWS.

My Personal Project: A Fully Serverless "Linktree-Style" Website on AWS

Before diving into MCP, here’s the context.

I maintain a personal production project:

a Linktree-style website built entirely by me, deployed on AWS with:

S3 (static hosting, private bucket)
CloudFront (global delivery)
OAC (Origin Access Control)
CloudFront Functions (routing logic)
Route 53 (DNS and ALIAS records)
ACM Certificate (TLS)
GitHub Actions CI/CD
Terraform IaC (complete infrastructure automation)

This project has grown over time, and I wanted a faster — and smarter — way to:

Understand and document the system
Validate architecture decisions
Receive AWS best-practice recommendations
Generate diagrams using official AWS icons
Improve Terraform (security, cost and performance)
Inspect GitHub workflows and suggest enhancements

That’s when Kiro + MCP changed everything.

What Kiro + MCP Did for This Project

After installing five MCP servers, Kiro became a full cloud architecture assistant.

Here is exactly what it did:

1. Generated a complete Spec File

Kiro analyzed my GitHub repo, Terraform code, static files and folder structure.

Then it produced a clear, structured Spec File describing:

System purpose
AWS services used
CI/CD workflow
Deployment strategy
Security posture
Future improvements

This Spec became a “living blueprint” for the project.

2. Created a full AWS architecture diagram (Draw.io) by itself

Using the diagram MCP, Kiro generated a .drawio file with:

Official AWS icons (mxgraph.aws4)
S3, CloudFront, Route 53, IAM, OAC
Data flows with arrow labels
Component descriptions
Legend and grouping

The diagram opens perfectly in app.diagrams.net.

3. Produced complete documentation using AWS official MCPs

Using:

awslabs.aws-documentation-mcp-server
awslabs.core-mcp-server
mcp-server-fetch
github MCP
diagram-ai MCP

Kiro:

Looked up AWS best practices
Compared my architecture to AWS recommendations
Generated docs in clear, well-structured English
Validated my CloudFront, S3 and Route 53 setup
Suggested improvements using AWS Well-Architected

All with citations and references to AWS documentation pages.

4. Identified improvements and generated new Spec Files to implement them

Examples Kiro suggested (and generated code/specs for):

Security

Add AWS WAF to CloudFront
Enforce TLS 1.3
Ensure S3 bucket has encryption + private access
IAM improvements for GitHub OIDC

Logging

Enable CloudFront logging
Optimize TTLs
Split long-cache and short-cache assets (I implemented this)

Performance

Gzip/Brotli checks
Image resizing recommendations
Use CloudFront Functions instead of Lambda@Edge when possible

Kiro even generated Terraform snippets to apply each change.

My MCP Config (Workspace)

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ],
      "env": {
        "PYTHONIOENCODING": "utf-8",
        "UV_PYTHON": "python3.12",
        "UV_NO_LAUNCH": "1"
      },
      "disabled": false,
      "autoApprove": [
        "*",
        "fetch"
      ]
    },
    "aws-docs": {
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.aws-documentation-mcp-server@latest",
        "awslabs.aws-documentation-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "AWS_DOCUMENTATION_PARTITION": "aws",
        "PYTHONIOENCODING": "utf-8",
        "UV_PYTHON": "python3.12",
        "UV_NO_LAUNCH": "1"
      },
      "disabled": false,
      "autoApprove": [
        "search_documentation"
      ]
    },
    "awslabs.core-mcp-server": {
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "PYTHONIOENCODING": "utf-8",
        "UV_PYTHON": "python3.12",
        "UV_NO_LAUNCH": "1"
      },
      "disabled": false
    },
    "github": {
      "command": "C:\\Program Files\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "*",
        "search_repositories",
        "list_commits"
      ]
    },
    "diagram-ai": {
      "command": "<!-- replace-here-->
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7nko510nmh5rk0xyn3b3.png)\\python.exe",
      "args": [
        "-m",
        "src.application.mcp.server_modular"
      ],
      "env": {
        "DIAGRAM_OUTPUT_DIR": "<!-- replace-here-->\\diagrams",
        "PYTHONIOENCODING": "utf-8"
      },
      "disabled": false,
      "autoApprove": ["*"]
    }
  }
}

AWS WAF Example (from the recommendations)


hcl
resource "aws_wafv2_web_acl" "site" {
  provider = aws.us_east_1
  name     = "site-waf"
  scope    = "CLOUDFRONT"

  rule {
    name     = "AWS-AWSManagedRulesCommonRuleSet"
    priority = 1
    override_action { none {} }

    statement {
      managed_rule_group_statement {
        vendor_name = "AWS"
        name        = "AWSManagedRulesCommonRuleSet"
      }
    }
    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "common-rules"
      sampled_requests_enabled   = true
    }
  }
}

Kiro – Comparison with Other Competitors for Better Understanding (Part 3)

Andre Luiz Rosa — Sat, 09 Aug 2025 19:51:05 +0000

For many, comparing a new technology with an existing one helps bring more clarity.

Below is a comparison between Kiro and Cursor to highlight their differences and similarities.

Kiro vs Cursor

1. Context

1.1. Growing interest in AI developer tools

1.2. Kiro recently launched with buzz around its performance

1.3. Cursor has gained popularity as a VS Code alternative with AI capabilities

2. Kiro

2.1. Description

2.1.1. AI coding assistant aimed at entire codebase understanding

2.1.2. Developed by former DeepMind engineers

2.2. Features

2.2.1. Entire-repo understanding

2.2.2. Fast semantic search

2.2.3. Conversational UI with history awareness

2.3. Technology

2.3.1. Runs in the cloud

2.3.2. Deep codebase indexing and retrieval

2.4. Strengths

2.4.1. Higher context memory

2.4.2. Better at navigating large projects

2.4.3. Context-aware AI conversations

2.5. Limitations

2.5.1. Not open-source

2.5.2. Potential lock-in to Kiro's ecosystem

3. Cursor

3.1. Description

3.1.1. AI-powered coding environment

3.1.2. Built on VS Code with built-in AI assistant

3.2. Features

3.2.1. Inline AI suggestions

3.2.2. Commands via natural language

3.2.3. Full IDE functionality

3.3. Strengths

3.3.1. Strong developer community

3.3.2. Integration with GitHub

3.3.3. Familiar VS Code UI

3.4. Limitations

3.4.1. Local compute dependent

3.4.2. Limited context-awareness compared to full-codebase tools

4. Industry Implications

4.1. Shift towards semantic-aware dev tools

4.2. AI agents becoming part of dev workflows

4.3. Market fragmentation: IDEs vs AI-native tools

5. Comparison

5.1. User Experience

5.1.1. Cursor = lightweight, editor-based

5.1.2. Kiro = heavy-duty, cloud-powered experience

5.2. Performance

5.2.1. Kiro excels in larger codebases

5.2.2. Cursor suitable for quick AI assistance in code

5.3. Customization

5.3.1. Cursor allows more plugin/extensions (VS Code)

5.4. Deployment

5.4.1. Cursor = local

5.4.2. Kiro = cloud-hosted

Who Wins?

Depends on use case:

Solo devs/small projects → Cursor
Teams/large repos → Kiro

Tradeoffs:

Cursor = flexibility + familiarity
Kiro = power + scalability

Kiro – Coding Experience Broken Down into Topics (Part 2)

Andre Luiz Rosa — Sat, 09 Aug 2025 19:48:14 +0000

For developers, nothing beats hands-on experience. So here’s a mind map showing what an author did when specifying requirements — and what they found as a result.

Kiro's Hands-On Experience

1. Scenario 1: Return Type Clarification

1.1. Author's Prompt

1.1.1. "What's the return type of this function?"

1.2. Expected

1.2.1. Just the return type

1.3. What Kiro Did

1.3.1. Gave return type

1.3.2. Explained type origin

1.3.3. Traced it to a type in another file

1.3.4. Linked explanation to the imported symbol

1.4. Value Add

1.4.1. Saved developer from digging across files

1.4.2. Demonstrated codebase awareness

2. Scenario 2: Error in Type Usage

2.1. Author's Prompt

2.1.1. Asked Kiro to explain a type mismatch

2.2. Expected

2.2.1. Just an explanation of the error

2.3. What Kiro Did

2.3.1. Identified root cause

2.3.2. Suggested code correction

2.3.3. Provided reasoning for suggestion

2.3.4. Highlighted implication on other modules

2.4. Value Add

2.4.1. Demonstrated static analysis-like capabilities

2.4.2. Reduced debugging time

3. Scenario 3: Custom Hook Navigation

3.1. Author's Prompt

3.1.1. "What does this hook do?"

3.2. Expected

3.2.1. Surface-level summary

3.3. What Kiro Did

3.3.1. Explained the hook's purpose

3.3.2. Followed dependencies used in the hook

3.3.3. Described each of the sub-functions involved

3.3.4. Provided insight into context providers

3.4. Value Add

3.4.1. Deep dive into React architecture

3.4.2. Reconstructed mental model for the developer

4. Scenario 4: Infrastructure Question

4.1. Author's Prompt

4.1.1. "How does this app get deployed?"

4.2. Expected

4.2.1. High-level steps or CI/CD info

4.3. What Kiro Did

4.3.1. Located deployment scripts

4.3.2. Parsed GitHub Actions YAML

4.3.3. Explained Docker setup

4.3.4. Described interaction with AWS

4.4. Value Add

4.4.1. Unified frontend, infra, and DevOps understanding

4.4.2. Helped map full deployment path

5. Scenario 5: Module Refactor Help

5.1. Author's Prompt

5.1.1. Requested help renaming and refactoring a module

5.2. Expected

5.2.1. Just rename functions or variables

5.3. What Kiro Did

5.3.1. Suggested file restructuring

5.3.2. Identified tight coupling

5.3.3. Proposed more modular architecture

5.3.4. Explained pros/cons of the new structure

5.4. Value Add

5.4.1. Functioned like a junior architect

5.4.2. Encouraged long-term maintainability

6. Scenario 6: Missing Tests

6.1. Author's Prompt

6.1.1. "Are there any tests for this component?"

6.2. Expected

6.2.1. Yes/No answer or test file location

6.3. What Kiro Did

6.3.1. Analyzed nearby test files

6.3.2. Pointed out lack of direct coverage

6.3.3. Suggested what should be tested

6.3.4. Offered Jest code snippet examples

6.4. Value Add

6.4.1. Boosted test coverage awareness

6.4.2. Jumpstarted test writing

7. Summary

7.1. Pattern

7.1.1. Kiro exceeds intent of prompt

7.1.2. Anticipates developer needs

7.1.3. Connects dots across files and domains

7.2. Implication

7.2.1. More than a tool — feels like a thinking collaborator

7.3. Strength

7.3.1. Context-rich AI understanding

7.3.2. Full-project scope awareness

8. Overview

8.1. Lets see Kiro with a real-world codebase

8.2. Main observation: Kiro often exceeds what is asked

8.3. Highlights potential as a proactive AI coding assistant

Read the continuation in Part 3

Kiro – The New Agentic IDE That Thinks with You, Featuring Great Mind Maps (Part 1)

Andre Luiz Rosa — Mon, 04 Aug 2025 12:29:38 +0000

A lot of people grasp new concepts more easily when they’re presented visually—through diagrams or infographics like mind maps. That’s why I’ve decided to share my impressions of Kiro using a few of them.

Let’s start with this mind map, which gives a high-level overview of Kiro’s purpose, core features and comparisons:

Kiro the New Agentic IDE

1. Context

1.1. Kiro is a cloud-based AI IDE

1.2. Focus on boosting developer productivity

1.3. Targets large codebases

2. Features Tested

2.1. Semantic Code Search

2.1.1. Finds functions/types based on meaning

2.1.2. More effective than traditional search

2.2. Natural Language Q&A

2.2.1. Kiro gave an accurate answer with file reference

2.2.2. How is this API used in the frontend?

2.3. Conversational Memory

2.3.1. Keeps session history

2.3.2. Useful for following reasoning over time

2.4. Code Navigation

2.4.1. Auto follows references

2.4.2. Works like a guided walkthrough of the codebase

3. Limitations

3.1. Limited Debugging Support

3.1.1. No breakpoints or live debugging tools

3.1.2. Cannot fully replace VS Code or JetBrains yet

4. First Impressions

4.1. Clean, intuitive UI

4.2. GitHub login integration

4.3. Quick onboarding experience

5. Final Thoughts

5.1. Highly promising for developers

5.2. Complements existing IDEs well

5.3. Represents future direction of AI-assisted development

6. Ideal Use Cases

6.1. Onboarding to large codebases

6.2. Understanding legacy systems

6.3. Code reviews of complex logic

6.4. Exploring unfamiliar repositories

7. Strengths

7.1. Semantic Understanding

7.1.1. Answers based on deeper code behavior

7.1.2. Goes beyond string matching

7.2. Handles Large Projects Well

7.2.1. Efficient indexing

7.2.2. Fast performance even in monorepos

7.3. Low Friction

7.3.1. No installation needed

7.3.2. Ready to use immediately

Read the continuation in Part 2

Video Generation using BedRock [Part 1] Amazon Nova Canvas, Lambda and S3

Andre Luiz Rosa — Sat, 14 Jun 2025 19:47:25 +0000

🌟 Hello! I’m André, a Staff Software Engineer and proud member of the AWS Community Builders program. With 9 AWS certifications earned along my journey, I’m constantly pushing the boundaries of what’s possible in the cloud. I’m passionate about designing scalable architectures, experimenting with emerging technologies like Generative AI, and giving back to the tech community by sharing what I learn. Excited to connect with fellow builders and innovators as we shape the future of cloud computing! 🚀

Introduction

In this article, we’ll explore how you can build your own AI-powered video generation workflow using Amazon Bedrock, AWS Lambda, AWS Cloudwatch and Amazon S3. We'll leverage Amazon Nova Reels as the foundation model to generate custom videos based on text prompts provided by users.

Initial Approach adopted

This solution follows an asynchronous architecture: the first Lambda function receives the prompt and triggers the video generation process in Amazon Bedrock. Once the video is created and saved automatically in an S3 bucket, an S3 Event Notification triggers a second Lambda function that generates a pre-signed URL on AWS Cloudwatch for enabling access to the video.

Target Audience

This guide is ideal for AWS Community Builders, IT professionals, and Generative AI enthusiasts who want to integrate AI-driven video generation into real-world serverless applications.

Bedrock Prerequisites

Accessing Amazon Nova Foundation Model via Amazon Bedrock
Before starting your project, make sure you complete the following steps:

AWS Account Setup:

Have an active AWS Account with billing enabled.
Ensure your IAM user or role has the necessary Bedrock service permissions, such as:

bedrock:InvokeModel bedrock:ListFoundationModels

Step 1: Enable Amazon Bedrock in Your AWS Account:

Log in to the AWS Management Console.
Navigate to the Amazon Bedrock service.
Make sure you are in a supported AWS region, like us-east-1.

Step 2: Request Access to Amazon Nova Foundation Model:

In the Bedrock Console, go to “Model access”.
Under “Manage model access”, locate Amazon Nova Foundation Model.
Click “Request access” for the Nova model if you don’t already have it.
Wait for AWS approval. This process can take from a few minutes to several hours, depending on your AWS account and region.

Step 3: Gather Model API Details:
Go to the “Foundation models” section in the Bedrock Console (left-hand menu).

First lambda - Start video creation process

Code explaned below

Importing Required Libraries and Initializing Parameters

import json          # For returning API responses in JSON format
import boto3          # AWS SDK for Python (to call Bedrock)
import random         # To generate a random seed for output variability

def lambda_handler(event, context):
    # Initialize Bedrock client in the desired AWS region
    bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")

    # Get the input prompt from the event (or use default)
    prompt = event.get("prompt", "Sample video")

    # Generate a random seed to ensure unique output per request
    seed = random.randint(0, 2_147_483_646)

Triggering Asynchronous Video Generation

response = bedrock.start_async_invoke(
    modelId="amazon.nova-reel-v1:0",
    modelInput={
        "taskType": "TEXT_VIDEO",
        "textToVideoParams": {"text": prompt},
        "videoGenerationConfig": {
            "fps": 24,
            "durationSeconds": 6,
            "dimension": "1280x720",
            "seed": seed
        }
    },
    outputDataConfig={"s3OutputDataConfig": {"BUCKETNAME/outputs/"}}
)

This is the heart of the Lambda function. We are calling the Bedrock API's start_async_invoke method, which is used for models that run *asynchronously *(like video generation with Nova Reels).

    return {
        "statusCode": 202,
        "body": json.dumps({"invocationArn": response["invocationArn"]}),
    }

Finally, the Lambda returns a 202 Accepted HTTP status code, along with the invocationArn, which acts as the Job ID for tracking the status of the asynchronous generation process.

Second lambda - Post processing event

Code explaned below

import boto3
import json

s3 = boto3.client("s3")  # S3 client for generating pre-signed URLs

def lambda_handler(event, context):
    print(json.dumps(event))  # Log the incoming S3 event payload

    for record in event['Records']:
        bucket = record['s3']['bucket']['name']  # Bucket name where the video was saved
        key = record['s3']['object']['key']      # Object key (file path) of the uploaded video

        # Generate a pre-signed URL valid for 1 hour
        presigned_url = s3.generate_presigned_url(
            ClientMethod='get_object',
            Params={'Bucket': bucket, 'Key': key},
            ExpiresIn=3600
        )

        print(f"Video URL: {presigned_url}")  # Log the generated link (you can replace this with SNS, DynamoDB, etc.)

    return {
        "statusCode": 200,
        "body": json.dumps({"message": "Processed"})
    }

Calling the first lambda

Getting the video pre-signedUrl after de S3 event calls the second lambda

AI Generated video from your application

And that’s a wrap!

Thank you for taking the time to read through this guide. I hope it brought you clarity and practical knowledge to help you on your cloud and AI journey. I’m passionate about making technical topics more accessible, and there’s plenty more content coming soon. Stay curious, keep experimenting, and let’s continue building great things together!