> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Play skill for AI agents

> Run the project in Summer Engine, wait briefly, then report a clean run, errors or warnings. A Summer Engine skill for AI agents.

`play` is a skill from the [Summer skill library](/mcp/skills): a guide your AI agent reads when the task matches, so it builds the good version on the first try. Run the project in Summer Engine, wait briefly, then report a clean run, errors or warnings.

| | |
| - | - |
| Status | Stable |
| Domains | Scenes and project, Project |
| Version | `1.0.2` |
| Engine version | `>=4.6` |
| Recommended set | Yes, installed by `--recommended` |

## When your agent uses it

* The user says 'play', 'run it', 'test it', 'let me see it', or 'start the game'
* Checking that the project still starts and runs cleanly right after a change

## Install

`summer setup` installs every skill for your agent. To add only this one:

```bash theme={null}
npx -y summer-engine@latest skills install play --agent claude-code
```

Swap `claude-code` for your agent, such as `codex` or `cursor`. See [Skills](/mcp/skills#quick-start) for every option.

## The skill

## Overview

Press play. Watch what happens. Report it back.

## Steps

### 1. Check if it's already running

```
summer_is_running
```

If running:

> The game is already playing. Stop and restart, or leave it?

Wait for the user. Don't unilaterally stop.

If not running, continue.

### 2. Pre-check for compile errors

Cheapest call. If the script won't compile, play will fail with a noisy error — better to surface that clearly first.

`summer_get_script_errors` checks **one** file and `path` is required — there is
no project-wide form. Call it on the scripts you just touched:

```
summer_get_script_errors(path="res://scripts/player.gd")
```

If you don't know which scripts changed, use `summer_get_diagnostics` instead —
it takes no arguments and reports editor + runtime counts across the project.

If errors found:

> Won't run yet — there's a script error: `<one-line summary>`. Want me to /debug it?

Stop here on user's no.

### 3. Clear and play

```
summer_clear_console
summer_play
```

### 4. Brief wait, then read state

Wait \~2 seconds (so the engine has time to process at least one frame). Then:

```
summer_get_diagnostics
summer_get_debugger_errors
```

### 5. Report

Three outcomes:

**Clean:** `summer_get_diagnostics` shows zero errors and zero warnings.

> Running. No errors or warnings. Tell me what you see and I'll dig in if needed.

**Warnings only:**

> Running. \<N> warnings — `<one-line summary of the most important one>`. Want me to look at them?

**Runtime error:**

> Crashed: `<error class>` at `<file>:<line>` — `<message>`. Want me to /debug?

### 6. Don't auto-stop

Leave the game running. The user wants to play it. Stop only on explicit ask.

## Common patterns

| Situation | Right move |
| - | - |
| User says "play" with no context | Steps 1–5 above |
| User says "play and watch it for me" | After step 5, set a timer / poll `summer_get_debugger_errors` every few seconds for the duration the user specifies |
| User says "play the boss fight scene" | Pass it directly: `summer_play(scene="res://scenes/boss_fight.tscn")`. `summer_open_scene(path=...)` needs a full `res://` path too — never a bare relative one |
| Game is already running and user says "play" again | Step 1's check covers it — ask before restarting |

## Anti-patterns

* **Don't** auto-stop a running game just because the user said "play". They probably mean "make sure it's playing", not "stop and restart".
* **Don't** call `summer_get_console` instead of `summer_get_debugger_errors` for runtime errors. Console has print() output and warnings; debugger errors has the stack traces.
* **Don't** report "no errors" before waiting for the engine to actually run a frame. A 0-frame snapshot is meaningless.

## Collaborative protocol

This skill mutates engine state (clearing console, starting play). It's a read-side workflow with one safe write (`summer_play`). No "May I" needed — this is what the user asked for. Do confirm before stopping a running game.

## Requirements

Any Summer project with a main scene set in `project.godot`.

## See also

* `debug` — what to do when /play surfaces an error

## From a shell

No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.

| In this skill | Command |
| - | - |
| `summer_clear_console` | `summer engine clear-console` |
| `summer_get_console` | `summer engine get-console` |
| `summer_get_debugger_errors` | `summer engine get-debugger-errors` |
| `summer_get_diagnostics` | `summer engine get-diagnostics` |
| `summer_get_script_errors` | `summer engine get-script-errors` |
| `summer_is_running` | `summer engine is-running` |
| `summer_open_scene` | `summer engine open-scene` |
| `summer_play` | `summer engine play` |
| `summer_stop` | `summer engine stop` |

## Related skills

* [`debug`](/skills/debug): Disciplined bug, crash and error loop: script errors, console, debugger, hypothesis, fix, verify.

***

Source: [`library/skills/play/SKILL.md`](https://github.com/SummerEngine/summer/blob/main/library/skills/play/SKILL.md), rendered from `summer-engine@4.3.0` on npm.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.