Building a Viral Trend Game in My Terminal with Amazon Q Developer CLI agent
Discover how I turned that ridiculous ice-water-dunking morning routine trend into a Universal Paperclips-style incremental game—all without leaving my terminal!
Brooke Jamieson
Amazon Employee
Published Mar 25, 2025
That viral ice-water-dunking morning routine kept showing up in my feed, and I couldn't help but think it would make a perfect parody in the style of Universal Paperclips—you know, that incremental game where you slowly convert the entire universe into paperclips? So I decided to build a game called "Morning Routine Maximizer" that combines both concepts. And the best part? I built the entire thing without leaving my terminal, thanks to Amazon Q Developer CLI agent.
In this post, I'll walk you through how I created this ridiculous game in one conversation, added some fun hustle culture references, and even got an optimal strategy guide—all from my terminal!
If you're more of a video person not a blog person, see a video version of this post on my LinkedIn!
If you haven't tried Amazon Q Developer CLI agent yet, it's super handy for developers who feel at home working in the terminal. Unlike previous versions that could just answer questions, this version is agentic—so it can execute commands, write files, and actually get things done for you, all without leaving your terminal workflow.
After installing, I just typed
This opened up a conversation with Amazon Q in my terminal. From there, I asked it to navigate to my project folder:
q chat to start.This opened up a conversation with Amazon Q in my terminal. From there, I asked it to navigate to my project folder:
1
> go to the morning-routine folder on my desktop pleaseAmazon Q navigated to the folder using a simple bash command, so I didn’t need to type
cd~/Desktop/morning-routine myself!Once in the right folder, I described my game concept in detail:
1
2
3
4
5
6
7
8
9
10
11
12
> I want to build a simple Python game called "Morning Routine Maximizer" that parodies both the Universal Paperclips incremental game and viral morning routine videos.
The game should start with the player as a morning routine enthusiast who clicks a button labeled "Dunk Face in Ice Water" to earn 1 Productivity Point per click.
The screen should display two main counters: "Face Dunks: X" and "Productivity Points: X".
Once the player reaches 10 Productivity Points, they unlock the ability to purchase a banana.
After buying a banana, two new buttons appear: "Eat Banana" and "Rub Face with Peel" (this second button should only become active after eating).
Eating a banana generates 2 Productivity Points, and rubbing the peel on your face generates 5 Productivity Points.
As the player accumulates more points, they unlock automation options like "Auto-Dunker" (costs 50 points) which performs one face dunk per second, and "Banana Peeler" (costs 100 points) which processes bananas automatically.
Later upgrades should include "Multiple Ice Bowls" and "Banana Farm".
Eventually, players start converting matter around them into ice water and banana peels, tracking this with a "Universe Conversion" percentage.
The endgame involves converting the entire universe, with victory at 100% conversion.
Keep the interface minimalist with just text buttons and counters, and include occasional humorous pop-up messages about optimizing productivity.
This could be implemented using PyGame or even a terminal-based interface, with a simple game loop that tracks resources and updates the display.My prompt was detailed, covering everything from the initial clicking mechanics to the endgame victory condition. This level of detail is important when you want Amazon Q to generate something specific.
Now - the magic happens! Amazon Q analyzed my requirements and generated a complete PyGame application with all the mechanics I asked for! It:
- Created a Python file with over 300 lines of code
- Implemented the core mechanics (face dunking for productivity points)
- Added resource management (bananas, auto-dunkers, etc.)
- Created a proper game loop with increasing difficulty
- Added humorous messages about productivity
- Generated a README with installation instructions
All of this happened in a single response! The game included everything from buttons for "Dunk Face in Ice Water" to automation systems like "Auto-Dunker" and "Banana Peeler"—exactly as I had requested.
Once the files were created, I asked Amazon Q to run the game:
Once the files were created, I asked Amazon Q to run the game:
1
> run the game pleaseAfter a quick adjustment (using
python3 instead of python- which it picked up on and fixed automatically), the game was up and running on my screen. I had a fully functional incremental game that let me (virtually) dunk my face in ice water to earn those sweet, sweet, Productivity Points!The game worked fine, but it didn’t feel fully complete without getting into the grindset with some inside jokes about hustle culture. So I asked:
> Now I want it to be more "in on the joke" with some self aware joke encouragement for "hustle culture" and "grindset" during the game.Amazon Q didn't disappoint! It updated various parts of the game to incorporate over-the-top hustle culture satire:
> Now I want it to be more "in on the joke" with some self aware joke encouragement for "hustle culture" and "grindset" during the game.Amazon Q didn't disappoint! It updated various parts of the game to incorporate over-the-top hustle culture satire:
- Added new messages like "While others sleep, you GRIND! #RiseAndGrind #IceDunkNation"
- Changed "Eat Banana" to "Eat Banana Like a CEO"
- Replaced "Rub Face with Peel" with "Biohack Face with Peel"
- Added stats like "Hustle Level" and "Sigma Grindset: ACTIVATED"
- Updated the victory message to include "Your LinkedIn profile now reads: 'Universe Optimization Specialist'"
- Renamed the game to "Morning Routine Maximizer: Sigma Edition"
These changes seemed small, but really helped to transform this from a simple game into something that really felt spot on. All these changes were done through natural conversation in my terminal, without me having to edit any code directly, or even open my IDE.
Once the game was complete, I was curious about the optimal way to play it. So I asked:
1
2
> This is great. Now I want to talk strategy.
Based on your knowledge of the game mechanics, what are the most optimal first 50 moves in order?The agent analyzed the game mechanics it had just created and provided a detailed strategy guide, breaking down it’s recommendations into game stage.
Here’s the recommendations:
Here’s the recommendations:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
### Early Game (First 10-15 Moves)
1-10. Manually dunk your face in ice water 10 times to reach 10 Productivity
Points (PP)
11. Buy your first banana (costs 10 PP)
12. Eat the banana (+2 PP)
13. Use the banana peel on your face (+5 PP)
14-25. Continue manually dunking your face to accumulate more PP
### Mid-Early Game (Moves 26-35)
26. Buy another banana when you reach 10 PP
27. Eat the banana
28. Use the banana peel
29-34. Continue manually dunking and saving PP
### First Automation (Moves 35-45)
35. Buy an Auto-Dunker once you reach 50 PP
• This is a critical investment as it generates 1 PP per second without
manual clicking
36-40. Continue manually dunking while your Auto-Dunker works
41. Buy another banana
42. Eat the banana
43. Use the banana peel
44-45. Continue dunking while saving for your next upgrade
### Scaling Up (Moves 46-50)
46-49. Continue dunking and collecting PP from your Auto-Dunker
50. Buy a Banana Peeler when you reach 100 PP
• This is your next major milestone as it automates banana processing
### Strategy Notes:
• The Auto-Dunker (50 PP) should be your first major purchase as it provides
passive income
• The Banana Peeler (100 PP) is your second priority for automation
• After these first 50 moves, focus on saving for an additional Ice Bowl (200 PP
) which multiplies your dunking effectiveness
• Banana Farms (500 PP) come later but are essential for scaling your banana
operations
This strategy maximizes your early PP generation by balancing manual actions
with strategic investments in automation, following the classic incremental game
pattern of "click to earn, spend to automate, scale to win."Truly, nothing felt more on-brand for this game than when the strategy recommended prioritizing the Auto-Dunker (50 PP) as the first major purchase since it provides passive income - truly in the grindset mindset.
To finish the project, I asked Amazon Q to add the strategy guide to the README:
1
> Can you add this to the README?It immediately updated the README.md file (did I mention it made a full readme file for me earlier, without me even having to ask?), adding a new "Optimal Strategy Guide" section with all the details from our conversation. The docs now have both basic game information and advanced strategy tips.
What amazes me about this experience is that the entire development process happened in a single conversation within my terminal:
- Navigating to the project directory
- Describing the game concept
- Generating and writing all the code
- Running the game
- Making substantial enhancements
- Getting strategy advice
- Updating documentation
I didn't need to switch to my IDE, look up PyGame documentation, or manually edit any files. Everything happened through a conversational interface right in my terminal.
This might seem like a silly example—after all, I built a game about dunking your face in ice water and rubbing banana peels on your face—but it demonstrates something really powerful. Amazon Q Developer CLI agent lets you stay in your command line while getting complex tasks done through natural conversation.
For developers who prefer a terminal-centric workflow, this means:
For developers who prefer a terminal-centric workflow, this means:
- Fewer context switches between terminal, browser, and IDE
- Faster implementation of ideas (even weird, trendy ones!)
- Complete development cycles without leaving your preferred environment
- The ability to make substantial changes through conversation
Whether you're building a meme game or a serious application, being able to go from concept to implementation without leaving your terminal is a huge productivity boost.
If you're curious about Amazon Q Developer CLI agent, give it a try for your next project! It's available in both Free and Pro tiers across all AWS regions where Q Developer is supported.
The simple command to get started is just
q chat in your terminal after installation. From there, you can navigate directories, generate code, execute commands, and build entire applications—all while staying in your terminal flow.What 'terminally online' trend should I code next? I'd love to hear your ideas in the comments below!
Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.
Comments
Log in to comment