Supercharging Your Developer Workflow with Amazon Q Developer

This ad is not shown to multipass and full ticket holders
React Summit US
React Summit US 2025
November 18 - 21, 2025
New York, US & Online
The biggest React conference in the US
Learn More
In partnership with Focus Reactive
Upcoming event
React Summit US 2025
React Summit US 2025
November 18 - 21, 2025. New York, US & Online
Learn more
Bookmark
Rate this content

In this talk, we'll to cover key features of Amazon Q Developer and demonstrate how it can enhance a developer’s workflow. The session will include live demos of:

  • /dev
  • @workspace
  • Code Scan
  • @git and @history from Q-Cli

We’ll also showcase real-world customer case studies to highlight the practical applications of these features.

This talk has been presented at Productivity Conf for Devs and Tech Leaders, check out the latest edition of this Tech Conference.

FAQ

Amazon Q Developer is an AI-powered conversational assistant that helps automate tasks across the software development lifecycle (SDLC).

Amazon Q Developer can autonomously take in requirements, analyze the code base, and develop features based on prompts in the IDE using its /dev agent.

Yes, using the /test agent, Amazon Q Developer can automatically generate unit tests by analyzing the code and handling various test cases and boundary conditions.

Amazon Q Developer can autonomously generate documentation by analyzing the entire codebase, summarizing source files, and creating README files with project structure, installation steps, and data flow diagrams.

Amazon Q Developer supports deploying applications using AWS services like S3, CloudFront, Lambda, and API Gateway, often using the serverless application model (SAM).

Amazon Q Developer can assist in debugging by integrating with Amazon CloudWatch to analyze logs, provide insights, and suggest hypotheses for resolving issues.

The /review agent is used to perform code reviews, identifying issues such as security vulnerabilities and suggesting improvements.

Amazon Q Developer streamlines software development by automating tasks such as feature development, testing, code reviews, and documentation, reducing manual effort and time.

Yes, Amazon Q Developer can generate deployment scripts for AWS services, facilitating the deployment process of applications to the cloud.

Amazon Q Developer can autonomously review code to identify security vulnerabilities and other issues, assisting developers in maintaining code quality.

Vikash Agrawal
Vikash Agrawal
Abeetha Bala
Abeetha Bala
26 min
27 Mar, 2025

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Today's Talk introduces Amazon Q Developer, an AI-powered conversational assistant that assists with software development lifecycle (SDLC) tasks. The speaker demonstrates building a 2048 game using Q Developer, which automatically detects the codebase and implements logic for the front end. The agent also generates tests for the code and helps identify bugs. Q Developer can generate documentation by analyzing the code and facilitate code reviews to find security vulnerabilities. The session covers error handling, deployment using AWS SAM, and debugging with Q Developer and CloudWatch. The speaker plans to deploy the application on EC2 in the future.

1. Introduction to Amazon Q Developer

Short description:

Today we'll discuss the software development lifecycle, Amazon Q Developer, its agents in IDE, terminal, and AWS console. Amazon Q Developer is an AI-powered conversational assistant that helps with SDLC. We'll also build a game called 2048. We'll use the Amazon Q Developer agent for feature development, write unit tests, perform code reviews, and write documentation. Everything starts with a prompt in your IDE.

Hi, everyone. I'm Vikash. I'm a software development manager with AWS at Amazon. Hi, everyone. I'm Abita Bala. I am a senior product manager at AWS. Thank you, Abita.

Today, I would like to welcome you all to our talk, Supercharging Developer Workflow with Amazon Q Developer. Today, in this talk, we'll first look at the software development lifecycle. Then we'll take a look at Amazon Q Developer. Then we'll look at the Amazon Q Developer agents in IDE, which is slash dev, slash test, slash docs and slash review. Then we'll look at the Amazon Q Developer in your terminal. And finally, we'll take a look at Amazon Q Developer in AWS console.

Software development lifecycle is fun. We get to solve hard problems, come up with great solutions and make our customers happy. It is a very iterative process. We start with a plan, which is like a product requirement document. Then we create artifacts, like code, documentation, et cetera. We test it, make it more secure, operate it, deploy it onto cloud, then maintain it, monitor it and modernize it. And then we do this all over again.

So what is Amazon Q Developer? Amazon Q Developer is an AI-powered conversational assistant that can help you across your software development lifecycle, which is the SDLC. It can perform complex tasks autonomously. And to take this step further, today we'll build a game called 2048 or 2048. The aim of the game, as we can see here, is to merge two tiles with the same numbers to build a larger number together. For example, here we merge two tiles of two to make them four, merge two tiles of four to make them eight and 16 and so on and so forth.

So how do we go ahead with this? We'll first use the Amazon Q Developer agent, which is slash dev for feature development. Then we'll write unit tests to make it production ready, then perform code reviews, and finally write a documentation for before pushing it to production. So let's start with feature development. The Amazon Q Developer agent for feature development can take in requirements from you, then it will analyze your code base and come up with the entire feature development and do it on your behalf autonomously. As we see in this entire presentation, everything starts with a prompt in your IDE.

2. Building the 2048 Game and Code Review

Short description:

I will invoke the agent to build a 2048 game with a front end and back end. The Q dev quickly reads our code base, comes up with a plan, and shares the summary of changes. It automatically detects it as a fast API application and implements the logic for the front end. It updates the existing code and wiring, preserving the configuration and logging setup. The code for the HTML is well aligned, connected to the back end, and follows best practices.

So let's start. First, I will invoke the agent by calling slash dev and I'm giving it a prompt that I want it to build a 2048 game with a front end and back end. Here while it's doing that, let's take a look on our sidebar. This is a simple hello world function boilerplate code in Python. We have app.py, which has a read root function, which is hello world, we have a test app.py and everything else is just a boilerplate piece of code.

So coming back to the right hand side where we see the Q dev, the moment it starts reading, the moment we start invoking the agent, it quickly starts reading our code base. One thing it does is it comes up with a plan and shares that plan entirely as it proceeds to go ahead. So it's also giving us the summary of change, the files that it is reading, reviewing and if it, because the agent is smart enough, if it thinks that it needs to modify an existing file, it will go ahead and do that for you. Here, one thing is interesting, that I didn't even mention that this is a fast API application, but it automatically found out and discovered that. And it figured out that it needs to do a front end implementation as well as there is no front end code which is wired in. So it is now implementing the logic for our front end and it is updating our existing first app.py. Now, it is now as a developer, as we review codes in smaller chunks, it is doing a front end implementation and as we do a front end implementation, it is also updating our existing code.

So, as you can see, as you review codes in smaller chunks, it is doing that for us in the background. Now it's taking a look at the entire file. Now it is wiring up the code. It also figured out that there is an existing configuration and logging setup and made sure it didn't change or alter that. Now it's it has a working code for the HTML. And now we can start reviewing our code. Before we do that, I want to call out that this entire application took me around 13 minutes. That's 1 3 2 build. There is some editing magic in here. That's why we see such a shorter period of time. So let's start our code reviews. Let's start with app.py. I see that it updated the app name. It removed the hello world function created a game file and created three API's a move function a start game and a game state that that looks correct. Let's start with index dot HTML. Here we see that the HTML is well aligned has CSS is connected to the back end makes a API call has a move function and has a color combination for tiles as well. I also see that it has event listeners for my arrow keys and it uses async await. So it follows the best practices which largely looks correct to me.

3. Game.py and Adding Tests

Short description:

The game.py file has created functions to manage state. When running the code, I encountered an error due to missing cause headers. By allowing the local host in the back end, I resolved the issue and now have a working game. Adding tests, I invoked the slash test agent and it generated tests for the app.py file.

So finally we look at the game dot py. Here we see that it has created a bunch of functions in the entire file which to manage state which largely looks correct to me. So why don't we go ahead and accept it? Let's try running the code. And as they say the first time if you run a code and if it's run successfully, then there's a bug. And that's exactly what happens here. I am trying to run the code. I come to the screen, but it's not running. I will again paste the error message in Amazon Q developer figure it out. And then I realized that it's missing cause headers cause as a mechanism used by browsers when they are making an external API call to a different endpoint. So I will allow allow list my local host in my back end to make sure my front end is able to read it successfully. Now, I'll add a middleware. That I'll do the necessary imports. And finally we have a working game. So once the game is running we can see that it has created a bunch of functions in the entire file. And finally, we have a working game. Here as I'm emerging the tiles I can see the numbers are adding and the game is working as expected. There's a score mechanism and I can always start a new game. Is it production ready? Probably not. So why don't we go ahead and add some tests and for this will invoke the slash test agent, which is the Amazon Q developer agent for unit test. We'll do the same. We'll invoke the agent by slash test. Here the prompt is optional. If you want to make the agent to generate test for a particular use case, then you can give it a prompt. But here we'll start with a generic with an empty prompt and it automatically figures that out. So it now it's creating the test or unit test for app dot py, which is the open file here. It quickly started analyzing and it's and it generated a bunch of tests for me. So let's before reviewing before accepting. Let's go ahead and review the the tests. So here I look at the test file. I see that there is a bunch of functions added.

4. Test Generation and Bug Fixes

Short description:

The generated tests included checks for game state management and boundary conditions. Fixing the failing tests improved the overall test coverage and identified bugs in the source code.

I also observe that it rightly included test for my state for my game IDs for my management Etc and it also handle the boundary conditions, which is good. So let's go ahead and accept it. And let's try running the test.

Okay, so this is interesting. I had almost 24 test out of which two are failing if I were to write these manually. I'm pretty sure I would have taken longer than this. So why don't we go ahead and fix this test? We'll again come back to Amazon queue developer paste the entire error. And now we can see that the test is not running.

So And it quickly started generating the test. So now once I have the test, I'll go ahead copy it and paste it in my test file. And let's rerun the tests. And I see that test is fixed. So let's move on to the next one and do the same. So I give it an error. I say fix. And in this case, it will not only find out that there is a bug in the test, but it will also find a bug in the source code. So I'll first copy it.

5. Fixing Bugs and Adding Tests

Short description:

I fixed a bug in the code by removing a duplicate patch and updating the necessary imports. I also added negative tests for the make move function. Running the code confirmed that the game is working and the imported uuid is being used correctly.

Here if you observe on line 274 while pasting. I have included at patch twice, which is again a bug that Lyle face later on. So it gave me changes in the app dot PY. I'll update my main server file. I'll do the necessary imports for my ui. So I'll do the necessary imports for my ui. So I'll update it. So I'll do the necessary imports for my ui. I'll do the necessary imports for my uuid. I'll come back and rerun the test. And I still see a failure. So I'll go back to the test file remove this patch. I'll go back to the test file. rerun the test. And now I have 24 passing tests.

So let's look at the slash test again. And this time I wanted to add negative test only for the make move function, which is very specific. So let's see how it does. I look at the test generated. I see that there's assertions. It's validating for status codes Etc. And finally I have 25 valid working unit as generated.

Let's retry running the code to make sure that everything is working as expected. So the game is working. Which is good. Let's also look at the uuid that we imported as it being used in this piece of code or not. So let's investigate in the network panel. Let's look at the headers of the move function. And in the payload we do see the game ID and the game ID is a uuid v4. That means it is running the recent code and the test are being working as expected.

6. Generating Documentations and Code Reviews

Short description:

To ensure up-to-date documentations, Amazon queue developer can generate documentations by analyzing the code. It scans the source files, generates a documentation with installation steps, API information, testing steps, and a data flow diagram. Code reviews can also be done with the agent to find security vulnerabilities.

So let's take this a step further and generate documentations and outdated documentation for a software project can be time-consuming and detrimental for on boarding. So it is in the best interest to keep the documentations updated with the code changes. Amazon queue developer can autonomously generate documentations for you by analyzing your entire code.

We again invoke the agent by doing slash talk. I'm not passing any prompt here. So it's asking me a few questions. I want to generate a readme. But before we do that, let's also look at the existing readme what's in there. So this is an empty readme at this point of time.

It has started scanning our source file. Now it is summarizing the source files. And finally it has generated the entire documentation. It figured out the repository structure the key files in the project. And then it give me the installation steps. It also generated documentations for my API my testing steps. And included a data flow as well. Towards the end of the readme. The data flow diagram is generally very helpful to understand how the application is working and what's the dependency mechanism here.

So let's go ahead and run it. So let's go ahead and do code reviews with Amazon Q developer agent for code reviews. Here the agent will autonomously review your entire code to find out security vulnerabilities. I'm running this application in localhost and at one point of time I wanted to run it with HTTPS. That's why we see the search folder in our left sidebar. So when it's so here coming back to the slash review, we see it has initiated the code review. Now it's reviewing the code and it has found a bunch of issues. So looking at the code issues up top. I see there are hard-coded credentials. I am running this application hard-coded credentials. I'm okay with that because I know these are only for localhost for development. So I don't need to take actions for them.

7. Error Handling, Deploying, and SAM Configuration

Short description:

There was an inadequate error handling detected. We generated a fix and completed the code review successfully. Now, let's start deploying the application. We commit the code and push it to QCLI, which uses best practices like semantic release. We use Amazon Q Developer for feature development and build deployment scripts with SAM. We deploy the frontend via S3 and CloudFront, and the backend via Lambda and API gateway, utilizing layers for dependencies. The feature dev agent quickly analyzes the code and generates deployment templates in template.yaml.

So here I see in the medium. There's an inadequate error handling detected. So why don't we go ahead and generate a fix for that? So I see the generated fix. Let's go ahead and accept it. And yes now we have finally successfully completed the slash review.

So why don't we go ahead and let's start deploying it. Hey folks. So let's take this application to the next level and why don't we deploy in cloud today? Before that, let's commit our code and push it to our code hosting services QCLI. So let's invoke QCLI with QChat. QChat has access to add get, git history and environment variables. When I ask it to create a commit, it was able to do it accurately. It can identify changes, modify your core game functionality. It updates corresponding test cases, makes a dog's changes. I also like that it uses feet which is best practice for committing the code and it also uses semantic release for better versioning of my software.

Now moving on, let's look at Amazon Q Developer in the AWS console. Before we deploy to console, we need to run some deployment scripts. So let's do that. Today we will again use Amazon Q Developer for feature development, which is slash dev to build our deployment scripts. When I ask Q Developer to build a SAM config, as a recap, SAM is serverless application model, which is a deployment mechanism to deploy software on AWS. As a best practice, I want to deploy frontend via S3 and serve via CloudFront and backend via Lambda and serve via API gateway. For Lambda, I want to use layers for dependencies whenever I deploy. My deployment time is minimal and code is very secure. So let's go ahead and deploy. And as you can see, it shares what it reviewed and what is created. Let's move on. I send the prompt and very quickly, my feature dev agent starts analyzing the code. It looks at existing code base to understand my frontend code and where my build is. My frontend code and where my backend code is hooked. Understanding my test application code and real application code quickly generates templates. So you can see the template.yaml, which will be deployed to AWS.

8. Debugging and Deployment

Short description:

Now, let's look at the template.yaml file. Some Lambda functions are created with game 2048. The naming looks correct. The S3 bucket is private. CloudFront uses OAI. Let's accept all the changes. Let's deploy to our own AWS account using SAM deploy and SAM build. The deployment starts and completes. However, there is a bug that needs to be debugged using Amazon QDeveloper with CloudWatch.

Now, let's look at the template.yaml file. I see layers on line 18 and above. So some Lambda functions are created with game 2048. The naming looks correct. The S3 bucket is private. CloudFront uses OAI. It largely looks correct to me. So why don't we go ahead and accept all the changes?

Now that it's ready, let's deploy to our own AWS account. First, we call SAM deploy, SAM build, the code build successfully. Then run SAM deploy. Give it the name, region, auth. I don't need auth here. I don't need auth here. I've not specified because it's a simple game. And then I say yes and the deployment starts. Quickly it starts uploading all the artifacts. Once it's done, you can see it's initiating the deployment. And let's wait for the stack updates to be completed. And finally we see the deployment is complete.

So as you can see, like Vikash mentioned before, if it runs the first time, then probably you have not done a great job. It does not look right. So the code runs for the first time. We notice there is a bug. It deployed to CloudFront, but it's not working. So let's run the code. And you can see that the code is running correctly. It deployed to CloudFront, but it's not working. So let's try to debug and see what happens. So to debug, again, we will be using Amazon QDeveloper with CloudWatch, which is Amazon monitoring and observability solution that we have. Let's try to debug and see what's going on.

9. Troubleshooting and Next Steps

Short description:

In Amazon CloudWatch, specify the log group and run a query to start investigating. Suggestions and reasoning help troubleshoot. Use QChak in Amazon QLogs for another investigation approach. The application is not suited for serverless architecture, so we plan to deploy an EC2 in the future.

So in logs and sites in Amazon CloudWatch, you specify the log group. And then you can see that we recently added the expanded log group criteria where you can search by all log groups or prefix itself. So you run the query and then you start investigating. So you give it an investigation title. And then you look down and then you start the investigation.

So it starts suggesting what could have happened. Then you go to the investigation tab where you started the investigation. On the right, you can see the suggestions. So there are a bunch of suggestions here with the API gateway error. It looks like that might be the reason. So I go ahead and accept it and then it suggests hypothesis and the reasoning as well. I then accept the reasoning. So with this, I understand what's going on when I'm trying to troubleshoot and figure out what's going on. So now that it's done, I can end the investigation and I can archive it.

The other way that you can do is you can go to the investigation and then you can use QChak to be able to do it as well. So you go to Amazon QLogs and then you see all that's generated. And you can see the summary of all the observations there as well. Now, finally, with a bunch of trial and error, we got the application to work. And then we realized the application is not suited for serverless architecture. As next steps, we are working to deploy an EC2 which will be in the future. So this summarizes it. Thank you all for your time today.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Debugging JS
React Summit 2023React Summit 2023
24 min
Debugging JS
Top Content
Watch video: Debugging JS
Debugging JavaScript is a crucial skill that is often overlooked in the industry. It is important to understand the problem, reproduce the issue, and identify the root cause. Having a variety of debugging tools and techniques, such as console methods and graphical debuggers, is beneficial. Replay is a time-traveling debugger for JavaScript that allows users to record and inspect bugs. It works with Redux, plain React, and even minified code with the help of source maps.
A Framework for Managing Technical Debt
TechLead Conference 2023TechLead Conference 2023
35 min
A Framework for Managing Technical Debt
Top ContentPremium
Today's Talk discusses the importance of managing technical debt through refactoring practices, prioritization, and planning. Successful refactoring requires establishing guidelines, maintaining an inventory, and implementing a process. Celebrating success and ensuring resilience are key to building a strong refactoring culture. Visibility, support, and transparent communication are crucial for addressing technical debt effectively. The team's responsibilities, operating style, and availability should be transparent to product managers.
Building a Voice-Enabled AI Assistant With Javascript
JSNation 2023JSNation 2023
21 min
Building a Voice-Enabled AI Assistant With Javascript
Top Content
This Talk discusses building a voice-activated AI assistant using web APIs and JavaScript. It covers using the Web Speech API for speech recognition and the speech synthesis API for text to speech. The speaker demonstrates how to communicate with the Open AI API and handle the response. The Talk also explores enabling speech recognition and addressing the user. The speaker concludes by mentioning the possibility of creating a product out of the project and using Tauri for native desktop-like experiences.
A Practical Guide for Migrating to Server Components
React Advanced 2023React Advanced 2023
28 min
A Practical Guide for Migrating to Server Components
Top Content
Watch video: A Practical Guide for Migrating to Server Components
React query version five is live and we'll be discussing the migration process to server components using Next.js and React Query. The process involves planning, preparing, and setting up server components, migrating pages, adding layouts, and moving components to the server. We'll also explore the benefits of server components such as reducing JavaScript shipping, enabling powerful caching, and leveraging the features of the app router. Additionally, we'll cover topics like handling authentication, rendering in server components, and the impact on server load and costs.
Power Fixing React Performance Woes
React Advanced 2023React Advanced 2023
22 min
Power Fixing React Performance Woes
Top Content
Watch video: Power Fixing React Performance Woes
This Talk discusses various strategies to improve React performance, including lazy loading iframes, analyzing and optimizing bundles, fixing barrel exports and tree shaking, removing dead code, and caching expensive computations. The speaker shares their experience in identifying and addressing performance issues in a real-world application. They also highlight the importance of regularly auditing webpack and bundle analyzers, using tools like Knip to find unused code, and contributing improvements to open source libraries.
Monolith to Micro-Frontends
React Advanced 2022React Advanced 2022
22 min
Monolith to Micro-Frontends
Top Content
Microfrontends are considered as a solution to the problems of exponential growth, code duplication, and unclear ownership in older applications. Transitioning from a monolith to microfrontends involves decoupling the system and exploring options like a modular monolith. Microfrontends enable independent deployments and runtime composition, but there is a discussion about the alternative of keeping an integrated application composed at runtime. Choosing a composition model and a router are crucial decisions in the technical plan. The Strangler pattern and the reverse Strangler pattern are used to gradually replace parts of the monolith with the new application.

Workshops on related topic

Building a Shopify App with React & Node
React Summit Remote Edition 2021React Summit Remote Edition 2021
87 min
Building a Shopify App with React & Node
Top Content
Workshop
Jennifer Gray
Hanna Chen
2 authors
Shopify merchants have a diverse set of needs, and developers have a unique opportunity to meet those needs building apps. Building an app can be tough work but Shopify has created a set of tools and resources to help you build out a seamless app experience as quickly as possible. Get hands on experience building an embedded Shopify app using the Shopify App CLI, Polaris and Shopify App Bridge.We’ll show you how to create an app that accesses information from a development store and can run in your local environment.
Build a chat room with Appwrite and React
JSNation 2022JSNation 2022
41 min
Build a chat room with Appwrite and React
Workshop
Wess Cope
Wess Cope
API's/Backends are difficult and we need websockets. You will be using VS Code as your editor, Parcel.js, Chakra-ui, React, React Icons, and Appwrite. By the end of this workshop, you will have the knowledge to build a real-time app using Appwrite and zero API development. Follow along and you'll have an awesome chat app to show off!
Hard GraphQL Problems at Shopify
GraphQL Galaxy 2021GraphQL Galaxy 2021
164 min
Hard GraphQL Problems at Shopify
Workshop
Rebecca Friedman
Jonathan Baker
Alex Ackerman
Théo Ben Hassen
 Greg MacWilliam
5 authors
At Shopify scale, we solve some pretty hard problems. In this workshop, five different speakers will outline some of the challenges we’ve faced, and how we’ve overcome them.

Table of contents:
1 - The infamous "N+1" problem: Jonathan Baker - Let's talk about what it is, why it is a problem, and how Shopify handles it at scale across several GraphQL APIs.
2 - Contextualizing GraphQL APIs: Alex Ackerman - How and why we decided to use directives. I’ll share what directives are, which directives are available out of the box, and how to create custom directives.
3 - Faster GraphQL queries for mobile clients: Theo Ben Hassen - As your mobile app grows, so will your GraphQL queries. In this talk, I will go over diverse strategies to make your queries faster and more effective.
4 - Building tomorrow’s product today: Greg MacWilliam - How Shopify adopts future features in today’s code.
5 - Managing large APIs effectively: Rebecca Friedman - We have thousands of developers at Shopify. Let’s take a look at how we’re ensuring the quality and consistency of our GraphQL APIs with so many contributors.
Build Modern Applications Using GraphQL and Javascript
Node Congress 2024Node Congress 2024
152 min
Build Modern Applications Using GraphQL and Javascript
Workshop
Emanuel Scirlet
Miguel Henriques
2 authors
Come and learn how you can supercharge your modern and secure applications using GraphQL and Javascript. In this workshop we will build a GraphQL API and we will demonstrate the benefits of the query language for APIs and what use cases that are fit for it. Basic Javascript knowledge required.
0 To Auth In An Hour For Your JavaScript App
JSNation 2023JSNation 2023
57 min
0 To Auth In An Hour For Your JavaScript App
WorkshopFree
Asaf Shen
Asaf Shen
Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool.
We will enhance a full-stack JS application (Node.js backend + Vanilla JS frontend) to authenticate users with One Time Passwords (email) and OAuth, including:
- User authentication – Managing user interactions, returning session / refresh JWTs- Session management and validation – Storing the session securely for subsequent client requests, validating / refreshing sessions
At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods.