Vibe Coding in Practice: Building a Classic Platform Jumping Game with Amazon Q CLI

Introduction

Last weekend, I embarked a journey with a simple goal: to use Amazon Q CLI to generate a prototype of a classic platform game. As I explored Q CLI’s capabilities more deeply, I discovered it could accomplish far more than creating a basic game prototype.

The project evolved to include fundamental game mechanics, character animations, a scoring system, physics (gravity, jumping, collision detection), sound effects, and multiple game levels - all without my writing a single line of code! This experience with generative AI programming assistance inspired me to document my platform game development journey.

My adventure building the platform game through Vibe Coding will be presented in two parts:

First Attempt
Enhancement Iterations
Implementation of a Complete Game Project

Here is how it unfolded.

Setting Up

First, ensure you have the Amazon Q CLI installed. Since I am using a MacBook, I installed Amazon Q CLI for macOS by following these steps:

Downloaded Amazon Q for command line for macOS.
Registered and authenticated with Builder ID.
Followed the instructions to install the shell integrations, and to granted macOS accessibility permissions.

Before beginning Super Mario game development, I verified my Q CLI environment was working correctly by running:

As shown above, the `q doctor` command serves as a useful tool to confirm that your Q CLI installation is functioning properly.

Next, we will use Pygame as the framework to develop the game with Python. Pygame is an open-source library that provides the fundamental building blocks for creating games in Python, including:

Graphics and animation capabilities
Sound playback functionality
Input handling (keyboard, mouse, joystick)
Basic collision detection
Surface manipulation and drawing primitives
Support for various image and sound formats

You can easily install Pygame library with the pip package manager using the following command:

First Attempt

After setting up the environment, I used Q CLI to create a simple platform game prototype using Pygame:

After several minutes of processing, Q CLI generated a fully functional game. The generated file, ‘main.py’, contained a complete game implementation. The game was playable right away! As shown in the screenshot below.

Screenshot of version 1 of platform game, generated by Q Developer CLI

If you're interested in exploring this platform game prototype created with just a single natural language prompt, you can view the complete code in my GitHub repository:

https://github.com/hanyun2019/q-cli-platform-game-demo/tree/main/code/v1

To run the game, use the following shell command:

In my first attempt with Q CLI, it successfully completed the programming task immediately after I submitted a single prompt. However, the game's UI looks relatively basic, so I decided to continue communicating with Q CLI using additional prompts to make the game more visually appealing.

Enhancement Iterations

Based on my first attempt, I experienced the charm of Q CLI in Vibe Coding, which led me to make several interesting explorations. Due to space limitations (and because the upcoming journey will be even more exciting), I’ll only list some of my main input prompts to give you a sense of my thinking process at that time.

Reloading Existing Code

I realized I needed to find a method to reload my previously written code. Given the time constraints, completing an entire platform game project in a single day seemed unrealistic. Therefore, I wanted to establish a workflow that would allow me to continue from my previous progress.

First, I needed to create a new V2 directory to begin the next phase of work. I thought: Since I'm using Vibe Coding, why not leverage Q CLI to assist with this task? Thus, I conducted the following exploration:

Screenshot of version 2 of reloading existing code

As shown above, Q CLI successfully created a new V2 subdirectory and copied all the code from the V1 version into this new location. Next, I instructed Q CLI to continue working within this new subdirectory.

Then I resumed Vibe Coding! Due to space constraints, I'll highlight only some of the more interesting prompts I submitted to Q CLI for reference:

Adding Sprites and Sound Effects

Implementing a Scrolling Camera

The conclusive game screenshot from this exploration phase is shown below:

Screenshot of version 2 of platform game, generated by Q Developer CLI

If you’re curious about the code at this exploration phase, you can view the complete code for that I’ve published on my GitHub repository:

https://github.com/hanyun2019/q-cli-platform-game-demo/tree/main/code/v2

At this point, I wasn't entirely satisfied with the generated code. I began to wonder: Could there be a more efficient "Vibe Coding" approach? For example, would it be possible to learn from existing open-source projects to create a more comprehensive game plan? This question forms the basis for the discussion in the following chapter.

Implementation of a Complete Game Project

In the first two parts, we explored using Q CLI to build a platform jumping game from scratch. However, incrementally providing requirements for Q CLI to modify proved inadequate for designing a truly comprehensive platform jumping game. Important aspects such as overall game framework design and difficulty progression across multiple levels requiring a more holistic approach.

This realization prompted a new question: Could I provide a complete reference to the large language model behind Q CLI, allowing it to learn and then design the game from a global perspective? This is precisely what I explore in this chapter.

Principles for Selecting a Reference Project

I selected the PirateMaker project as a reference for my next game development. I intended to submit this codebase directly to Q CLI for learning and reference purposes, then used it as a framework to design a new game project.

A critical factor in selecting this particular game code project is its licensing status: The project code is in the public domain. This means it can be copied, modified, distributed, and used even for commercial purposes without requiring permission.

Process of Q CLI Learning from External Code

To demonstrate how Q CLI learns from external code and generates new implementations, let’s first verify the environment and initiate a conversation:

Then, let’s submit the following prompt:

After submitting the prompt, Q Developer CLI responded with:

When entering “t”, the Q CLI executed the `clone` command and began thoroughly analyzing the PirateMaker project code. It examined the complete hierarchical structure of the project and generated its own overall game design.

Overall Game Design generated by Q CLI

What followed was an exciting moment. After reading and analyzing all the PirateMaker code that was previously shown to it, Q CLI first generated a high-level overall game design:

Fix Code Issues

Naturally, the development process is not without challenges. When first executed, code generated by Q CLI typically contains bugs that need addressing. However, what I appreciate most about Q CLI its command line interface, which operates independently from specific IDEs. This approach enables developers to maintain a consistent and fluid "Vibe Coding" experience throughout the debugging process.

If the initially generated code has defects, you can directly communicate with Q CLI through prompts such as:

For specific implementation issues, you can continue using “Vibe Coding” approach when interacting with Q CLI. For example, to address a UTF-8 encoding problem:

When requesting new functional features from Q CLI, simply describe them in natural language:

Or:

Final Game Showcase

I successfully completed a platform jumping game with three different difficulty levels without writing a single line of code myself! To provide an immersive demonstration of this entirely AI-generated game development process (embodying the "Vibe Coding" approach), I created a dedicated YouTube video:

While certain artistic elements still require refinement, and I haven't yet instructed Q CLI to generate realistic wall textures in this version, the game's underlying code structure is remarkably comprehensive. With just a few additional hours of “Vibe Coding” style interaction with Q CLI, I'm confident the system would produce an even more sophisticated gaming experience.

For those interested in examining the technical details of the Q CLI-generated code, you can access the complete codebase in my GitHub repository: https://github.com/hanyun2019/q-cli-platform-game-demo/blob/main/code/v3/

To run the game in your local macOS environment, execute these shell commands:

Conclusion

Using Amazon Q CLI, I created a complete platform jumping game without writing a single line of code. My development process evolved through three distinct phases: Initially, a simple prompt generated a basic functional game. Subsequently, through iterative enhancement, I incorporated sprites, sound effects, and a scrolling camera. Finally, by instructing Q CLI to analyze a public domain project as a reference, it produced a comprehensive game architecture with sophisticated level management, physics, and enemy systems. When technical issues emerged, I resolved them using natural language prompts. The final product features custom sprites, sound effects, and three difficulty levels—all accomplished through AI-powered "Vibe Coding."

Having completed this platform game development journey, I strongly recommend Amazon Q CLI as a coding assistant. The barrier to entry for game development has never been lower, and the creative possibilities have never been more expansive. Happy Vibe Coding!

Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.

Site Terms, Privacy, and more.