AI GamingGPT & Claude

IndieQA

Target user IndieQA is designed for: - Solo game developers - Small indie studios - Small QA teams - Developers using Unity, Godot, Pygame, or similar 2D engines Problem Small studios often cannot afford continuous manual QA. Human testers may miss physics bugs that occur only under unusual movement combinations, such as: - Walking or jumping through walls - Falling forever through a missing floor boundary - Becoming trapped in an unreachable pit - Leaving the playable map - Being unable to reproduce the exact input sequence that caused the failure These bugs are expensive because they can survive until launch and lead to negative reviews, emergency patches, and lost development time. Solution IndieQA automatically plays the game, deliberately stresses boundaries and collision areas, records every frame, detects physics anomalies, and reports: - What failed - Where it failed - When it failed - Which inputs caused it - How developers can reproduce and investigate it This gives small studios a repeatable physics-testing workflow at a much lower cost than continuous manual testing.

Video GitHub

Preliminary score

66.0/ 100Promisingaverage of 2 judges

Value for the user19.0 / 25
A specific problem and a clear outcome from solving it.
Prototype and use of AI16.5 / 30
A working core scenario, and what AI actually contributes to the result.
Quality testing17.0 / 20
Tests, examples of failures, and comparison with the current approach.
Feasibility7.5 / 15
Data requirements, running costs and a clear next step.
Originality6.0 / 10
A meaningful difference from common solutions.

What the judges wrote

GPT-6 AstraPreliminary70/100
Strengths
Your project addresses a concrete indie-developer pain and makes failures actionable through frame-level telemetry and reproducible input sequences. Your ground-truth verification, cross-laptop determinism checks and detailed explanations of detector failures provide strong testing evidence. You also clearly distinguish the reported 318/318 detections on your planted-bug level from the generalisation work still needed.
To improve
Your next tests should use unseen levels with fixed detector settings, preserve the game's original physics, and compare against random-input and manual-QA baselines. Show how your agent chooses actions and quantify what its AI adds beyond scripted checks or random exploration. Document the instrumentation and integration needed for a real Unity or Godot game, along with compute costs and a concrete pilot plan.
Claude Opus 5.5Preliminary62/100
Strengths
Your testing write-up is excellent: you planted three bugs with engine-recorded ground truth and built a --verify mode that counts hits, misses and false alarms. You also documented real failures and their fixes, such as 4,932 Out of Bounds reports masking the other checks, the softlock baseline, the 95px versus 100px jump, and the inflated bug counts. Seeded reproducibility (7,200 of 7,200 frames, confirmed on a second laptop) and root-cause linking of side effects make the reports useful to a developer. The target user, solo and small indie studios fighting physics bugs, is specific and the pain is credible.
To improve
The AI contribution is unclear from your materials: the agent appears to be seeded random or scripted input and the detector is threshold rules, so explain what is learned or intelligent, or add a learning or LLM component that clearly improves bug discovery. Your softlock detection depends on the pit position from the level layout, and everything was tested only on your own level, so run it on at least one unmodified open-source Godot or Pygame game. Add running costs, a comparison against manual QA time or cost, and a concrete integration path for Unity or Godot. Your GitHub README is only a title; put the setup and verification steps there.

The team

Muhammad Gasimov
data
Şakir HəsənovLead
product
İbrahimli Fəxrəddin /Email
developer
Tofiq Həşimli /Email
developer

Disclosure

Required by the rules. Judges verify it against the repository.

Models: Autonomous QA agent,Bug detector, Reporter
Data: Synthetic
Components: game engine, autonomus agent, telementry,bug detection,report generation, dashboard, visualizaton, data processing, chatbot advisor, testing
Built during the event: Confirmed

Quality testing

How we tested. We built our own test level with 3 bugs planted on purpose: a Wall Clip (a 2px seam in a wall), an Infinite Fall (a hole with no bottom) and a Softlock pit (150px deep, while the player can only jump 100px). Because we know exactly where and when these bugs happen, the game engine can record the ground truth. We then wrote an automatic check, main.py --verify, which compares what our detector reports against what really happened, for every life the bot plays: bugs found, missed, and false alarms. On top of that we used: Self-tests for each module: engine 5 checks, telemetry 6, agent 5. 10 unit tests for the detector. Automated tests of the dashboard. Manual play-testing of the level by keyboard. Live tests with the game and the website running side by side. What broke, and how we fixed it: Our first end-to-end run detected none of the 3 bugs. It produced 4,932 “Out of Bounds” reports and nothing else, because the Out of Bounds check ran first and stopped the other checks from running. We changed it so all checks run on every frame, and each problem is reported once instead of once per frame. Softlock could never be detected. The detector measured movement from the first button press, but our bot never stops pressing buttons. We changed it to compare against the position 300 frames earlier. The jump was “100px” in the code but 95px in reality, because the physics advances in fixed steps of 1/60 second. We calculated the right jump strength and verified it reaches exactly 100.0px. False alarms from normal movement: fast falls could have looked like wall clips. We capped normal fall speed so legitimate movement never exceeds 16.2px per frame, then confirmed no false alarms in 20,000 frames of random input. The website always showed 0 bugs, because nothing generated the bug reports it reads. We connected the pipeline so one command runs the game, the detection and the reports. The live view lagged, because telemetry was buffered in memory. We now write every batch to disk immediately; we confirmed the file had 166 rows after 2 seconds and 386 after 4. The bug count was inflated: falling forever after a wall clip was counted as a separate bug. We now link side effects to their root cause, so the priority list shows only real problems. Results: On 4 different runs (40 minutes of gameplay), the detector found 318 of 318 real bugs (81 Wall Clips, 163 Infinite Falls, 74 Softlocks) with 0 false alarms. The bot finds all 3 bugs on its own, in under 15 seconds with seed 11. The same seed gives identical results on every rerun: 7,200 of 7,200 frames, also confirmed on a second laptop. 10 minutes of gameplay are tested in about 2.5 seconds. Known limitations: Tested only on our own level, with bugs we planted. The detection limits are tuned to standard platformer physics, such as more than 25px in one frame for a wall clip. Softlock detection uses the pit’s position from the level layout, so it would need generalising for new levels.

Worth 20 of the 100 points.

Running it

Install Python 3.11 or newer, then clone the repository: git clone https://github.com/GasimovDev/indieQA_bot.git cd indieQA_bot Create a virtual environment and install the required packages. On Windows: python -m venv venv .\venv\Scripts\Activate.ps1 python -m pip install -r requirements.txt On macOS or Linux: python3 -m venv venv source venv/bin/activate python -m pip install -r requirements.txt To run the full verification: python main.py --headless --frames 36000 --verify This runs the game simulation, analyzes the recorded telemetry, checks the planted bugs, and creates the diagnostic reports. To run the tests: python -m unittest discover -s tests To open the dashboard: streamlit run dashboard/app.py Open the local address shown in the terminal, usually: http://localhost:8501 For the live demo, keep the dashboard open and run this command in another terminal: python main.py --seed 11 The bot will explore the level while the dashboard displays its movement trail and detected failure points. The demo includes three intentional bugs: - Wall Clip - Infinite Fall - Softlock If no telemetry is shown, run: python main.py --headless --frames 36000 --analyze Then refresh the dashboard.

Project ownership

The team keeps the rights to this project. Judges were given access for verification only.