AI Engineer World's Fair 2025
Supercharging Developer Workflow with Amazon Q Developer
Loading slides…
Read the talk
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.
From a talk by Vikash Agrawal and Linda Haviv
Before you start: 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?
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 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.
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 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn the 2048 rules into a build plan
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 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, and manage the project with Poetry. 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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Correct the workspace and inspect the scaffold
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Test state transitions, then repair an error
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Refresh documentation after the code changes
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use an issue as the development request
Linda next shows an alternative development surface: Q’s GitHub integration. 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:
- Install Q Developer through GitHub Marketplace and select all repositories or a smaller set.
- Open an existing issue or create a new one, then apply the development-agent label.
- Let Q generate code from the issue and notify you when the pull request is ready.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Investigate the gap between local and deployed behavior
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 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 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Bring infrastructure and prompts into the initial plan
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Product overview, editor installation links and current availability notices.
Official tutorial for declaring API response models and return types.
Installation and usage documentation for Python dependency management and packaging.
Overview of AWS SAM for defining and deploying serverless applications.
Further reading
The May 2025 announcement explains issue-driven development, pull-request reviews and feedback inside GitHub.
AWS walkthrough of starting an investigation and using generated hypotheses to guide operational troubleshooting.
Updates since the talk
- Amazon Q Developer feature and command historyDocumentation
Dated changes explain the replacement of IDE slash-command agents and the transition from Q CLI to Kiro CLI.
Full transcript
Loading transcript…