Supercharging developer workflow with Amazon Q Developer - Vikash Agrawal

Hi everyone, I'm Vikasj, I'm a Software Development Manager with AWS at Amazon.

I'm Linda, I'm a Developer Advocate at AWS, and in this video we're going to talk about the software development lifecycle, and specifically how you can use Gen AI throughout that lifecycle. 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.

So I'm going to throw it to Vikasj because he, as a manager, always gets a very common question regarding this.

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 lifecycle, or the SDLC. For those of us who don't know what SDLC is, it's a process of building and releasing software to our customers.

We generally start with a planning phase where we gather requirements, product feedbacks, etc. Then we go to the create phase, where we actually build the software 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.

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.

So let's getright into it. Amazon Q Developer is a coding 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 lifecycle,right?

So I'm going to show you where you can get started. One of the cool things is, if you install it in the command line or the IDE, it doesn't require an AWS account. 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, over here, and we're going to build, don't worry. Here is the way it appears in the CLI.

What we could do next is jump into the CLI version, because that's the most lightweight version for you to install Amazon Q. 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.

So let's get into it.

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.

The goal is to reach a total of 2048, or 2048. So here if you see, we are merging two tiles of 2, they become 4. If we are merging two tiles of 4, they become 8. If we are merging two tiles of 8, making them 16, and so on and so forth.

This is a really fun game to build. So I actually think let's getright 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.

Now, Vikasj, give 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 languageright now and start just talking to it, also as a chat, also to 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 different commands, as well as MCP if you would like to use that, and other tips.

So for now, I want to build a 2048 game in Python.

Using FastAPI?

Yeah, let's do using FastAPI.

Let's use poetry.

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'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.

Vikasj, should we trust it?

I trust Q.

Of course. This is a demo. If you're building in production, we always recommend reviewing the code. But here we're going to trust it, and it'll start running. And now you can see how long each step is taking as well.

Allright, 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 inside just my regular folder. I actually wanted to move the whole thing into my development folder.

So guess what? I could actually ask it, can you move this project to my development folder? So now it will move it in there.

That's actually a pretty nifty little hack.

Yeah, because I always forget when I do this to put it in theright place. Allright, so now it's saying the project is set up. You could see that here it appears in my development folder.

Awesome. I think this code actually looks good. I am really happy that it is using FastAPIrightly. It has a response model. It has created post APIs.

Agreed. What's cool, Vikasj, you could also use this in your IDE,right, and open the folder structure, because of course this is more coming out in the CLI, but you could use Q in your IDE of choice.

Given that my engineering team relies on VS Code, IntelliJ, Eclipse, and everyone has their own preferences,right? And Amazon Q Developer touches all these touchpoints, which makes it very seamless of an experience.

It even created a README, Vikasj. Which part of the software development lifecycle is that?

Awesome.

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.

I think this is a great start. But is it production ready? I would say no too. Why don't we add unit test? Yes, so let's open it in the IDE. 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. 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. 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 tests for the state management itself.

So I think this looks 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. 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. 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.

Voilà, 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.

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 want to see how it does better.

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 instructions, which was pretty much the same last time as well.

This is interesting. Now my API endpoints also have relevant examples. There's my troubleshooting documentation. And it also gave me a data flow diagram of how my state is being managed.

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 and have 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.

Awesome.

I'm going to give you a quick overview. So head over to Q Developer in Marketplace and GitHub, and all you have to do is choose which repos you want. 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. 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 want to 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 it does it again. So you don't even have to leave GitHub.

And then Q also automatically runs code scans and fixes itright in the PR. And so it's pretty awesome how you can use also agentsright inside GitHub with Q. We talked about where we could code, which is IDEs, CLI, GitHub, or building this 2048 game.

We even ran tests. We added documentation. So what's next in the lifecycle?

So 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,right? To make this game 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 some scripts and deploy my application. You know what's something interesting I found?

What?

That our application was actually not running theright way in production.

Oh.

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 looking at the logs.

And I quickly see there's some import error happening in the Lambda itself. Now I can start investigating the application directly in the console itself using Amazon Q Developer. 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. 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 theright timestamp and create reports or incident reports for the team. So this feature enables me to quickly look what's wrong in my application, and I can go back in time and go ahead and fix it.

I think this, I was happy with this report, so let's just go ahead and close the investigation. Taking this game to production, I think 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 going to the customers.

I think if that's something that we would have done early on, we wouldn't have.

Right.

Faced this.

I should have asked Q CLI to generate an ICE.

We should have thought about infra first.

We are both part of the software development lifecycle, Vikasj.

So we should have thought about it upfront. What was your takeaways?

My takeaway is kind of similar to yours, where we have to pre-plan. So that planning phase might have other things. And maybe one way to actually follow best practices is to actually ask, 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?

And you can iterate before you ever actually have the code saved anywhere,right, or generate and iterate. So I think the planning part, where you can, of course, if you're deploying to the cloud, use IAC. And then being able to 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 is just helping you with all these tedious tasks and almost becoming your assistant in so many places there. So it's awesome to have it in all these different places, but of course it's on you, as we learned, to be able to do this responsibly.

And I love the security scans and the monitoring and observability, because I think it helps a lot in mitigating issues.

Absolutely. One of the things that yourightly 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 large models and the agents.

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. 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 buildingright over here. If you want to 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. And as always, happy building.

Thank you.