🐍 Building a Classic Snake Game with Amazon Q CLI

Prerequisites

1. macOS system
2. AWS account with Builder ID or IAM identity

Installing Amazon Q on macOS

• Go to the official download page: https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-installing.html
• Download the Mac installer (typically a .dmg file):
• Click the download link for macOS under the Amazon Q Developer section.
• Open the .dmg file once downloaded.
• Drag the Amazon Q app into your Applications folder.

• Enable shell integrations with Amazon Q

• Grant accessibility permissions so Amazon Q can interact with windows and perform actions.

• After clicking ‘Enable’, you’ll be prompted to activate Amazon Q.

• Open the app and follow the sign-in process using your AWS Builder ID or IAM identity.

• Click on ‘Allow Access’ to grant Amazon Q command line access.

• After successful installation, you’ll be greeted with the Getting Started page.

• Click on Integrations and check your favorite terminal enabled or not

• Copy the code , optional and paste in terminal

q integrations install input-method

Lets Restart the terminal ( Close and Open terminal/iterm using cmd +q )

cmd + q

Lets start integration of Amazon Q ( terminal )

q chat

You will see a page like this

Use commands help

/help

If you want to change model use

/model

Select Enter , so we can use required model

Snake game

Why Snake?

Snake is a timeless game that’s simple to play but surprisingly challenging to code. I picked it because:

• It’s a great way to learn about game loops, collision detection, and user input.
• The rules are simple, making it perfect for a quick project.
• It’s nostalgic and fun!

---

Effective Prompting Techniques

I found that being clear and specific in my prompts led to the best results. For example, my main prompt was:
> Create a basic Snake game in Python using PyGame. The game should have:
> – A snake that moves with arrow keys
> – Food that appears randomly
> – The snake grows when it eats food
> – The game ends if the snake hits the wall or itself
> – A score displayWhen I wanted to add features, I used prompts like:

• “Add a game over screen that shows the final score.”
• “Make the snake move faster as the score increases.”

How AI Handled Classic Programming Challenges

• Collision Detection: Amazon Q CLI generated code to check if the snake hit itself or the wall.
• Random Food Placement: The AI handled placing food in random locations, avoiding the snake’s body.
• Game Loop: The main loop, event handling, and screen updates were all generated quickly.

Development Automation That Saved Me Time

• Boilerplate Code: Amazon Q CLI wrote the PyGame setup and main loop for me.
• Bug Fixes: When I got errors, I pasted them into the CLI and got instant solutions.
• Feature Additions: Adding new features was as simple as describing them in a prompt.

Interesting AI-Generated Solutions

One clever solution was how the AI managed the snake’s body as a list of coordinates, making it easy to grow the snake and check for collisions.

Example code

import pygame
import random
import sys
from pygame.math import Vector2

# Initialize pygame
pygame.init()

# Game constants
CELL_SIZE = 20
CELL_NUMBER = 20
SCREEN_WIDTH = CELL_SIZE * CELL_NUMBER
SCREEN_HEIGHT = CELL_SIZE * CELL_NUMBER
FPS = 10

# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
WHITE = (255, 255, 255)

class Snake:
    def __init__(self):
        self.body = [Vector2(5, 10), Vector2(4, 10), Vector2(3, 10)]
        self.direction = Vector2(1, 0)
        self.new_block = False

    def draw(self, screen):
        for block in self.body:
            rect = pygame.Rect(block.x * CELL_SIZE, block.y * CELL_SIZE, CELL_SIZE, CELL_SIZE)
            pygame.draw.rect(screen, GREEN, rect)

    def move(self):
        if self.new_block:
            body_copy = self.body[:]
            body_copy.insert(0, body_copy[0] + self.direction)
            self.body = body_copy
            self.new_block = False
        else:
            body_copy = self.body[:-1]
            body_copy.insert(0, body_copy[0] + self.direction)
            self.body = body_copy

    def add_block(self):
        self.new_block = True

    def reset(self):
        self.body = [Vector2(5, 10), Vector2(4, 10), Vector2(3, 10)]
        self.direction = Vector2(1, 0)

    def check_collision(self):
        # Check if snake hits the wall
        if not 0 <= self.body[0].x < CELL_NUMBER or not 0 <= self.body[0].y < CELL_NUMBER:
            return True

        # Check if snake hits itself
        for block in self.body[1:]:
            if block == self.body[0]:
                return True

        return False

class Food:
    def __init__(self):
        self.randomize()

    def draw(self, screen):
        rect = pygame.Rect(self.pos.x * CELL_SIZE, self.pos.y * CELL_SIZE, CELL_SIZE, CELL_SIZE)
        pygame.draw.rect(screen, RED, rect)

    def randomize(self):
        self.x = random.randint(0, CELL_NUMBER - 1)
        self.y = random.randint(0, CELL_NUMBER - 1)
        self.pos = Vector2(self.x, self.y)

class Game:
    def __init__(self):
        self.snake = Snake()
        self.food = Food()
        self.score = 0
        self.font = pygame.font.SysFont('Arial', 25)

    def update(self):
        self.snake.move()
        self.check_collision()
        self.check_fail()

    def draw(self, screen):
        screen.fill(BLACK)
        self.snake.draw(screen)
        self.food.draw(screen)
        self.draw_score(screen)

    def check_collision(self):
        if self.food.pos == self.snake.body[0]:
            self.food.randomize()
            self.snake.add_block()
            self.score += 1

            # Make sure food doesn't appear on snake
            while self.food.pos in self.snake.body:
                self.food.randomize()

    def check_fail(self):
        return self.snake.check_collision()

    def reset(self):
        self.snake.reset()
        self.food.randomize()
        self.score = 0

    def draw_score(self, screen):
        score_text = self.font.render(f'Score: {self.score}', True, WHITE)
        screen.blit(score_text, (10, 10))

def main():
    # Setup
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption('Snake Game')
    clock = pygame.time.Clock()

    game = Game()

    # Game loop
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_UP and game.snake.direction.y != 1:
                    game.snake.direction = Vector2(0, -1)
                if event.key == pygame.K_DOWN and game.snake.direction.y != -1:
                    game.snake.direction = Vector2(0, 1)
                if event.key == pygame.K_LEFT and game.snake.direction.x != 1:
                    game.snake.direction = Vector2(-1, 0)
                if event.key == pygame.K_RIGHT and game.snake.direction.x != -1:
                    game.snake.direction = Vector2(1, 0)

        game.update()

        if game.check_fail():
            game.reset()

        game.draw(screen)
        pygame.display.update()
        clock.tick(FPS)

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()

Screenshots & Gameplay

Final Thoughts

Building Snake with Amazon Q CLI was fast, fun, and educational. The AI made it easy to get started, debug issues, and add new features. I highly recommend trying it out!

Try It Yourself!

Here’s the prompt I used (copy and paste into Amazon Q CLI):

Create a basic Snake game in Python using PyGame. The game should have:
- A snake that moves with arrow keys
- Food that appears randomly
- The snake grows when it eats food
- The game ends if the snake hits the wall or itself
- A score display

Over excited with AMAZON Q CLI , so created another game

🥚 Building an Egg Shooter Game with Amazon Q CLI

For my second project in the Amazon Q CLI campaign, I built a fun Egg Shooter game—similar to Bubble Shooter—using Python and PyGame, with Amazon Q CLI as my coding partner. Here’s how it went!

---

Why Egg Shooter?

I chose Egg Shooter because:

• It’s a classic arcade-style game that’s easy to play and addictive.
• It involves interesting mechanics like aiming, shooting, and matching colors.
• It’s a great way to learn about collision detection and grid management.

---

Effective Prompting Techniques

I started with a detailed prompt:

> Create a simple “Egg Shooter” game in Python using PyGame. The game should have the following features:

> – The player controls a shooter at the bottom center of the screen that can aim left or right using the arrow keys.

> – When the player presses the spacebar, the shooter fires an egg upwards in the direction it is aiming.

> – There are rows of colored eggs at the top of the screen arranged in a grid.> – When the fired egg collides with eggs at the top, it sticks to them.

> – If three or more eggs of the same color are connected, they disappear and the player scores points.

> – The game ends if the eggs reach the bottom of the screen.> – Display the current score at the top.

> – Use simple colored circles to represent eggs.

> – Include comments in the code explaining each part.When I wanted to tweak the game, I used prompts like:

• “Add sound effects for popping eggs.”
• “Show a game over screen with the final score.”

How AI Handled Classic Programming Challenges

• Collision Detection: The AI generated code to detect when the fired egg hit the grid.
• Matching Algorithm: It used a flood-fill algorithm to find and remove groups of matching eggs.
• Grid Management: The AI managed the grid of eggs and handled new eggs being added.

---

Development Automation That Saved Me Time

• Game Loop and UI: Amazon Q CLI set up the main loop, drawing functions, and event handling.
• Bug Fixes: I pasted error messages and got quick, accurate fixes.
• Feature Requests: Adding new features was as simple as describing them in a prompt.

Interesting AI-Generated Solutions

The AI’s use of a recursive function to find connected eggs of the same color was both efficient and easy to understand.

import pygame
import sys
import math
import random
from pygame.locals import *

# Initialize pygame
pygame.init()

# Game constants
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 800
FPS = 60

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
PURPLE = (255, 0, 255)
CYAN = (0, 255, 255)

# List of egg colors
EGG_COLORS = [RED, GREEN, BLUE, YELLOW, PURPLE, CYAN]

# Game parameters
EGG_RADIUS = 20
SHOOTER_WIDTH = 40
SHOOTER_HEIGHT = 60
SHOOTER_SPEED = 5
EGG_SPEED = 10
GRID_ROWS = 5
GRID_COLS = 10
GRID_TOP_MARGIN = 50
GRID_HORIZONTAL_MARGIN = 30

class Shooter:
    """Class representing the player's shooter"""
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = SHOOTER_WIDTH
        self.height = SHOOTER_HEIGHT
        self.angle = 0  # 0 degrees is straight up
        self.color = WHITE
        # Add next egg color
        self.next_egg_color = random.choice(EGG_COLORS)

    def move(self, direction):
        """Move the shooter left or right"""
        self.angle += direction * 3
        # Limit the angle to -60 to 60 degrees
        self.angle = max(-60, min(60, self.angle))

    def draw(self, surface):
        """Draw the shooter on the screen"""
        # Draw the base of the shooter
        base_rect = pygame.Rect(self.x - self.width//2, self.y - self.height//4,
                               self.width, self.height//4)
        pygame.draw.rect(surface, self.color, base_rect)

        # Draw the barrel of the shooter
        # Calculate the end point of the barrel based on the angle
        angle_rad = math.radians(self.angle)
        end_x = self.x + math.sin(angle_rad) * self.height * 0.75
        end_y = self.y - math.cos(angle_rad) * self.height * 0.75

        pygame.draw.line(surface, self.color, (self.x, self.y - self.height//4),
                        (end_x, end_y), 5)

        # Draw the next egg preview
        preview_x = self.x
        preview_y = self.y - self.height//2
        pygame.draw.circle(surface, self.next_egg_color, (int(preview_x), int(preview_y)), EGG_RADIUS//1.5)
        # Draw a small white highlight to make it look like an egg
        highlight_radius = EGG_RADIUS // 5
        highlight_offset = EGG_RADIUS // 6
        pygame.draw.circle(surface, WHITE,
                          (int(preview_x - highlight_offset), int(preview_y - highlight_offset)),
                          highlight_radius)

    def shoot(self):
        """Create a new egg to shoot"""
        angle_rad = math.radians(self.angle)
        direction_x = math.sin(angle_rad)
        direction_y = -math.cos(angle_rad)  # Negative because y increases downward

        # Use the next egg color for the fired egg
        color = self.next_egg_color

        # Generate a new next egg color
        self.next_egg_color = random.choice(EGG_COLORS)

        return Egg(self.x, self.y - self.height//4, direction_x, direction_y, color)

class Egg:
    """Class representing an egg"""
    def __init__(self, x, y, dx=0, dy=0, color=None):
        self.x = x
        self.y = y
        self.dx = dx
        self.dy = dy
        self.radius = EGG_RADIUS
        self.color = color if color else random.choice(EGG_COLORS)
        self.grid_pos = None  # Position in the grid when attached
        self.moving = dx != 0 or dy != 0  # Flag to indicate if the egg is moving

    def update(self):
        """Update the egg's position if it's moving"""
        if self.moving:
            self.x += self.dx * EGG_SPEED
            self.y += self.dy * EGG_SPEED

            # Check if the egg hits the sides of the screen
            if self.x - self.radius < 0 or self.x + self.radius > SCREEN_WIDTH:
                self.dx = -self.dx  # Reverse horizontal direction

            # Check if the egg hits the top of the screen
            if self.y - self.radius < 0:
                self.y = self.radius
                self.moving = False

    def draw(self, surface):
        """Draw the egg on the screen"""
        pygame.draw.circle(surface, self.color, (int(self.x), int(self.y)), self.radius)
        # Draw a small white highlight to make it look like an egg
        highlight_radius = self.radius // 3
        highlight_offset = self.radius // 4
        pygame.draw.circle(surface, WHITE,
                          (int(self.x - highlight_offset), int(self.y - highlight_offset)),
                          highlight_radius)

class EggGrid:
    """Class representing the grid of eggs at the top of the screen"""
    def __init__(self):
        self.eggs = []
        self.init_grid()

    def init_grid(self):
        """Initialize the grid with eggs"""
        for row in range(GRID_ROWS):
            for col in range(GRID_COLS):
                # Calculate position
                x = GRID_HORIZONTAL_MARGIN + col * (EGG_RADIUS * 2 + 5) + EGG_RADIUS
                y = GRID_TOP_MARGIN + row * (EGG_RADIUS * 2 + 5) + EGG_RADIUS

                # Create egg with random color
                egg = Egg(x, y)
                egg.grid_pos = (row, col)
                self.eggs.append(egg)

    def draw(self, surface):
        """Draw all eggs in the grid"""
        for egg in self.eggs:
            egg.draw(surface)

    def check_collision(self, moving_egg):
        """Check if the moving egg collides with any egg in the grid"""
        if not moving_egg.moving:
            return False

        for egg in self.eggs:
            # Skip eggs that are moving
            if egg.moving:
                continue

            # Calculate distance between centers
            distance = math.sqrt((moving_egg.x - egg.x)**2 + (moving_egg.y - egg.y)**2)

            # If distance is less than the sum of radii, they collide
            if distance < moving_egg.radius + egg.radius:
                # Stop the moving egg
                moving_egg.moving = False

                # Calculate grid position for the new egg
                # Find the nearest valid grid position
                nearest_row = round((moving_egg.y - GRID_TOP_MARGIN - EGG_RADIUS) / (EGG_RADIUS * 2 + 5))
                nearest_col = round((moving_egg.x - GRID_HORIZONTAL_MARGIN - EGG_RADIUS) / (EGG_RADIUS * 2 + 5))

                # Ensure the position is within grid bounds
                nearest_row = max(0, min(GRID_ROWS, nearest_row))
                nearest_col = max(0, min(GRID_COLS - 1, nearest_col))

                # Adjust the egg's position to align with the grid
                moving_egg.x = GRID_HORIZONTAL_MARGIN + nearest_col * (EGG_RADIUS * 2 + 5) + EGG_RADIUS
                moving_egg.y = GRID_TOP_MARGIN + nearest_row * (EGG_RADIUS * 2 + 5) + EGG_RADIUS
                moving_egg.grid_pos = (nearest_row, nearest_col)

                # Add the egg to the grid
                self.eggs.append(moving_egg)

                # Check for matches
                return True

        # Check if the egg has reached the top of the screen
        if moving_egg.y - moving_egg.radius <= GRID_TOP_MARGIN:
            moving_egg.moving = False

            # Calculate the column it's in
            nearest_col = round((moving_egg.x - GRID_HORIZONTAL_MARGIN - EGG_RADIUS) / (EGG_RADIUS * 2 + 5))
            nearest_col = max(0, min(GRID_COLS - 1, nearest_col))

            # Place it at the top row
            moving_egg.x = GRID_HORIZONTAL_MARGIN + nearest_col * (EGG_RADIUS * 2 + 5) + EGG_RADIUS
            moving_egg.y = GRID_TOP_MARGIN + EGG_RADIUS
            moving_egg.grid_pos = (0, nearest_col)

            # Add the egg to the grid
            self.eggs.append(moving_egg)

            # Check for matches
            return True

        return False

    def check_matches(self):
        """Check for matches of 3 or more eggs of the same color"""
        # List to store eggs to remove
        to_remove = set()

        # Check each egg
        for egg in self.eggs:
            if egg.moving or egg in to_remove:
                continue

            # Find connected eggs of the same color
            connected = self.find_connected(egg)

            # If there are 3 or more connected eggs, remove them
            if len(connected) >= 3:
                to_remove.update(connected)

        # Remove the matched eggs
        score = len(to_remove)
        self.eggs = [egg for egg in self.eggs if egg not in to_remove]

        return score

    def find_connected(self, egg):
        """Find all eggs of the same color connected to the given egg"""
        connected = set([egg])
        to_check = [egg]

        while to_check:
            current = to_check.pop()

            # Check all eggs for connections
            for other in self.eggs:
                if other.moving or other in connected:
                    continue

                # If the eggs are the same color and adjacent
                if other.color == current.color and self.are_adjacent(current, other):
                    connected.add(other)
                    to_check.append(other)

        return connected

    def are_adjacent(self, egg1, egg2):
        """Check if two eggs are adjacent in the grid"""
        if not egg1.grid_pos or not egg2.grid_pos:
            return False

        row1, col1 = egg1.grid_pos
        row2, col2 = egg2.grid_pos

        # Check if they're neighbors (horizontally, vertically, or diagonally)
        return abs(row1 - row2) <= 1 and abs(col1 - col2) <= 1

    def check_game_over(self):
        """Check if any eggs have reached the bottom of the screen"""
        bottom_threshold = SCREEN_HEIGHT - 100

        for egg in self.eggs:
            if egg.y + egg.radius >= bottom_threshold:
                return True

        return False

class Game:
    """Main game class"""
    def __init__(self):
        # Set up the display
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('Egg Shooter')
        self.clock = pygame.time.Clock()

        # Create game objects
        self.shooter = Shooter(SCREEN_WIDTH // 2, SCREEN_HEIGHT - 50)
        self.grid = EggGrid()
        self.moving_eggs = []

        # Game state
        self.score = 0
        self.game_over = False

        # Font for text
        self.font = pygame.font.SysFont('Arial', 24)

    def handle_events(self):
        """Handle user input"""
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()

            if event.type == KEYDOWN:
                if event.key == K_SPACE and not self.game_over:
                    # Shoot an egg
                    self.moving_eggs.append(self.shooter.shoot())

        # Handle continuous key presses
        if not self.game_over:
            keys = pygame.key.get_pressed()
            if keys[K_LEFT]:
                self.shooter.move(-1)
            if keys[K_RIGHT]:
                self.shooter.move(1)

    def update(self):
        """Update game state"""
        if self.game_over:
            return

        # Update moving eggs
        for egg in self.moving_eggs[:]:  # Create a copy of the list to safely modify during iteration
            egg.update()

            # Check for collisions with the grid
            if self.grid.check_collision(egg):
                # Remove the egg from moving eggs
                self.moving_eggs.remove(egg)

                # Check for matches
                points = self.grid.check_matches()
                self.score += points * 10  # 10 points per egg

        # Check if game is over
        if self.grid.check_game_over():
            self.game_over = True

    def draw(self):
        """Draw the game"""
        # Clear the screen
        self.screen.fill(BLACK)

        # Draw the grid
        self.grid.draw(self.screen)

        # Draw moving eggs
        for egg in self.moving_eggs:
            egg.draw(self.screen)

        # Draw the shooter
        self.shooter.draw(self.screen)

        # Draw the score
        score_text = self.font.render(f"Score: {self.score}", True, WHITE)
        self.screen.blit(score_text, (10, 10))

        # Draw next egg text
        next_text = self.font.render("Next:", True, WHITE)
        self.screen.blit(next_text, (SCREEN_WIDTH - 100, 10))

        # Draw game over message if game is over
        if self.game_over:
            game_over_text = self.font.render("GAME OVER", True, RED)
            text_rect = game_over_text.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2))
            self.screen.blit(game_over_text, text_rect)

            restart_text = self.font.render("Press R to restart", True, WHITE)
            restart_rect = restart_text.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2 + 40))
            self.screen.blit(restart_text, restart_rect)

        # Update the display
        pygame.display.flip()

    def run(self):
        """Main game loop"""
        while True:
            self.handle_events()
            self.update()
            self.draw()
            self.clock.tick(FPS)

            # Check for restart
            if self.game_over:
                keys = pygame.key.get_pressed()
                if keys[K_r]:
                    self.__init__()  # Reset the game

# Start the game
if __name__ == "__main__":
    game = Game()
    game.run()

Screenshots & Gameplay

First i was confused what was the egg shooter ball color and again asked to add ball color to code

Try It Yourself!

Here’s the prompt I used (copy and paste into Amazon Q CLI):

Create a simple "Egg Shooter" game in Python using PyGame. The game should have the following features:
- The player controls a shooter at the bottom center of the screen that can aim left or right using the arrow keys.
- When the player presses the spacebar, the shooter fires an egg upwards in the direction it is aiming.
- There are rows of colored eggs at the top of the screen arranged in a grid.
- When the fired egg collides with eggs at the top, it sticks to them.
- If three or more eggs of the same color are connected, they disappear and the player scores points.
- The game ends if the eggs reach the bottom of the screen.
- Display the current score at the top.
- Use simple colored circles to represent eggs.
- Include comments in the code explaining each part.

My Honest Review of Building with Amazon Q CLI

When I first heard about Amazon Q CLI, I was both curious and a little skeptical. I’ve used various coding assistants before, but the idea of a command-line AI that could help me build entire projects—especially games—sounded almost too good to be true. After spending some real time with it, I want to share my honest thoughts, both the good and the not-so-good, in hopes it helps others considering giving it a try.

---

First Impressions

Setting up Amazon Q CLI was straightforward. The documentation was clear, and I appreciated that it worked right from my terminal, which is where I’m most comfortable. The interface felt familiar, almost like chatting with a very knowledgeable friend who just happens to live in my command line.

---

The Experience: Collaboration, Not Just Automation

What struck me most was how collaborative the process felt. Instead of just spitting out code snippets, Amazon Q CLI engaged in a back-and-forth. I’d describe what I wanted, sometimes in very broad strokes, and it would ask clarifying questions or suggest approaches I hadn’t considered. It felt less like using a tool and more like pair programming with someone who never gets tired or frustrated.There were moments when I was genuinely surprised by the AI’s suggestions. Sometimes it would recommend a more efficient algorithm or point out a potential bug before I even ran the code. Other times, it would generate code that was well-structured and commented, making it easy to understand and modify.

---

Prompting: The Art of Asking

One thing I quickly learned is that the quality of the output depends a lot on the quality of your prompts. Being specific and clear made a huge difference. When I was vague, the results were hit-or-miss, but when I described exactly what I wanted, Amazon Q CLI delivered impressively accurate and relevant code.I also appreciated that I could iterate. If something didn’t work quite right, I could just paste the error message or describe the issue, and the AI would help me debug or refactor. This iterative loop made the development process feel natural and productive.

---

Where It Shines

• Speed: Tasks that would have taken me hours—like setting up boilerplate code, handling edge cases, or writing documentation—were done in minutes.
• Learning: I found myself learning new techniques and best practices just by reading the code Amazon Q CLI generated. It’s like having a mentor who explains their reasoning as they go.
• Debugging: When I hit a wall, the AI was quick to suggest fixes or alternative approaches, often saving me from long, frustrating debugging sessions.
• Creativity: Sometimes, the AI would suggest features or improvements I hadn’t even thought of, sparking new ideas and directions for my project.

---

Where It Struggles

• Complex, Multi-Step Tasks: For very complex features that required a lot of context or multiple steps, I sometimes had to break things down into smaller prompts. The AI is great at focused tasks, but can get lost if you ask for too much at once.
• Understanding Ambiguity: If I wasn’t clear in my instructions, the results could be unpredictable. It’s not a mind reader—clear communication is key.
• Occasional Bugs: While most of the code worked out of the box, there were times when I had to tweak or debug the output. This wasn’t a dealbreaker, but it’s important to stay engaged and review the code carefully.

---

The Human Element

What I appreciated most was how Amazon Q CLI made coding feel less lonely. Even though I was working solo, the AI’s presence made it feel like a team effort. It was encouraging, responsive, and always ready to help—no matter how late at night I was working.I also found myself experimenting more. Knowing I had a safety net made me bolder in trying new ideas, since I could always ask the AI for help if I got stuck.

---

Final Thoughts

Amazon Q CLI isn’t magic, but it’s the closest thing I’ve experienced to having a tireless, knowledgeable coding partner. It accelerates the boring parts, helps you learn, and makes the creative process more fun and less stressful. Like any tool, it has its limitations, but with clear communication and a willingness to iterate, it can be an incredible asset.If you’re curious about AI-assisted development, I highly recommend giving Amazon Q CLI a try. It won’t replace your skills or creativity, but it will amplify them—and maybe even teach you a few new tricks along the way.