Next Gen Developer Experience with Amazon Q Developer

There have been massive advances in the capabilities and features supported by Amazon Q Developer over the last few months. A number of these really stood out for me:

• At the beginning of March the new enhanced Amazon Q Developer CLI agent was released with the power of Claude 3.7 Sonnet step-by-step reasoning. This also gave the agent access to tools such as the AWS CLI. Read more in the blog post

• At the end of April the Amazon Q Developer CLI was further enhanced with support for Model Context Protocol (MCP) to provide even more context. Read more in the blog post

• At the beginning of May, Amazon Q Developer support was integrated into GitHub in preview. Read more in the blog post

With all of these improvements, I wanted to see if there was a way of bringing them together to meet a coherent use case. This use case was to:

1. Take a task assigned to me from a Jira Kanban board

2. Implement the requested functionality

3. Push the code up to GitHub as the source code repository

4. Run a check for security vulnerabilities and code quality issues

5. Raise a Pull Request

6. Move the task along on the Kanban board

The goal was to show how these tools can make life easier for a software engineer, and greatly increase their productivity. Let's see how I got on.

Step 1: Set up Jira

I am using a hosted version of Jira Cloud using the free tier provided by Atlassian. The first thing I did was to create a new Jira project that sets up a Kanban board using a software development supporting template.

Next I created a new Jira task. The task was to "create a classic snake game written in python using pygame", and I assigned it to myself. Although this is a contrived example, you could easily equate this to a new feature on an existing service.

Once created, we can see this task in to "To Do" section of the Kanban board.

I also created a new GitHub repository which is cloned to my workspace.

Step 2: Configure MCP Servers

The next step was to setup the Amazon Q CLI to access both Atlassian and GitHub. Amazon Q CLI acts as an MCP Client, and it can access MCP Servers that have been configured in a mcp.json file. This files needs to be located in ~/.aws/amazonq. You can find out more details in this blog post by Ricardo Sueiras.

I want to run these MCP Servers in a container, and without access to Docker Desktop I configure them to use Podman. My configuration is shown below.

{
  "mcpServers": {
    "github-mcp-server": {
      "command": "podman",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--env",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "github_pat_xxx"}
    },
    "mcp-atlassian": {
      "command": "podman",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "JIRA_URL",
        "-e", "JIRA_USERNAME",
        "-e", "JIRA_API_TOKEN",
        "ghcr.io/sooperset/mcp-atlassian:latest"
      ],
      "env": {
        "JIRA_URL": "https://xxx.atlassian.net/",
        "JIRA_USERNAME": "xxx@email.com",
        "JIRA_API_TOKEN": "XXXXX"
      }
    }
  }
}

This required creating a Personal Access Token in GitHub, and an API Token in Atlassian.

Step 3: Run Amazon Q Developer CLI

After making the changes to the mcp.json configuration, I launched Amazon Q CLI from the terminal window in my Visual Studio Code IDE. You can see that the two MCP Servers have been loaded and are accessible.

I start by asking the Amazon Q CLI to “get the latest task from Jira that is assigned to me”. The Amazon Q CLI returns wanting to know more details, before it can use the configuration to retrieve information about the task.

I tell the Amazon Q CLI that I am using Jira Cloud and to search across all projects. I am then told that the Amazon Q CLI wants to run a tool provided by the mcp_atlassian MCP Server. I am prompted to either press t to always trust the tool for the session, y to allow the tool to be executed this time without trusting for the session, or n to not let the tool be executed. I will be answering y to all of these prompts.

After running the tool, the Amazon Q CLI has found the task and displays all of the details.

I ask Amazon Q CLI to help me implement the functionality, and it goes away and generates all the code required. At this point, the code is in memory, and I am asked if I want to save the code to a file in my current directory.

I tell the Amazon Q CLI to create a new branch and add the file to this new branch. After running the relevant git commands to create a new branch, the Amazon Q CLI switches to this branch, and then writes the code to a new file in this branch.

After successfully writing the code to a new branch, the Amazon Q CLI commits the changes with a message referencing the specific Jira task number that it still has in its current session context.

At this point, I could prompt to make more enhancements to the game. The Amazon Q CLI even gives suggestions of areas of the game it could improve. Instead, I just ask it to update the README file with instructions on how to play the game, and then make another commit.

The Amazon Q CLI now asks if I want to make any other changes. I'm happy with those that have been made so far, so ask it to make a pull request for these. Notice the first request to create a pull request fails. Amazon Q CLI apologises, and tries another approach, this time pushing the branch to GitHub and then creating the pull request which succeeds.

After creating the pull request, the Amazon Q CLI knows from its session context and its reasoning, that we should also update the original task in Jira. It interacts with tools in the Atlassian MCP Server to transition the task to the "In Progress" state and add a relevant comment.

Step 4: Jira Kanban Board

At this point in time, I go across to the Kanban board in Jira and can see that the task has been transitioned to "In Progress".

Clicking into the task, I can see the comment that has been added to the task. This gives details about the functionality implemented to meet the task description, alongside a working link to the open PR in GitHub.

Step 5: Code Scanning in GitHub

The final task I wanted to carry out was to run a check for security vulnerabilities and code quality issues. I have already configured my GitHub account with the Amazon Q Developer application. This means that as soon as the pull request was raised, the amazon-q-developer application automatically scanned the changes in the PR. Happily, there were no security or code quality issues found. If there were, the new application would have automatically generated code suggestions to fix the findings.

Conclusion

I can't remember the last time I tested out new features and services and genuinely felt so convinced we are now starting to see a change in how we will engineer applications in the software industry. The value of software engineering still remains, even more so when working on complex problems for which generative AI solutions do not have the corpus of knowledge to be trained on. However, this showed to me how these new capabilities can help in reducing the context switching, and the need to move between various tools, copying data between them. The next generation of developer experience is well and truly upon it, so I'd urge everyone to try it out.