Welcome to the Gemini CLI Game Challenges at DevFest 2026! These games give participants an opportunity to use AI-assisted development to solve practical programming challenges.
Event Information
- Event: DevFest 2026
- Organizer: Google Developer Group (GDG) Ranchi
- Challenge format: Individual participation
- Tool: Gemini CLI
- Time limit: 5–10 minutes, depending on the game
- Participation rule: Each participant can participate in only one game.
Available Games
| Game | Time Limit | Maximum Score |
|---|---|---|
| UI Makeover Challenge | 5–10 minutes | 100 points |
| Bug Hunt Challenge | 5–10 minutes | 100 points |
| Build It with One Prompt | 5–7 minutes | 50 points |
General Rules
- Each participant can participate in only one game.
- The organizer will assign one of the three challenges to you.
- Complete the challenge within the given time limit.
- Use Gemini CLI to help you understand, modify, debug, or build the project.
- Read the task carefully before asking Gemini CLI for help.
- You must be able to explain the changes you make.
- Your final work should run or behave as expected, wherever applicable.
- Do not copy another participant's solution.
- Inform the organizer if you encounter a problem with the starter project or challenge instructions.
- The organizer's decision will be final.
Game 1: UI Makeover Challenge
1.1 Objective
You will receive an existing website or web application. Your task is to improve its user interface (UI) with the help of Gemini CLI.
A website may work correctly but still look outdated, confusing, or unprofessional. Your job is to improve its appearance and usability without breaking its existing functionality.
Your goal: Make the provided interface cleaner, more attractive, easier to use, and responsive.
1.2 Time Limit
5–10 minutes
Focus on the most important improvements instead of trying to redesign every part of the application.
1.3 Challenge Requirements
A. Visual Design
- Improve the overall layout and spacing.
- Use consistent colors and typography.
- Make headings, buttons, cards, and other elements visually consistent.
- Remove unnecessary clutter.
- Make the page look professional and organized.
B. Responsiveness
- Ensure the interface adapts to smaller screens.
- Prevent text, buttons, and cards from overflowing.
- Keep content readable on mobile and desktop screens.
- Ensure important actions remain accessible on smaller devices.
C. Functionality
- Preserve existing working features.
- Make buttons and interactive elements behave correctly.
- Fix obvious interaction issues caused by your changes.
- Avoid introducing errors while updating the design.
D. Creativity
- Give the interface a clear visual identity.
- Make thoughtful design decisions.
- Improve the user experience instead of simply changing colors.
1.4 Suggested Workflow
- Open the provided project.
- Inspect the existing interface.
- Identify the biggest design problems.
- Use Gemini CLI to help improve the UI.
- Review the code changes.
- Run the project and inspect the result.
- Check the interface at different screen sizes.
- Show the final result to the judge.
You do not need to rewrite the entire application. Focus on making meaningful improvements within the time limit.
1.5 Example Prompt
The following prompt is an illustration of how you might communicate your requirements to Gemini CLI. It is not the actual challenge prompt.
Improve the existing website's user interface. Make the layout cleaner,
improve spacing and typography, use a consistent color scheme, and
ensure that the page works well on mobile and desktop screens.
Preserve existing functionality, avoid unnecessary dependencies, and
run the project to check for errors.
You can write your own prompt based on the actual project and the improvements you want.
1.6 Starter Project
Reference repository: abhishek-nexgen-dev/gdg-ranchi-ui-challenge
Live Link: Live Demo
The organizer will provide the designated starter project and explain which files or screens you should improve.
1.7 Scoring Criteria
Maximum Score: 100 points
| Evaluation Area | Points | What the Judge Checks |
|---|---|---|
| Design Quality | 40 | Visual appeal, layout, spacing, typography, and consistency |
| Responsiveness | 30 | Usability on mobile and desktop screens |
| Functionality | 20 | Whether existing features still work correctly |
| Creativity | 10 | Originality and thoughtful improvements |
| Total | 100 |
1.8 Tips for Success
- Prioritize the most visible design problems.
- Keep the layout clean and consistent.
- Test the interface on a narrow screen.
- Preserve existing features.
- Be ready to explain your design choices.
Remember: A beautiful design that breaks the application is not a successful solution.
Game 2: Bug Hunt Challenge
2.1 Objective
You will receive a project containing a software bug.
A bug is a mistake in software that causes it to behave incorrectly or prevents a feature from working as expected.
Your task is to find the problem, understand why it occurs, fix it with the help of Gemini CLI, and verify that the solution works.
Your goal: Identify the bug, implement a correct fix, and demonstrate that the application behaves as expected.
2.2 Time Limit
5–10 minutes
Focus on finding and fixing the relevant problem rather than rewriting the entire project.
2.3 Challenge Requirements
A. Identify the Bug
- Run or inspect the application.
- Understand what is going wrong.
- Identify the relevant code.
- Determine the likely cause of the issue.
B. Fix the Problem
- Make the smallest appropriate change that solves the issue.
- Avoid unrelated changes.
- Preserve existing functionality.
- Address the actual cause instead of hiding the symptom.
C. Test the Fix
- Run the application or the relevant test.
- Reproduce the original problem if possible.
- Check that the expected behavior now works.
- Ensure that the fix has not introduced an obvious new problem.
D. Explain Your Solution
Be ready to explain:
- What was the bug?
- Why did it happen?
- Which change fixed it?
- How did you verify the fix?
You do not need to memorize every line of code. You should understand the problem and the reasoning behind your solution.
2.4 Suggested Workflow
- Read the task description carefully.
- Run the project or inspect the relevant code.
- Reproduce the problem if possible.
- Ask Gemini CLI to investigate the relevant behavior.
- Review the suggested explanation and code changes.
- Apply an appropriate fix.
- Run the relevant test or reproduce the scenario again.
- Explain the problem and your fix to the judge.
Do not blindly accept every suggestion from Gemini CLI. Check whether the suggested fix addresses the reported issue.
2.5 Example Scenario
The following scenario is provided for understanding only. It is not the actual bug participants will receive.
Imagine an application has a button labeled Add Item. When you click the button, the item appears twice instead of once.
An illustrative prompt could be:
Investigate why the Add Item button adds an item twice.
Inspect the relevant code, identify the root cause, and suggest the
smallest safe fix. Explain how I can verify that the item is added
only once.
This example demonstrates the debugging process. The actual issue will be provided by the organizer.
2.6 Starter Project
Reference repository: zaidu06xk/Bug-Hunt
The organizer will provide the designated project or a prepared version containing a reproducible bug. Follow the instructions for the specific issue assigned to you.
2.7 Scoring Criteria
Maximum Score: 100 points
| Evaluation Area | Points | What the Judge Checks |
|---|---|---|
| Bug Identification | 30 | Correctly identifies the relevant bug |
| Working Fix | 40 | Implements a correct solution without unnecessary changes |
| Testing | 20 | Verifies the fix with an appropriate test or reproducible check |
| Explanation | 10 | Clearly explains the cause and solution |
| Total | 100 |
2.8 Tips for Success
- Find the root cause instead of guessing.
- Make a focused and appropriate change.
- Verify the result instead of assuming the fix works.
- Explain the problem in simple words.
- Avoid unrelated refactoring.
Remember: Finding a bug is only part of the challenge. A working, verified fix earns the most points.
Game 3: Build It with One Prompt
3.1 Objective
In this game, you will build a small application using Gemini CLI by giving it one build prompt.
The organizer will assign an application-building task. Your job is to understand the requirements, write a clear prompt, and let Gemini CLI generate the implementation.
This game tests how clearly you can describe a problem and how effectively you can guide an AI coding tool with a single prompt.
Your goal: Build a working application using one well-written build prompt.
3.2 Time Limit
5–7 minutes
Think carefully about the requirements before submitting your prompt.
3.3 The One-Prompt Rule
This is the most important rule of the game.
- You may inspect the provided project and read the task before writing your prompt.
- You may give Gemini CLI one build prompt to implement the requested application.
- Your prompt should include the important requirements, functionality, and design expectations.
- After submitting your build prompt, you may inspect the generated code, run the application, and demonstrate the result.
- You may not submit another prompt asking Gemini CLI to modify, improve, fix, or add features to the generated application.
- You may not use another AI coding tool to make changes after the build prompt.
- If the generated application has a problem, you may explain the issue to the judge, but you cannot request a second build or correction prompt.
The organizer may clarify the task before the timer begins. That clarification does not count as a build prompt.
3.4 Challenge Requirements
A. Understand the Requirements
Identify the application's main purpose and the features it must support.
B. Write One Clear Prompt
Your prompt should describe:
- The application's purpose.
- The required features.
- How users will interact with it.
- The expected interface.
- Relevant technical restrictions.
- How the application should be run.
C. Generate the Application
Submit your single build prompt to Gemini CLI and allow it to create the implementation.
D. Run and Demonstrate It
Run the generated application if time permits. Show the judge which required features work and explain any limitations.
You are judged on the result of your single prompt, not simply on how long or complicated the prompt is.
3.5 Example Tasks
The following are examples of the types of applications that could be built. They are not guaranteed to be the actual event tasks.
- To-do List: Add tasks, mark them complete, and remove them.
- Calculator: Perform basic arithmetic operations.
- Countdown Timer: Set a duration and start, pause, or reset the timer.
- Student Marks Calculator: Enter marks and calculate the total and percentage.
- Expense Tracker: Enter expenses and display the total amount spent.
The organizer will provide the actual task for your round.
3.6 Example Prompt
Suppose the assigned task is to build a to-do list. The following illustrates how a participant might describe the requirements in one prompt. It is not the actual prompt for the event.
Build a simple, responsive to-do list application using the existing
project's technology stack.
Users should be able to add tasks, mark tasks as completed, and delete
them. Show completed and pending tasks clearly, handle empty task
input, and provide a clean, mobile-friendly interface.
Use readable code, avoid unnecessary dependencies, and make sure the
application can run using the project's existing setup.
A good prompt is not necessarily the longest prompt. It is one that communicates the important requirements clearly and leaves less room for misunderstanding.
3.7 Starter Project
The organizer will provide the starter project and the actual application-building task.
Use the provided project and its existing technology stack unless the task explicitly allows otherwise.
3.8 Scoring Criteria
Maximum Score: 50 points
| Evaluation Area | Points | What the Judge Checks |
|---|---|---|
| Requirements Coverage | 20 | How well the generated application meets the assigned requirements |
| Functionality | 15 | Whether the required features work |
| Prompt Quality | 10 | Clarity, completeness, and organization of the single build prompt |
| Successful Run | 5 | Whether the application starts and can be demonstrated |
| Total | 50 |
3.9 Tips for Success
- Read the task carefully before writing your prompt.
- Include the essential requirements in your first prompt.
- Describe user interactions clearly.
- Avoid vague instructions such as "make a good app."
- Keep the requested features achievable within the time limit.
- Use the existing technology stack.
- Run and demonstrate the generated application.
Remember: You get only one build prompt. Think first, write clearly, and then build.
Final Reminder
Before your round begins, make sure you understand which game you have been assigned.
| Game | Main Skill Being Tested |
|---|---|
| UI Makeover Challenge | Improving design, responsiveness, and usability |
| Bug Hunt Challenge | Finding, fixing, and testing software bugs |
| Build It with One Prompt | Writing a clear prompt and generating a working application |
You do not need to know everything in advance. The purpose of these games is to demonstrate how effectively you can use Gemini CLI to solve practical development problems.
Understand the task. Use the tool thoughtfully. Test your work. Explain your decisions.
Good luck, and enjoy DevFest 2026!
Google Developer Group (GDG) Ranchi
Top comments (0)