How to Set Up and Configure the QA Testing Framework in Claude Code Game Studios

Run the /test-setup command to automatically scaffold a language- and engine-specific tests/ hierarchy, configure the appropriate test runner, and wire a GitHub Actions CI pipeline for continuous integration.

The Claude Code Game Studios repository provides a sophisticated QA testing framework that automates the creation of testing infrastructure for game projects. To set up and configure the QA testing framework, developers use the /test-setup skill, which detects the game engine from technical-preferences.md and generates the complete testing scaffold including unit, integration, performance, and playtest directories.

What /test-setup Does to Configure Your QA Framework

According to the CCGS Skill Testing Framework/skills/utility/test-setup.md source specification, the /test-setup skill performs a sequence of automated steps to establish the testing environment.

Engine Detection

The skill first reads technical-preferences.md (or checks the engine set by /setup-engine) to determine whether the project uses Godot, Unity, or Unreal Engine. This detection step ensures that all subsequent configurations match the project's language and runtime requirements.

Directory Structure Creation

Based on the detected engine, the skill generates the appropriate directory tree:

• Godot/GDScript: Creates tests/unit/, tests/integration/, tests/performance/, and tests/playtest/
• Unity: Creates Tests/ with Unity-style .asmdef assembly definition files
• Unreal: Creates an Unreal headless runner folder structure

Test Runner Configuration

The skill writes engine-specific runner configurations:

• Godot: Adds tests/gdunit4_runner.gd and a matching CI command (godot --headless --script …)
• Unity: Creates Tests/Tests.asmdef and Tests/Editor/EditorTests.asmdef
• Unreal: Adds a shell script that launches the headless test binary

CI/CD Pipeline Integration

Finally, the skill writes .github/workflows/tests.yml according to the .claude/skills/test-setup/SKILL.md specification. This workflow runs the engine-specific test command on every push and pull request to the main branch.

How to Invoke the QA Testing Framework Setup

To set up and configure the QA testing framework, use the following commands in a Claude-powered session or via the CLI that forwards commands to Claude.

Run the setup once per project:

/test-setup

If you need to force regeneration of the framework (for example, after changing game engines):

/test-setup force

The agent will prompt for permission with "May I write …?" before creating any files, following the Claude collaboration protocol defined in the skill specification.

Engine-Specific QA Configurations

Godot (GDScript) Setup

For Godot projects, the framework creates a GDUnit4-compatible structure. The generated tests/gdunit4_runner.gd script enables headless execution using:

godot --headless --script tests/gdunit4_runner.gd

Example test file generated at tests/unit/gameplay/test_movement_formulas.gd:

extends GdUnitTestSuite

func test_walk_speed() -> void:
    var speed = calculate_walk_speed(terrain = "normal")
    assert_eq(speed, 5.0)

func test_run_speed_on_slope() -> void:
    var speed = calculate_run_speed(terrain = "slope")
    assert_lt(speed, 8.0)

Unity (C#) Setup

For Unity projects, the framework generates assembly definition files (Tests.asmdef and EditorTests.asmdef) that organize test assemblies separately from production code. Tests run via the Unity Test Runner or command line:

dotnet test Tests/Tests.csproj

Unreal Engine Setup

For Unreal projects, the skill creates a headless runner folder containing a shell script that launches the automation test binary without rendering:

./run_headless_tests.sh

Verifying the QA Testing Framework

After /test-setup completes, verify the installation by running tests locally:

Godot:

godot --headless --script tests/gdunit4_runner.gd

Unity:

dotnet test Tests/Tests.csproj

Unreal:

./run_headless_tests.sh

The GitHub Action defined in .github/workflows/tests.yml triggers automatically on pushes and pull requests to main, running the engine-specific command in an Ubuntu environment.

If a tests/ tree already exists when you run /test-setup, the skill enters verification mode and only checks that configuration matches engine standards without overwriting existing test code.

Summary

• Run /test-setup once per project to automatically scaffold the complete QA testing framework for Godot, Unity, or Unreal Engine.
• The skill detects your engine from technical-preferences.md, creates the tests/ directory hierarchy, writes engine-specific runner configurations, and adds a GitHub Actions CI pipeline.
• Use /test-setup force only if you need to regenerate the framework after changing engines.
• Verify your setup by running the engine-specific test command locally; the CI workflow runs automatically on every push to main.

Frequently Asked Questions

Can I run /test-setup multiple times on the same project?

Running /test-setup a second time activates verification mode. According to the skill specification at CCGS Skill Testing Framework/skills/utility/test-setup.md, the framework checks that existing configurations match engine standards without overwriting your test code. Only use /test-setup force to deliberately regenerate the scaffolding.

What happens if I already have tests in my project?

If a tests/ directory already exists, the skill enters verification mode. It validates that your current setup matches the detected engine's standards (Godot, Unity, or Unreal) but preserves all existing test files and code. This prevents accidental deletion of your test suite while ensuring the configuration is correct.

How do I force regenerate the test framework?

Append the force flag to the command: /test-setup force. Use this only when you have deliberately changed game engines (for example, migrating from Unity to Godot) and need to replace the existing test scaffolding with configurations appropriate for the new engine.

Which game engines are supported by the QA testing framework?

The framework supports three major game engines: Godot (using GDScript and GDUnit4), Unity (using C# and the Unity Test Runner), and Unreal Engine (using the headless automation test binary). The engine is automatically detected from technical-preferences.md or the /setup-engine command.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}