# Supercharging Developer Workflow with Amazon Q Developer

Vikash Agrawal · Linda Haviv, AWS

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/utxVvGJ4bcg-supercharging-developer-workflow-amazon-q) · [Video](https://www.youtube.com/watch?v=utxVvGJ4bcg)

## Supercharging Developer Workflow with Amazon Q Developer

A Python game moves from a CLI prompt to tests, documentation, pull-request review, and a Lambda failure that brings infrastructure back into planning.

Basic familiarity with Python, HTTP APIs, unit tests, and pull requests will help you follow the workflow.

### Where does AI fit in the development cycle?

[0:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=17s)

How do you incorporate generative AI into the software development life cycle? That is the recurring engineering question Vikash Agrawal starts with. [**Amazon Q Developer**](https://aws.amazon.com/q/developer/) provides the assistant for this walkthrough, but the workflow begins with the familiar sequence of decisions that turns requirements into software customers can use.

Planning gathers requirements and product feedback. Creation turns those requirements into an application. Testing checks it through end-to-end, integration, and penetration tests. Deployment then leads into maintenance and modernization, with customer feedback starting the cycle again. **Generating code addresses only one part of that loop.**

![Slide showing five stages linked in a cycle: Plan, Create, Test and secure, Operate, and Maintain and modernize.](https://ai.engineer/api/talk-essay-media/569e4681e9b785023fe7fa397fd097e3765e132aa8203360cf3aa53cbe73e7fe)

The software development lifecycle connects planning, creation, testing and security, operations, and maintenance.

Linda introduces Q through the IDE, terminal, and GitHub integration. She opens the product’s free getting-started flow, shows Visual Studio Code, and chooses the CLI as a lightweight place to begin. IDE and CLI use do not require an AWS account in the demonstrated setup; that does not mean anonymous access. The [authentication FAQ](https://aws.amazon.com/q/developer/faqs/) distinguishes IDE sign-in through Builder ID or IAM Identity Center from AWS console access, which needs its own login and permissions. In the CLI, a developer can discuss a plan or move directly into implementation after planning elsewhere.

### Turn the 2048 rules into a build plan

[2:14](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=134s)

The application is 2048: merge two equal tiles to create a tile with twice the value. Two 2s become 4, two 4s become 8, and two 8s become 16, working toward a 2048 tile. This gives the assistant a recognizable game with concrete rules to implement.

Linda launches the assistant by entering `q`. Natural-language chat is available immediately for ideation; `/help` exposes commands, MCP options, and usage tips. The commands here follow the recording: AWS’s [document history](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/doc-history.html) records the later replacement of IDE agents such as `/test`, `/dev`, and `/doc` with agentic chat on October 21, 2025, followed by Q CLI becoming Kiro CLI on November 17, 2025.

The request becomes specific through a short exchange: build the game in Python, use [FastAPI](https://fastapi.tiangolo.com/tutorial/response-model/), and manage the project with [Poetry](https://python-poetry.org/docs/). Q responds with a plan before executing its steps. At the permission prompt, Linda can press `Y` and Enter to accept an individual step, or choose `T` to trust execution. The visible pause separates a proposed operation from permission to perform it.

![Terminal showing a five-step 2048 build plan, a project initialization command, and a permission prompt with yes, no, and trust choices.](https://ai.engineer/api/talk-essay-media/60985b3802baf2962cd4fd7e289a2a06888065f52e131168d774babfca99188b)

Amazon Q presents a build plan and requests permission to run the first shell command.

For the demonstration, the presenters choose trust and let execution proceed. Linda explicitly recommends reviewing generated code for production use. As Q runs, the terminal also displays how long each step takes, making the build’s progress visible.

### Correct the workspace and inspect the scaffold

[4:01](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=241s)

While Q generates the game, Linda notices that it is creating the project in her current folder rather than her development folder. She asks it to move the project, then confirms that it appears in the intended location. The correction happens within the same conversation: an omitted workspace requirement becomes another operation for the assistant.

Vikash inspects the generated Python and points out a FastAPI response model and POST APIs. Those are useful structural details to review: the response model declares the shape returned to clients, while POST endpoints provide places to handle game actions. Linda then suggests opening the folder in an IDE to inspect the project more comfortably. Vikash names VS Code, IntelliJ, and Eclipse as environments his team uses.

The scaffold also includes a README. Q finishes by summarizing the project structure, confirming its location, and explaining how to run it. The result is an application scaffold with an entry point for the next developer—not just a stream of generated source code.

### Test state transitions, then repair an error

[5:26](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=326s)

Vikash rejects the initial scaffold as production ready and moves into the IDE to add unit tests. Invoking `/test` starts an agent that examines the code and generates tests. He specifically calls out its attention to **state management**, an important concern for a game whose behavior depends on changes to the board.

A small Python example makes that testing concern concrete. For a single merge, the test should check the resulting value and the state that remains, rather than merely checking that a function returned successfully. For two equal tiles:

```python
def merge_pair(tiles: list[int]) -> list[int]:
    if len(tiles) != 2 or tiles[0] != tiles[1]:
        return tiles.copy()
    return [tiles[0] * 2]


def test_merge_pair() -> None:
    original = [2, 2]
    assert merge_pair(original) == [4]
    assert original == [2, 2]
    assert merge_pair([2, 4]) == [2, 4]
```

Vikash considers the generated tests substantial, particularly their treatment of state, but supplies no coverage figure or detailed test report.

He next describes `/dev`, which uses project context for feature development, and turns to a repair request. He asks Q to fix an error and supplies the error message. Q analyzes the codebase and proposes a change; Vikash applies it. The sequence matters: the error provides diagnostic context, the assistant produces a patch, and the developer decides to incorporate it.

### Refresh documentation after the code changes

[6:55](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=415s)

After applying the fix, Vikash reports a working game with unit tests. Before raising a pull request, he invokes `/doc` and asks for a README. Although the scaffold already included one, the code and tests have changed, so the documentation agent now has a more developed project to describe. It reads source files and summarizes the codebase.

The run instructions are substantially the same as before. The more useful additions are API endpoint examples, troubleshooting guidance, and a data-flow diagram explaining how state is managed. The IDE shows the README as a proposed diff with review controls: generating documentation makes it available for inspection, rather than automatically establishing that every explanation is correct.

![VS Code displaying a green README diff with Troubleshooting and Data Flow sections, alongside Amazon Q's documentation result and review controls.](https://ai.engineer/api/talk-essay-media/ab172da9819649923374d6147ab27071030e047c0420c9cac727f5b35e96251f)

The generated README includes troubleshooting guidance and a text-based data flow diagram.

### Use an issue as the development request

[7:49](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=469s)

Linda next shows an alternative development surface: [Q’s GitHub integration](https://aws.amazon.com/about-aws/whats-new/2025/05/amazon-q-developer-integration-github-preview-available/). Here, the issue and pull request carry the request and feedback that previously lived in a CLI or IDE conversation. The workflow stays inside GitHub:

1. Install Q Developer through GitHub Marketplace and select all repositories or a smaller set.
2. Open an existing issue or create a new one, then apply the development-agent label.
3. Let Q generate code from the issue and notify you when the pull request is ready.
4. Inspect the changed files, leave review comments, and request changes for another revision.

The walkthrough does not supply the exact label string.

Linda also describes automatic code scans and fixes within the pull request. The historical behavior needs a precise boundary: AWS’s document history specifies automatic reviews for new or reopened pull requests, so this should not be read as automatic rescanning after every subsequent commit. The demonstrated interaction is still familiar code review—inspect a proposed change, give feedback, and examine the revision.

### Investigate the gap between local and deployed behavior

[9:08](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=548s)

The next stage exposes the limits of a locally working application. Vikash reports using `/dev` in the IDE, in the background, to generate [AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) scripts and deploy the game. SAM provides the infrastructure definition and deployment tooling for the move to AWS Lambda. The deployed application, however, does not run correctly.

Vikash opens the AWS console, locates the deployed Lambda, and examines its CloudWatch logs. An import error gives him a starting point. He then begins an investigation with Q directly in the console, moving from application generation to evidence from the running environment.

The [operational investigation](https://aws.amazon.com/blogs/aws/investigate-and-remediate-operational-issues-with-amazon-q-developer/) examines the log group and associated resources, builds a topology, and produces a report with a proposed diagnosis. Resource relationships and graphs help organize the evidence that a developer would otherwise assemble through log searches and timestamp matching. Vikash emphasizes that this also helps with the reporting work around an incident.

The report gives him a route back to the application, but the recording does not establish the exact import failure, a corrective patch, or a successful redeployment. The demonstrated outcome is an investigation that informs the next repair, not a completed production recovery.

### Bring infrastructure and prompts into the initial plan

[10:47](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=647s)

Satisfied with the investigation report, Vikash closes it and revisits the original planning decision. **The path from application code to customers belongs in the initial requirements.** Infrastructure entered this build late, after the local game, tests, and documentation. Linda identifies the missing request: she could have asked Q CLI to generate infrastructure as code alongside the application.

That changes how the next session should begin. Before asking the assistant to build, ask how to plan a more robust application that follows the relevant production practices. Iterate on that plan before saving code, or generate an initial version and refine it. For a cloud deployment, include infrastructure as code in that iteration rather than treating deployment as a separate final task.

The developer remains responsible for planning and decisions while Q helps with repetitive work across environments. Linda places security scanning, monitoring, and observability within that responsibility: they help expose and mitigate issues after generation. Vikash extends planning to the prompts themselves, because the requirements and context given to models and agents shape the output they can produce.

For readers who want to try the workflow, Linda closes by pointing to free entry through the IDE, CLI, and GitHub in the demonstrated offering, along with the product’s getting-started page and updates. She invites follow-up questions in the video comments. The practical starting point is a small application whose entire life cycle you can inspect—including what happens when its first deployment fails.

## Resources

- [Amazon Q Developer](https://aws.amazon.com/q/developer/) — Product overview, editor installation links and current availability notices.
- [Amazon Q Developer's GitHub preview launch](https://aws.amazon.com/about-aws/whats-new/2025/05/amazon-q-developer-integration-github-preview-available/) — The May 2025 announcement explains issue-driven development, pull-request reviews and feedback inside GitHub.
- [Amazon Q Developer feature and command history](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/doc-history.html) — Dated changes explain the replacement of IDE slash-command agents and the transition from Q CLI to Kiro CLI.
- [FastAPI response models](https://fastapi.tiangolo.com/tutorial/response-model/) — Official tutorial for declaring API response models and return types.
- [Poetry documentation](https://python-poetry.org/docs/) — Installation and usage documentation for Python dependency management and packaging.
- [AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) — Overview of AWS SAM for defining and deploying serverless applications.
- [Operational investigations with CloudWatch](https://aws.amazon.com/blogs/aws/investigate-and-remediate-operational-issues-with-amazon-q-developer/) — AWS walkthrough of starting an investigation and using generated hypotheses to guide operational troubleshooting.

## Slides

### Software Development Life Cycle with Amazon Q Developer

Vikash Agrawal and Linda Haviv introduce how Amazon Q Developer can be used throughout the software development life cycle.

[0:04](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=4s) [Title slide introducing presenters Vikash Agrawal and Linda Haviv.](https://assets.ai.engineer/sites/aiecode2025/sha256/9bd263bc33c2b07b2afa81a3c7d351c8a5e00802d39d791bc92977d3d1c553f2.webp)

Software Development Life Cycle with
Amazon Q Developer

Vikash Agrawal
He/Him
Software Development Manager
Amazon

Linda Haviv
She/Her
Developer Advocate
Amazon

aws
© 2025, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Software Development Lifecycle

Teams plan, create, test and secure, operate, and maintain and modernize software, then repeat the cycle as feedback arrives.

[0:37](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=37s) [A cycle showing plan, create, test and secure, operate, and maintain and modernize.](https://assets.ai.engineer/sites/aiecode2025/sha256/39d35b0699d828113d984227d97dbc29af029a7acfb6fb8c1ee8ff73f5155158.webp)

Software Development Lifecycle (SDLC)

Plan
Create
Test and secure
Operate
Maintain and modernize

aws
© 2025, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Untangle and document complex code

Amazon Q Developer’s /doc feature generates and updates README files and data-flow diagrams. The page illustrates a README request ending in a completed readme.md.

[1:29](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=89s) [Amazon Q Developer page describing README generation and data-flow diagrams.](https://assets.ai.engineer/sites/aiecode2025/sha256/2891bbe166ee13f4e0035f548c9169a7b9f84b0e598b09a523e254fb2f141808.webp)

Untangle and document complex code

"/doc" helps generate and update README files, create data-flow diagrams, and keep your project fully documented, so you can onboard faster and focus on your code.

Type in @workspace to understand your entire project context at a glance – from auth flows to service dependencies. Ask anything about your entire project, code and get answers and even architecture diagrams.

[Embedded example]
• Processes supported file types including [illegible], md, html, json, jsonl, csv, and various image formats
• Interacts with S3 buckets and manages job processing
2. Prompt Management Lambda:
Thinking...
@workspace how are Lambda functions organized in this

[README example]
Chat
Generate a README for my repo
I’ll help you create a README file for your [illegible]. Let’s first explore your source files structu[illegible] understand what information should be in[illegible] in the README.
4 files read
Thinking...
readme.md
Complete

[Partially visible example]
AWS API logging disabled cdk (CWE-778)
Ensure that access logging is enabled by setting the access_log_setting for the API. This will allow operators to monitor [illegible]

Interface text:
Amazon Q
Products  Solutions  Pricing  Documentation  Learn  Partner Network  AWS Marketplace  Customer Enablement  Events  Explore More
Amazon Q Developer  Overview  Features  Pricing  FAQs  Documentation  Resources  Get started

### Get started with Amazon Q Developer

The presenter opens Get started for free to choose a command-line or IDE installation. She says neither requires an AWS account.

[1:42](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=102s) [Amazon Q Developer overview with a menu listing command-line and IDE options.](https://assets.ai.engineer/sites/aiecode2025/sha256/1282bf3bb8dfd96662ba245f2e015030261187c19a36fe9714bdd77fb8245c22.webp)

Amazon Q Developer: Your AI code assistant

Built to handle large projects, Amazon Q Developer works alongside you from idea to production code

Get started for free
See pricing plans

Command line
Visual Studio Code
JetBrains
Visual Studio
Eclipse (preview)

[illegible]lligently in your IDE

[illegible]tic coding experience that helps you accomplish your tasks
[illegible]reads and writes files locally, generates code diffs, and runs shell commands, while incorporating your feedback and sending real-time updates along the way.

Now available in VS C[illegible]

Interface text:
Amazon Q
Products
Solutions
Pricing
Documentation
Learn
Partner Network
AWS Marketplace
Customer Enablement
Events
Explore More

Amazon Q Developer
Overview
Features
Pricing
FAQs
Documentation
Resources
Get started

### Amazon Q command-line example

The Amazon Q CLI shows a chat prompt for an AWS-hosted app that reports whether it is raining in Seattle. The presenter describes the CLI as a place to plan or start coding.

[1:58](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=118s) [A terminal example shows Amazon Q chat and a prompt for a weather application.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea6d1b90c4ac1cca3d6ddfffe8a1f930b8be521441ae04cb29ccdb9004fa71ce.webp)

[[~/workspace/projects/is-it-raining-in-seattle]$ q chat

Hi, I'm Amazon Q. Ask me anything.

Things to try
• Fix the build failures in this project.
• List my s3 buckets in us-west-2.
• Write unit tests for my application.
• Help me understand my git status.

/tools    View and manage tools and permissions
/issue    Report an issue or make a feature request
/profile  (Beta) Manage profiles for the chat session
/context  (Beta) Manage context files for a profile
/compact  Summarize the conversation to free up context space
/help     Show the help dialogue
/quit     Quit the application

Use Ctrl(^) + j to provide multi-line prompts.

> I want to create a simple web application hosted on AWS. This web app should
just display is it raining in Seattle or

Interface text:
Amazon Q Developer
Overview
Features
Pricing
FAQs
Documentation
Resources
Get started
zsh

### 2048 game demonstration

A 2048 board shows 2 and 4 tiles at a score of 4. The presenter explains that merging equal tiles doubles their value, with the goal of reaching 2048.

[2:16](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=136s) [A 2048 game board with numbered tiles and a score of 4.](https://assets.ai.engineer/sites/aiecode2025/sha256/e7b3f64d6fc95fc3dbece19b436dca5003d5306deabe16fc90af20fd0cd558ce.webp)

New Game

Score: 4

2  2
4

   2

Interface text:
2048 Game
localhost:8000/src/frontend/
SDM
DevRel
CWL
AWS IDEs
Vancouver
Error
aws

### Amazon Q CLI welcome screen

The presenter starts Amazon Q with q and types /help to explore its commands. The welcome screen also shows how to resume the last conversation from the current directory.

[3:01](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=181s) [Amazon Q terminal welcome screen showing a conversation-resume tip and a typed help command.](https://assets.ai.engineer/sites/aiecode2025/sha256/947b68212c854421e8e4dfc4edd3cf92a69a6f9a80c44321beeeb4aac377e3dc.webp)

Amazon Q

Did you know?
You can resume the last conversation from your current directory b[illegible] launching with q chat --resume

/help all commands • ctrl + j new lines • ctrl + s fuzzy search

> /help

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24
➜ ~ q

### Building a 2048 game with Amazon Q CLI

The presenter asks Amazon Q for a 2048 game using FastAPI and Poetry. Q outlines the work and requests permission to initialize the project; the presenter types t to trust the tool for the session.

[3:25](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=205s) [Terminal help lists commands and tips above a partially typed request to build a 2048 game in Python.](https://assets.ai.engineer/sites/aiecode2025/sha256/b7a7ab6f01b6206875b693ab2de6200b5b1bbcf7dba12ece1a597a6c9ac49ae8.webp)

rm  Remove file(s) from context [--global]
clear  Clear all files from current context [--global]
hooks  View and manage context hooks
/usage  Show current session's context window usage
/load  Load conversation state from a JSON file
/save  Save conversation state to a JSON file

MCP:
You can now configure the Amazon Q CLI to use MCP servers.
Learn how: https://docs.aws.amazon.com/en_us/amazonq/latest/qdeveloper-u[illegible]d-line-mcp.html

Tips:
!{command}  Quickly execute a command in your current session
Ctrl(^) + j  Insert new-line to provide multi-line prompt. Alte[illegible]y, [Alt(⌥) + Enter(↵)]
Ctrl(^) + s  Fuzzy search commands and context files. Use Tab to select multiple items.
Change the keybind to ctrl+x with: q settings chat.skimCommandKey x (where x is any key)
chat.editMode  Set editing mode (vim or emacs) using: q settings chat.editMode vi/emacs

> i want to build a 2048 game in python using

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24

[3:38](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=218s) [Terminal lists steps for building a 2048 game and asks permission to initialize the project.](https://assets.ai.engineer/sites/aiecode2025/sha256/e14f8eaa9560277c75e1160b5cf238459f75e62c1ee802984bb91c0900b13b8c.webp)

I'll help you build a 2048 game in Python using FastAPI and Poetry. Let's break this down into steps:

1. Set up a Poetry project
2. Install FastAPI and other dependencies
3. Create the 2048 game logic
4. Build the FastAPI endpoints
5. Add a simple frontend to play the game

Let's start by setting up the project:

Using tool: execute_bash

I will run the following shell command:
mkdir -p 2048-game && cd 2048-game && poetry init -n

Purpose: Create a new directory for the project and initialize Poetry

Allow this action? Use 't' to trust (always allow) this tool for the session. [y/n/t]:

> t

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24

### 2048 game initialization

Amazon Q generates a 2048 game class with an empty board and two starting tiles. The presenter then asks to move the project to the development folder.

[4:07](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=247s) [Terminal shows a Python game class initializing the board, score, and two tiles.](https://assets.ai.engineer/sites/aiecode2025/sha256/a06de24a9bb1f16ccfb6edaff3ca4527d647b881d16f62f5a076f08fdee42bc0.webp)

Completed in 0.26s

Using tool: fs_write
Path: /Users/lhaviv/[illegible]048-game/app/game.py

1: import random
2: from typing import List, Tuple, Optional, Dict, Any
3:
4:
5: class Game2048:
6:     def __init__(self, size: int = 4):
7:         self.size = size
8:         self.score = 0
9:         self.board = [[0 for _ in range(size)] for _ in range(size)]
10:        self.game_over = False
11:        # Add two initial tiles
12:        self.add_random_tile()
13:        self.add_random_tile()

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24

### Project moved

Amazon Q reports moving the 2048 project into the development folder, then lists the application, frontend, and API endpoints as remaining work.

[4:29](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=269s) [Terminal reports that the project was moved to a development folder and lists remaining application and frontend tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/16e775e512fc8ae407aae46467f6b06129a4ee5cb1cf198cefdfb14a229ef7de.webp)

Completed in 0.27s

The 2048 game project has been successfully moved to your Development folder.
You can now find it at ~/Development/2048-game.

To continue working on the project, you can navigate to that directory:

bash
cd ~/Development/2048-game

The project structure is set up with Poetry for dependency management an[illegible] includes FastAPI, Uvicorn, and Jinja2 for building the web application. [illegible] started creating the game logic, but we still need to:

1. Complete the FastAPI application
2. Create the HTML templates and CSS for the frontend
3. Implement the game's API endpoints

Would you like me to continue setting up the rest of the project in the new location?

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24
>

### Building the 2048 game

Amazon Q creates the merged-tile animation and provides instructions for running the game. The presenters call it a good start and move on to adding unit tests.

[4:53](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=293s) [Terminal displays CSS keyframes and animation rules for merged tiles.](https://assets.ai.engineer/sites/aiecode2025/sha256/71210fcde955de43759ff839a03e57158f8c82a27f7e411b0610e45d3bc9d6f2.webp)

+ 264: @keyframes pop {
+ 265:     0% {
+ 266:         transform: scale(0.8);
+ 267:     }
+ 268:     50% {
+ 269:         transform: scale(1.1);
+ 270:     }
+ 271:     100% {
+ 272:         transform: scale(1);
+ 273:     }
+ 274: }
+ 275:
+ 276: .tile-merged {
+ 277:     z-index: 20;
+ 278:     animation: pop 200ms ease 100ms;
+ 279:     animation-fill-mode: backwards;
+ 280: }

Creating: /Users/lhaviv/Development/2048-game/app/static/css/style.css
Completed in 0.1s
Thinking...

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24

[5:24](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=324s) [A terminal lists startup instructions, game features, and the FastAPI backend and frontend roles.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d0dbf1d517465f435de11f3138f624c1b49b83fb29e8ce608ebc9dacd70dec3.webp)

3. Start the application:
    bash
    python main.py

4. Open your browser and go to http://localhost:8000

## Game Features
• Classic 2048 gameplay with arrow key controls
• Score tracking
• Game state management via API
• Responsive design
• New game and retry options

The game uses a client-server architecture where:
• The backend (FastAPI) handles game logic and state management
• The frontend (HTML/JS/CSS) provides the user interface

Would you like me to explain any specific part of the implementation in more detail?

Interface text:
lhaviv — q — q — zsh (qterm) ▸ qchat — 80×24
>

### Generating unit tests

The presenter invokes /test in the IDE. Amazon Q starts generating tests for the 2048 app’s new_game, make_move, and get_game_state methods.

[5:56](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=356s) [Amazon Q shows a unit test request and lists the game methods being tested while generation progresses.](https://assets.ai.engineer/sites/aiecode2025/sha256/81f5a806fc065c903f0ffb71df865ca9d8a2db328f3d22322a265c534b6da22d.webp)

class MoveRequest(BaseModel):
    direction: str
    game_id: str

@app.post("/game/new")
async def new_game() -> dict:
    """Start a new game and return the initial state."""
    game = Game2048()
    game_id = str(len(games))
    games[game_id] = game
    return {"game_id": game_id, "state": game.get_state()}

@app.post("/game/move")
async def make_move(move_request: MoveRequest) -> dict:
    """Make a move in the specified direction."""
    game_id = move_request.game_id
    if game_id not in games:
        raise HTTPException(status_code=404, detail="Game not found")

    game = games[game_id]
    try:
        moved = game.move(move_request.direction)
        return {"moved": moved, "state": game.get_state()}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

@app.get("/game/{game_id}")
async def get_game_state(game_id: str) -> dict:
    """Get the current state of a game."""
    if game_id not in games:
        raise HTTPException(status_code=404, detail="Game not found")
    return games[game_id].get_state()

Interface text:
Welcome to unit test generation. I can help you generate unit tests for your active file.

/test Generate unit tests for app.py

/test
Included in your Q Developer Agent subscription

I can generate unit tests for your active file.
After you select the functions or methods I should focus on, I will:
1. Generate unit tests
2. Place them into relevant test file
To learn more, check out our User Guide.

Sure. This may take a few minutes. I’ll share updates here as I work on this.
Generating unit tests for the following methods in app.py
new_game
make_move
get_game_state

Generating unit tests... 57%
Cancel
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

EXPLORER
OPEN EDITORS
app.py
 test_app.py
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md
OUTLINE
TIMELINE
APPLICATION BUILDER
CODE ISSUES
CHAT
Q - Test

### Reviewing generated unit tests

Amazon Q presents generated tests for review in a code diff. The tests cover game state, new-game responses and unique IDs; the presenter can accept or reject the proposed file.

[6:04](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=364s) [The editor displays generated test additions alongside Amazon Q's review panel with accept and reject controls.](https://assets.ai.engineer/sites/aiecode2025/sha256/b5ae972df6bc5354e781d5e0780b95360d78746949afc62f6f0de2a8544a432b.webp)

import os
import re
from unittest.mock import patch

import pytest
from fastapi.testclient import TestClient
from src.app.app import app

from fastapi import HTTPException
from src.app.app import app, Game2048
from src.app.app import app, MoveRequest
from src.app.app import app, MoveRequest, games
from src.app.app import app, games
from src.app.app import app, games, Game2048
from src.app.game import Game2048
import concurrent.futures

@pytest.fixture(scope="module")
def test_client():
    return TestClient(app)

def test_get_game_state_edge_case_large_game_id(test_client):
    """
    Test get_game_state with a very large game ID.
    """
    large_id = "9" * 1000  # A string of 1000 nines
    response = test_client.get(f"/game/{large_id}")
    assert response.status_code == 404
    assert response.json() == {"detail": "Game not found"}

Interface text:
EXPLORER
OPEN EDITORS
app.py  src/app
test_app.py (Generated by Amazon Q)
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md

CODE ISSUES
CHAT
Q - Test
I will:
1. Generate unit tests
2. Place them into relevant test file
To learn more, check out our User Guide.

Sure. This may take a few minutes. I'll share updates here as I work on this.
Generating unit tests for the following methods in app.py
new_game
make_move
get_game_state

Please see the unit tests generated below. Click “View diff” to review the changes in the code editor.
READY FOR REVIEW  1 file(s)
demo 1 file(s)
tests 1 file(s)
test_app.py
Accept
Reject
Please select an action to proceed (Accept or Reject)
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

[6:16](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=376s) [Amazon Q displays generated tests for new games and offers them for review.](https://assets.ai.engineer/sites/aiecode2025/sha256/c77c128e409a7f184a046c3692ddf683089026cc64323abdb24eaf5be3e6ace1.webp)

def test_new_game_memory_leak(test_c[illegible]
    """
    Test that creating many new game[illegible]
    """
    initial_game_count = len(games)
    for _ in range(1000):
        test_client.post("/game/new")

    assert len(games) == initial_game_count + 1000

def test_new_game_success(test_client):
    """
    Test that a new game is created successfully with the correct response format.
    """
    response = test_client.post("/game/new")
    assert response.status_code == 200
    data = response.json()
    assert "game_id" in data
    assert "state" in data
    assert isinstance(data["state"], dict)
    assert "board" in data["state"]
    assert "score" in data["state"]
    assert "game_over" in data["state"]

def test_new_game_unique_ids(test_client):
    """
    Test that multiple new games created have unique game IDs.
    """
    response1 = test_client.post("/game/new")
    response2 = test_client.post("/game/new")

    assert response1.json()["game_id"] != response2.json()["game_id"]

Interface text:
EXPLORER
OPEN EDITORS
app.py  src/app
test_app.py (Generated by Amazon Q)
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md

CODE ISSUES
CHAT
Q - Test
I will:
1. Generate unit tests
2. Place them into relevant test file
To learn more, check out our User Guide.

Sure. This may take a few minutes. I'll share updates here as I work on this.
Generating unit tests for the following methods in app.py
new_game
make_move
get_game_state

Please see the unit tests generated below. Click “View diff” to review the changes in the code editor.
READY FOR REVIEW  1 file(s)
demo 1 file(s)
tests 1 file(s)
test_app.py
Accept
Reject
Please select an action to proceed (Accept or Reject)
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

### Unit test results

After applying a fix, the presenter runs the game’s tests: all 24 pass, with two Pydantic deprecation warnings about dict and model_dump.

[6:59](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=419s) [A terminal shows 24 passing tests and two warnings.](https://assets.ai.engineer/sites/aiecode2025/sha256/678d8b3afce77a9283ab69d45f21e3a493236e3df7eb66d0e07f6012c15e9eb5.webp)

poe test
Poe => poetry run pytest tests

test ses[illegible]
platform darwin -- Python 3.11.9, pytest-8.3.2, pluggy-1.5.0
rootdir: /Users/vikasagr/workspace/demo
configfile: pyproject.toml
plugins: cov-5.0.0, anyio-4.4.0
collected 24 items

tests/test_app.py ........................ [100%]

warnings summary
tests/test_app.py::test_make_move_game_not_found
tests/test_app.py::test_make_move_valid_game
/Users/vikasagr/workspace/demo/.venv/lib/python3.11/site-packages/pydantic/main.py:1087: PydanticDeprecatedSince20: The `dict` method is deprecated; use `model_dump` instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.8/migration/
    warnings.warn('The `dict` method is deprecated; use `model_dump` instead.', category=PydanticDeprecatedSince20)

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
24 passed, 2 warnings in 1.01s

Interface text:
demo on main [$!] is 0.1.0 via 3.11.9 via demo took 2.3s
demo on main [$!] is 0.1.0 via 3.11.9 via demo took 2.1s
aws

### Create a README

Before raising a pull request, the presenter invokes Amazon Q Developer’s /doc agent and asks it to create a README for the demo project, now that it has code and unit tests.

[7:12](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=432s) [Amazon Q asks whether to create a README for the demo project.](https://assets.ai.engineer/sites/aiecode2025/sha256/4def225f0ffeaaa1f9018d4bc2dfcfac93c3e8aecf67472cf18b08b6bb265c54.webp)

app.py

class MoveRequest(BaseModel):
    game_id: str

@app.post("/game/new")
async def new_game():
    try:
        game = Game2048()
        game_id = str(uuid.uuid4())
        games[game_id] = game
        return {"game_id": game_id, "state": game.get_state()}
    except Exception as e:
        raise HTTPException(status_code=500, detail="Internal server error")

@app.post("/game/move")
async def make_move(move_request: MoveRequest) -> dict:
    """Make a move in the specified direction."""
    game_id = move_request.game_id
    if game_id not in games:
        raise HTTPException(status_code=404, detail="Game not found")

    game = games[game_id]
    try:
        moved = game.move(move_request.direction)
        return {"moved": moved, "state": game.get_state()}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

@app.get("/game/{game_id}")
async def get_game_state(game_id: str) -> dict:
    """Get the current state of a game."""
    if game_id not in games:
        raise HTTPException(status_code=404, detail="Game not found")
    return games[game_id].get_state()

Q - Doc
Welcome to doc generation!
I can help generate documentation for your code. To get started, choose what type of doc update you'd like to make.
Create a README
Create a README for this project?
demo
Yes | Change folder | Cancel
Choose an option to continue
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

Interface text:
EXPLORER
OPEN EDITORS
app.py  src/app
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md
CODE ISSUES
CHAT
OUTLINE
TIMELINE
APPLICATION BUILDER
AWS
Amazon Q
Python 3.11.9 ('venv': Poetry)

### Generate and preview a README

Amazon Q scans the project and generates a README with API examples, testing and troubleshooting guidance. The preview also diagrams how requests reach the game logic and how state is stored in memory.

[7:35](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=455s) [A generated README includes an API example, testing instructions, and troubleshooting notes.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e552bdc4c442008c1664a01a2a42dab636ff6eeb08952b88b6537e1381d385b.webp)

# 2048 Game API: A FastAPI Backend for t[illegible]
## Usage Instructions
### API Endpoints

3. Get game state:
```
GET /game/{game_id}
```
Response:
```json
{
  "board": [[2, 0, 2, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 2]],
  "score": 4,
  "game_over": false
}
```

### Testing
To run the test suite:
```
pytest
```

### Troubleshooting
1. Issue: API returns 404 for all requests
- Ensure the server is running and you're using the correct URL.
- Check if the `STAGE` environment variable is set correctly.
2. Issue: Unable to make moves
- Verify that you're sending a valid `game_id` and `direction` in the request body.
- Check if the game has ended (`game_over: true` in the state).

Interface text:
EXPLORER
OPEN EDITORS
app.py  src/app
README.md ↔ README.md
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md
OUTLINE
TIMELINE
APPLICATION BUILDER
CODE ISSUES
CHAT
Q - Doc
Create a README
Create a README for this project?
demo
Yes
Okay, I'm creating a README for your project. This may take a few minutes.
Scanning source files
Summarizing source files
Generating documentation
Documents ready 1 file(s)
Documentation 1 file(s)
README.md
I've created a README for your code. You can accept the changes to your files, or describe any additional changes you'd like me to make.
Accept
Make changes
Reject
Choose an option to continue
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

[7:48](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=468s) [VS Code displays a generated README alongside the Amazon Q documentation panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6e0bd25a8ed610325f6ec4f44b6e67d164257f530afd6dc49852644cf5b5556.webp)

Testing
To run the test suite:
pytest

Troubleshooting
1. Issue: API returns 404 for all requests
- Ensure the server is running and you're using the correct URL.
- Check if the STAGE environment variable is set correctly.
2. Issue: Unable to make moves
- Verify that you're sending a valid game_id and direction in the request body.
- Check if the game has ended (game_over: true in the state).
3. Issue: Unexpected game behavior
- Enable debug mode by setting STAGE=development in your environment.
- Check the server logs for detailed error messages.

For more detailed debugging:
- Set STAGE=development to enable verbose logging.
- Inspect the logs in stderr for trace-level information.

Data Flow
The 2048 Game API follows a straightforward request-response flow:
1. Client initiates a request (new game, move, or get state).
2. FastAPI routes the request to the appropriate endpoint handler.
3. The handler interacts with the Game2048 class to perform game operations.
4. The game state is updated and stored in memory.
5. The response is formatted and sent back to the client.

Client <-> FastAPI Router <-> Endpoint Handlers <-> Game2048 Class
  ^                                                     ^
  |                                                     |
  +---------------------Memory Storage------------------+

Note: The current implementation stores game states in memory, which may not be suitable for production environments with high concurrency or persistence requirements.

Interface text:
EXPLORER
OPEN EDITORS
app.py  src/app
README.md
Preview README.md
DEMO
.vscode
launch.json
certs
src
app
__init__.py
app.py
game.py
frontend
__init__.py
tests
__init__.py
test_app.py
.env.sample
.gitignore
.python-version
lefthook.yml
LICENSE
poetry.lock
poetry.toml
pyproject.toml
README.md
OUTLINE
TIMELINE
APPLICATION BUILDER
Yes
Okay, I'm creating a README for your project. This may take a few minutes.
Scanning source files
Summarizing source files
Generating documentation
Documents ready 1 file(s)
Documentation 1 file(s)
README.md
I've created a README for your code. You can accept the changes to your files, or describe any additional changes you'd like me to make.
Accept
Select one of the following...
Start a new documentation task
End session
Choose an option to continue
Amazon Q Developer uses generative AI. You may need to verify responses. See the AWS Responsible AI Policy.

### Generated GitHub login pull request

Amazon Q generates a pull request for GitHub login, with changes spanning OAuth, routing and the header. The presenter explains that reviewers can request further changes through PR comments.

[8:27](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=507s) [A GitHub pull request summarizes changes for an OAuth login flow.](https://assets.ai.engineer/sites/aiecode2025/sha256/0770ebe68011a4742c58f9fc399c5e02c69a3b9de07d776989067c13d452851b.webp)

Add GitHub login using direct OAuth2 flow #24

This pull request implements GitHub authentication functionality for the application. The key changes include:

1. Adding GitHub OAuth integration with a new authentication context and callback handling
2. Installing necessary dependencies (axios and react-router-dom)
3. Updating the header component to display login/logout buttons
4. Setting up routing infrastructure with React Router
5. Adding environment configuration for GitHub OAuth credentials

The changes enhance the user experience by replacing the placeholder authentication alert with a proper GitHub-based login system.

Interface text:
Open
amazon-q-devel... wants to merge 1 commit into main from Q-DEV-issue-23-1746143049
Conversation 6
Commits 1
Checks 0
Files changed 6
amazon-q-developer bot commented 17 minutes ago

### CloudWatch Logs Insights query setup

To investigate a production problem, the presenter selects Lambda log groups by the /aws/lambda/sam prefix and prepares a query sorted by timestamp.

[9:49](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=589s) [CloudWatch Logs Insights shows selected log groups and a query editor.](https://assets.ai.engineer/sites/aiecode2025/sha256/7710482259b99511823bc8cb511b48796f7b75e57fcdcae04a3c15ebcff69fff.webp)

Logs Insights
Select log groups, and then run a query or choose a sample query.

Logs Insights QL
OpenSearch PPL - new
OpenSearch SQL - new
30m  3h  1h
Compare (Off)
Local timezone

Select log groups by
Name prefix

Selection criteria
Add prefix
/aws/lambda/sam
Preview matched log groups (2)
Clear All

Log class
Standard

Account(s)
Change Accou...
All accounts

See recommendations
fields @timestamp, @message, @logStream, @log
| sort @timestamp desc
| limit 10000

Query generator
Run query
Cancel
Save
History
Logs Insights QL query can run for maximum of 60 minutes.

Logs (-)
Patterns (-)
Visualization
Logs (-)
Investigate
Export results
Add to dashboard
No results

Queries
Saved queries
Learn more
Filter by query name
Create query
Sample queries
Learn more
Common queries
Lambda
VPC Flow Logs
CloudTrail
Route53
AWS AppSync
NAT Gateway
IoT
CloudFront Standard Logs

Discovered fields
Saved and sample queries
Query commands

Interface text:
CloudWatch > Logs Insights
CloudWatch
Logs Insights
Analyze with OpenSearch - new
Favorites and recents
Dashboards
AI Operations Preview
Overview
Investigations
Configuration
Alarms
In alarm
All alarms
Billing
Logs
Log groups New
Log Anomalies
Live Tail
Logs Insights New
Contributor Insights
Metrics
All metrics
Explorer
Streams
X-Ray traces
Traces New
Trace Map
CloudShell
Feedback
© 2025, Amazon Web Services, Inc. or its affiliates.
Privacy
Terms
Cookie preferences

### Start an investigation from log results

The presenter finds Lambda import errors in CloudWatch Logs Insights and starts a new investigation with the query results as a snapshot.

[9:56](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=596s) [CloudWatch shows log results beside a form for starting an investigation.](https://assets.ai.engineer/sites/aiecode2025/sha256/1f56950ac149a1f278b41b532911d268bc16c94cc0c7b432a5bb2f42c7abd5a4.webp)

Logs (381)
Completed. Query executed for 2 log groups.
Showing 381 of 381 records matched
381 records (53.7 kB) scanned in 2.5s @ 153 records/s (21.6 kB/s)
Y-axis ticks: 0, 20, 40
Timeline: 01 AM, 01:15, 01:30, 01:45

# | @timestamp | @message
1 | 2025-02-06T01:40:43.8... | Unknown application error occurred Runtime.ImportModuleError
2 | 2025-02-06T01:40:43.8... | END RequestId: [illegible]
3 | 2025-02-06T01:40:43.8... | REPORT RequestId: [illegible] Duration:
4 | 2025-02-06T01:40:43.7... | START RequestId: [illegible] Version: $[illegible]
5 | 2025-02-06T01:40:43.7... | INIT_REPORT Init Duration: 3606.63 ms Phase: invoke Status: erro[illegible]
6 | 2025-02-06T01:40:43.3... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app.[illegible]
7 | 2025-02-06T01:40:38.0... | INIT_REPORT Init Duration: 220.22 ms Phase: init Status: error [illegible]
8 | 2025-02-06T01:40:38.0... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app.[illegible]
9 | 2025-02-06T01:40:37.8... | INIT_START Runtime Version: python:3.9.v64 Runtime Version ARN: [illegible]
10 | 2025-02-06T01:40:37.7... | Unknown application error occurred Runtime.ImportModuleError
11 | 2025-02-06T01:40:37.7... | END RequestId: [illegible]
12 | 2025-02-06T01:40:37.7... | REPORT RequestId: [illegible] Duration:
13 | 2025-02-06T01:40:37.7... | INIT_REPORT Init Duration: 3589.74 ms Phase: invoke Status: erro[illegible]
14 | 2025-02-06T01:40:37.7... | START RequestId: [illegible] Version: $[illegible]
15 | 2025-02-06T01:40:37.2... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app.[illegible]
16 | 2025-02-06T01:38:55.3... | INIT_REPORT Init Duration: 261.76 ms Phase: init Status: error [illegible]
17 | 2025-02-06T01:38:55.3... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app.[illegible]
18 | 2025-02-06T01:38:55.1... | INIT_START Runtime Version: python:3.9.v64 Runtime Version ARN: [illegible]
19 | 2025-02-06T01:38:55.0... | Unknown application error occurred Runtime.ImportModuleError

[illegible]bleshooting
Investigate
[illegible] operational investigations. Gather all your findings in one place, receive AI-driven suggestions based on your input, and resolve issues faster.
Learn more
Start a new investigation
Add to an existing investigation
Investigation title
Error in
No special characters
Additional note - optional
Note can be up to 2048 characters long. Character count: 0/2048
Snapshot preview
Observation suggestion discarded
Log Insights query result
Query
fields @timestamp, @message, @logStream, @log | sort @timestamp desc |
limit 10000
@timestamp | @message
2025-02-06 09:40:43.802 | Unknown application error occ...
2025-02-06 09:40:43.802 | END RequestId: 51777914-ed...

Interface text:
CloudWatch > Logs Insights
CloudWatch
Favorites and recents
Dashboards
AI Operations Preview
Overview
Investigations
Configuration
Alarms
In alarm
All alarms
Billing
Logs
Log groups New
Log Anomalies
Live Tail
Logs Insights New
Contributor Insights
Metrics
All metrics
Explorer
Streams
X-Ray traces
Traces New
Trace Map
Logs (381)
Patterns (-)
Visualization
Investigate
Export results
Add [illegible]
CloudShell
Feedback
© 2025, Amazon Web Services, Inc. or its affiliates.
Privacy
Terms
Cookie preferences

### CloudWatch Lambda investigation

The investigation brings Lambda import errors into a feed alongside suggested API Gateway error and latency graphs, giving the developer related signals to inspect.

[10:02](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=602s) [CloudWatch shows log results alongside an investigation feed containing a query observation.](https://assets.ai.engineer/sites/aiecode2025/sha256/7584da34ee9874f0d4d7a343fb999d450f4d689ec8c3471825335d156292fcd8.webp)

Logs (381)
Completed. Query executed for 2 log groups.
Showing 381 of 381 records matched
381 records (53.7 kB) scanned in 2.5s @ 153 records/s (21.6 kB/s)
Y-axis ticks: 0, 20, 40
Timeline: 01 AM, 01:15, 01:30, 01:45

# | @timestamp | @message
1 | 2025-02-06T01:40:43.8... | Unknown application error occurred Runtime.ImportModuleError
2 | 2025-02-06T01:40:43.8... | END RequestId: 51777914-ed9e-42ba-9166-b6f2df3a658c
3 | 2025-02-06T01:40:43.8... | REPORT RequestId: 51777914-ed9e-42ba-9166-b6f2df3a658c Duration:
4 | 2025-02-06T01:40:43.7... | START RequestId: 51777914-ed9e-42ba-9166-b6f2df3a658c Version: $[illegible]
5 | 2025-02-06T01:40:43.7... | INIT_REPORT Init Duration: 3606.63 ms Phase: invoke Status: error
6 | 2025-02-06T01:40:43.3... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app...
7 | 2025-02-06T01:40:38.0... | INIT_REPORT Init Duration: 220.22 ms Phase: init Status: error [illegible]
8 | 2025-02-06T01:40:38.0... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app...
9 | 2025-02-06T01:40:37.8... | INIT_START Runtime Version: python:3.9.v64 Runtime Version ARN: ...
10 | 2025-02-06T01:40:37.7... | Unknown application error occurred Runtime.ImportModuleError
11 | 2025-02-06T01:40:37.7... | END RequestId: 29d985fc-f030-4ca5-bbf4-3a03a32281c6
12 | 2025-02-06T01:40:37.7... | REPORT RequestId: 29d985fc-f030-4ca5-bbf4-3a03a32281c6 Duration:
13 | 2025-02-06T01:40:37.7... | INIT_REPORT Init Duration: 3589.74 ms Phase: invoke Status: error
14 | 2025-02-06T01:40:37.7... | START RequestId: 29d985fc-f030-4ca5-bbf4-3a03a32281c6 Version: $[illegible]
15 | 2025-02-06T01:40:37.2... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app...
16 | 2025-02-06T01:38:55.3... | INIT_REPORT Init Duration: 261.76 ms Phase: init Status: error [illegible]
17 | 2025-02-06T01:38:55.3... | [ERROR] Runtime.ImportModuleError: Unable to import module 'app...
18 | 2025-02-06T01:38:55.1... | INIT_START Runtime Version: python:3.9.v64 Runtime Version ARN: ...
19 | 2025-02-06T01:38:55.0... | Unknown application error occurred Runtime.ImportModuleError

Investigate
Error in Lambda
Feed
Tip: Found something else related to this investigation? Add it here. An “add to investigation” option is available on most dashboards and CloudWatch pages. Learn more

Observation added by vikasagr
Now
Log Insights query result
Query
fields @timestamp, @message, @logStream, @log | sort @timestamp desc | limit 10000
@timestamp | @message | [illegible]
Loading logs...

Interface text:
CloudWatch > Logs Insights
Logs (381) | Patterns (-) | Visualization
Investigate | Export results | Add [illegible]
Open in full page | Suggestions
CloudWatch
Favorites and recents
Dashboards
AI Operations Preview
Overview
Investigations
Configuration
Alarms
In alarm
All alarms
Billing
Logs
Log groups New
Log Anomalies
Live Tail
Logs Insights New
Contributor Insights
Metrics
All metrics
Explorer
Streams
X-Ray traces
Traces New
Trace Map

[10:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=617s) [CloudWatch investigation showing Lambda error findings and API Gateway metric graphs.](https://assets.ai.engineer/sites/aiecode2025/sha256/67e16db72b1ea8f246c2ab53ce6f66c7a87be158e21657e2b60eba1be05e3f59.webp)

Error in Lambda
Open
Impact started 47 minutes ago
No linked ticket
Analysis in progress. New suggestions will continuously appear after a few minutes.

Feed
Observation added by vikasagr
1 minute ago
The logs show multiple Lambda function invocations for the sam-2048-Game2048Function-92hxtZWv5xw6 function. Execution durations range from approximately 3400 ms to 11000 ms, with memory usage between 20 MB and 34 MB. A recurring Runtime.ImportModuleError is observed, specifically related to importing 'pydantic_core._pydantic_core'. Initialization errors and unknown application errors are also present. The logs indicate issues with module imports and potential configuration problems in the Lambda function environment.

Log Insights query result
Query
fields @timestamp, @message, @logStream, @log | sort @timestamp desc | limit 10000
@timestamp | @message
2025-02-06 09:40:43.802 | Unknown application error occ...
2025-02-06 09:40:43.802 | END RequestId: 51777914-ed...
2025-02-06 09:40:43.802 | REPORT RequestId: 51777914...
2025-02-06 09:40:43.782 | START RequestId: 51777914-e...
2025-02-06 09:40:43.762 | INIT_REPORT Init Duration: 36...
2025-02-06 09:40:43.303 | [ERROR] Runtime.ImportModu...
2025-02-06 09:40:38.099 | INIT_REPORT Init Duration: 22...

Observation suggested for AWS::ApiGateway::Stage x4mif50t84|dev
Now
AWS/ApiGateway | 5XXError
No unit
Y-axis ticks: 0, 6.0, 12.0
Timeline: Feb 06 00:30, Feb 06 01:00, Feb 06 01:30, Feb 06 02:00, Feb 06 02:30
Impact Start (2025-02...)
Impact End (2025-02...)
Legend: Sum (ApiName=sam-2048, Stage=dev)
Accept | Discard

AWS/ApiGateway | IntegrationLatency
No unit
Y-axis ticks: 3,218, 6,645, 10,072
Timeline: Feb 06 00:30, Feb 06 01:00, Feb 06 01:30, Feb 06 02:00, Feb 06 02:30
Impact Start (2025-02...)
Impact End (2025-02...)
Legend: Average (ApiName=sam-2048, Stage=dev)

Interface text:
Console Home > CloudWatch > AI Operations: Investigations > Error in Lambda
Suggestions | End investigation
All | New note
CloudWatch
Favorites and recents
Dashboards
AI Operations Preview
Overview
Investigations
Configuration
Alarms
In alarm
All alarms
Billing
Logs
Log groups New
Log Anomalies
Live Tail
Logs Insights New
Contributor Insights
Metrics
All metrics
Explorer
Streams
X-Ray traces
Traces New
Trace Map
CloudShell | Feedback
© 2025, Amazon Web Services, Inc. or its affiliates. Privacy | Terms | Cookie preferences

### Amazon Q Developer updates

The Amazon Q Developer page highlights GitLab Duo with Amazon Q and a preview of the transformation web experience. The speaker points viewers to the page for updates and to get started.

[13:09](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=789s) [Amazon Q Developer page showing announcements for GitLab Duo and the transformation web experience.](https://assets.ai.engineer/sites/aiecode2025/sha256/1af90ea04cb1836253aacaa930c1ef722b4227d57e872513e8f3c8a11c67beb6.webp)

What's new?

Introducing GitLab Duo with Amazon Q

Announcing Amazon Q Developer transformation web experience (preview)

Getting started

Interface text:
aws
About AWS
Contact Us
Support
English
My Account
Sign In to the Console
Amazon Q
Products
Solutions
Pricing
Documentation
Learn
Partner Network
AWS Mar[illegible]
Explo[illegible]
Amazon Q Developer
Overview
Features
Pricing
FAQs
Documenta[illegible]

## Full transcript

[0:00](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=0s) Hi, everyone. I'm Vikash. I'm a Software Development Manager with AWS at Amazon.

[0:05](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=5s) I'm Linda. I'm a Developer Advocate at AWS, and in this video we're going to talk about the software development life cycle, and specifically how you can use GenAI throughout that life cycle.

[0:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=17s) We're going to focus on Amazon Q Developer, which is an AI coding assistant, and we're going to show you where you could use it in all the different parts of that.

[0:25](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=25s) So I'm going to throw to Vikash because he, as a manager, always gets a very common question regarding this.

[0:31](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=31s) One of the most common questions that I hear from the engineering team is how can they incorporate generative AI practices into their software development life cycle, or the SDLC?

[0:42](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=42s) For those of us who don't know what SDLC is, it's a process of building and releasing software to our, uh, customers. We generally start with a planning phase where we gather requirements, product feedbacks, et cetera.

[0:55](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=55s) Then we go to the create phase where we actually build the software app- application itself. Then we test it, do end-to-end testing, integration testing, penetration testing to make sure that the software that we are building is safe for our customers.

[1:09](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=69s) We then deploy it, and finally we maintain it and modernize it. Over time, depending upon the feedback, we go through this cycle all over again.

[1:18](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=78s) So let's get right into it. Amazon Q Developer is a coding s- assistant that is also in your IDE, can be even in your CLI and terminal. Actually also has a GitHub extension and can be also in different parts of the life cycle, right?

[1:33](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=93s) So I'm gonna show you where you could get started. One of the cool things is if you install it in the command line or the IDE, doesn't require an AWS account.

[1:41](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=101s) All you have to do is go to this page, click Get started for free, and choose which one you want. Once you do that, I'll just quickly show you, here you have an example of how it appears in Visual Studio Code.

[1:51](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=111s) Over here... And we're gonna build, don't worry. Here is the way it appears in the CLI. What we d- can do next is jump into the CLI version because that's the most lightweight version for you to install Amazon Q.

[2:01](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=121s) You all have a command line on your computer, and here you can do either the planning phase, or if you've already done the planning phase somewhere else, you can go straight into creating and coding.

[2:12](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=132s) So let's get into it.

[2:14](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=134s) I have an idea. Why don't we build a game for our viewers today? So this game is called 2048 or 2048. So we have multiple tiles. The goal of the game is to merge two tiles of the same number, and then the numbers double.

[2:28](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=148s) The goal is to reach a total of 2048, or 2048. So here if you see we are merging two tiles of two, they become four. We are merging two tiles of four, they become eight.

[2:39](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=159s) We are merging two tiles of eight, making them 16, and so on and so forth.

[2:43](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=163s) This is a really fun game to build. So I actually think let's get right into the CLI and try it out. So everyone has a command line, right? So in order to start Q, once you install it, we showed you where to install it.

[2:54](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=174s) Now Vikash gave me a challenge. We have to build this 2048 game. To start it, all I have to actually write is q. I press Enter. If you aren't sure what to do and how to use it, you can just type with natural language right now and start just talking to it also as a chat, also to

[3:08](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=188s) ideate. But if you want to see all the other options you have, you could do /help and you will see also that you have all these, uh, different commands, as well as MCP if you would like to use that, and other tips.

[3:21](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=201s) So for now, I want to build a 2048 game in Python.

[3:28](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=208s) Using FastAPI?

[3:29](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=209s) Yeah, let's do using FastAPI.

[3:33](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=213s) Uh, let's use Poetry.

[3:34](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=214s) Using Poetry. Let's see what it comes up with. So now it's giving me the plan. It's telling me, "Here's what I w- I'm, I'm going to do," and now I have an ability to either accept each step by pressing Y and Enter, or I can just do T and trust it.

[3:49](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=229s) Vikash, should we trust it?

[3:51](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=231s) I, I trust Q.

[3:52](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=232s) Of course, this is a demo. If you're building in production, we always recommend reviewing the code, but here we're gonna trust it and it'll start running. And now you can see how long each step is taking as well.

[4:01](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=241s) All right. So now while we were chatting, this was generating some 2048 code here. One thing I forgot, and check this out. One thing I forgot is, look, it's putting it in inside just my, my regular folder.

[4:13](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=253s) I actually want it to move the whole thing into my development folder. So guess what? I could actually asked it, "Can you move this project to my development folder?"

[4:21](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=261s) So now it will move it in there.

[4:23](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=263s) That's actually pretty nifty little hack.

[4:25](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=265s) Yeah, 'cause I always forget when I do this to [laughs] put it in the right place. All right. So now, uh, it's saying the p- the project's set up. You could see that here it appears in my development folder.

[4:35](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=275s) Awesome. I think this code actually looks good. I am really happy that it is using FastAPI rightly. It has a response model. It has created POST APIs.

[4:45](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=285s) Agreed. What's cool, Vikash, you could also use this in your IDE, right? And open the folder structure 'cause of course this is more coming out in the CLI, but you can use Q in your IDE of choice.

[4:58](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=298s) Given that my engineering team relies on VS Code, IntelliJ, Eclipse, um, and everyone has their own preferences, right? And Amazon Q Developer touches all these touchpoints, which makes it very seamless of an experience.

[5:11](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=311s) It even created a README, Vikash. Which part of the software development life cycle is that? [laughs]

[5:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=317s) Awesome.

[5:19](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=319s) So now it tells me what my project structure is, it created it in the development folder even though I only remembered midway, and it tells me how to run it.

[5:26](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=326s) I think this is a great start, but is it production ready? I w- I would say no too. Why don't we add unit test? Yes. So let's open it in the IDE.

[5:36](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=336s) So why don't we start with adding unit test to make sure that it's production ready? So let's start with that. I quickly open up in my IDE, and I start invoking my Amazon Q Developer agent for test, for generating unit test by invoking /test.

[5:52](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=352s) So here I'm doing /test. It automatically invokes the Amazon Q Developer agent, and it quickly starts looking at the code itself. Once it's done, let's look at the generated code.

[6:05](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=365s) Here we see it is able to understand all pieces of the code, and we have, I think, a good amount of test. It is amazing that it was able to also understand the state and created relevant test for the state management itself.

[6:19](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=379s) So I think this looks pretty, pretty robust. I generally use /test a lot. There's also a feature called /dev, which is for feature development. You can give it a prompt in the IDE.

[6:30](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=390s) It will automatically understand the entire project as context and build context-aware features for me. So let's go ahead and quickly ask Q to fix my bugs by just saying fix and giving the error message.

[6:45](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=405s) It quickly analyzed my code base, it figured out where the error is, gave me the code, I applied it, and now let's see what happens.

[6:55](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=415s) Voila. I have a working code for a game with unit test. Let's do one more thing. Why don't we generate documentations before we raise a pull request? So let's invoke the /doc, which is the Amazon Q Developer agent to generate documentation.

[7:11](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=431s) I go ahead, I quickly pass on /doc. I ask it to create a README. So initially, there was a README generated, but now that we have a code and we have unit test, I, I want to see how it does better.

[7:23](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=443s) So it quickly started my summarizing my code base, started going through my source files. So now I see a documentation. It is able to understand my source code. It gives me the instruction, which was pretty much the same last time as well.

[7:36](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=456s) This is interesting. Now my API endpoints also have relevant examples with my troubleshooting documentation, and it also gave me a data flow diagram of how my state is being managed.

[7:49](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=469s) And I think one of the next steps could be deploying or having a PR, but did you know also that Q is available inside GitHub, and you can actually build inside GitHub?

[7:58](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=478s) It has agents there, and I'm going to show you really quick that as well. So if you like to build on GitHub and not leave GitHub, you can also do that.

[8:06](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=486s) Awesome.

[8:06](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=486s) I'm gonna give you a quick overview. So head over to Q Developer in, in Marketplace in GitHub, and all you have to do is choose which repos you want.

[8:14](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=494s) You can put all or a few. And now you can actually either use an existing issue or create a new one. Apply a label. Here, let's say we're just doing development agent.

[8:23](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=503s) And based on that issue, it will generate code. It will tell you when the PR is ready, and you can then look at the files that were changed. And now if we wanna change something in the PR, you can actually add comments and request changes like I normally would in a review, and then request the changes so

[8:41](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=521s) it does it again. So you don't even have to leave GitHub. And then Q also automatically runs code scans and fixes it right in the PR. And so it's pretty awesome how you can use also agents right inside GitHub with Q.

[8:55](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=535s) And we talked about where we could code, which is IDE, CLI, GitHub. We're building this 2048, uh, uh, game. We even ran tests. We add documentation. So what's next in the life cycle?

[9:08](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=548s) So n- the next would be to deploy it to our cloud services already. So one of the most common things, and I'm guilty of it, is saying, "Works on my machine."

[9:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=557s) Right? To make this game- [laughs] ... an actual production ready, we'll deploy it into AWS console. And in the background, I use the /dev agent in the IDE to actually generate SAM scripts and deploy my application.

[9:31](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=571s) You, you know what's something interesting I found?

[9:34](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=574s) What?

[9:35](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=575s) That our application was actually not running the right way in production.

[9:39](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=579s) Oh.

[9:40](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=580s) Yes. So I need to investigate. So let's go ahead and do that. So here I come to my AWS console. I go into my CloudWatch. Let's first look at the Lambda where I deployed through SAM, and I'm d- looking at the logs, and I quickly see there's, is some import error happening in the Lambda itself.

[9:59](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=599s) Now I can start investigating the application directly in the console itself using Amazon Q Developer.

[10:07](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=607s) The Amazon Q Developer AI operations automatically starts looking at the log group and all the associated resources. It creates a topology and then figures out the root cause for me.

[10:20](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=620s) I don't have to spend time debugging. I can look at the graphs. I can figure out what's going on and come back and fix my application. It's so easy for developers to actually know what's happening rather than trying to find the right timestamp and create reports or incident reports for the team.

[10:37](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=637s) So this feature enables me to quickly look what, what's wrong in my application, and I can go back in time and go ahead and fix it. I think this...

[10:47](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=647s) I was happy with this report, so let's just go ahead and close the investigation. Taking this game to production, I think, uh, when we saw the errors and Amazon Q Developer helped us debug what's the reason, I think one of the takeaways for me in this particular situation is to think of infra upfront, how your application is

[11:07](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=667s) going to the customers. I think if that's something that we would have done early on, we wouldn't have-

[11:12](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=672s) Right

[11:14](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=674s) ... faced this-

[11:14](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=674s) I should have asked Q CLI to generate an IaC.

[11:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=677s) We should have thought about infra upfront.

[11:18](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=678s) We are both part of the software development life cycle, Vikash. [laughs] [laughs]

[11:22](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=682s) So we should have thought about it upfront. What was your takeaways?

[11:27](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=687s) My takeaway is kind of similar to yours, where we have to k- pre-plan. So that planning phase might have other things, and maybe one way to actually follow best practices is to actually ask...

[11:38](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=698s) Even in the CLI, we could say, "What is the best way for me to plan for something that's a bit more robust, right, and production ready, and follow best practices?"

[11:46](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=706s) And you can iterate before you ever actually have the code saved anywhere, right? Or like generate and iterate. So I think the planning part where you can, of course, if you're deploy- deploying to the cloud, use IaC.

[11:58](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=718s) And then being able to use and utilize Q in different ways for your use case in so many different locations is helpful. Of course, it's always you are the person planning, you're the manager, and AI just is just helping you with all these tedious tasks and almost becoming your assistant in so many places there.

[12:13](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=733s) So it's awesome you have it in all these different places, but of course, it's on you as we learn to [laughs] be able to, uh, do this responsibly. Um, and I love the security scans and the monitoring and observability 'cause I think it's helps a lot in mitigating issues, so.

[12:27](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=747s) Absolutely. One of the things that you rightly pointed out is as engineers and with generative AI and Amazon Q Developer, the planning phase might probably also include planning your prompts, because prompt engineering is going to be a very important skill set to make sure that you get desired outputs from the, uh, from the la- models and the

[12:48](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=768s) agents.

[12:48](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=768s) So for anyone who's watching this and wants to try Q, first of all, you could try it for free in the IDE. You could try it for free in the CLI.

[12:55](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=775s) You could try it for free in GitHub and so many different locations. So definitely give it a try. Play around with it yourself. So you could head over to aws.amazon.com/q/developer and get started building right over here.

[13:08](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=788s) If you wanna see what's new also, check out... There's updates coming through, so be sure to check that out. And if you have any questions, let us know in the comments.

[13:17](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=797s) And as always, happy building.

[13:20](https://www.youtube.com/watch?v=utxVvGJ4bcg&t=800s) Thank you.
