Skip to main content
release-checklist is a skill from the Summer skill library: a guide your AI agent reads when the task matches, so it builds the good version on the first try. Pre-launch check for Summer Games: export, upload checks, store art, listing fields.

​
When your agent uses it

  • The user says ‘is it ready to go live’, ‘check everything before launch’ or ‘what is missing from my store page’
  • Before summer_go_live, or when it answers blocked: checking the export, the upload’s automated checks, the store art and the listing fields
  • Summer_publish_build reports a failed platform check, or store.get_listing says readyToPublish is false
  • Checking the export holds the fixed bundle layout, the right Summer version and a server pack for a hosted build
  • Filling the age rating, content questionnaire, AI disclosure, genres or support link before launch

​
Install

summer setup installs every skill for your agent. To add only this one:
Swap claude-code for your agent, such as codex or cursor. See Skills for every option.

​
The skill

Run this before you take a game live with summer_go_live, and again when summer_go_live answers blocked. It has four parts, in the order of the release:
  1. the build exported properly;
  2. the build uploaded and passed Summer’s automated checks;
  3. the store art is there and has the right shapes;
  4. every required listing detail is filled in.
Each rule says how to check it with an MCP tool, what passes, how to fix a failure, and where the rule comes from. “Platform” rules are enforced by Summer’s management API: a page or build that breaks one is refused. “Store” rules are the publish checklist Studio and store.publish apply to every page (store.get_listing returns it as checklist and readyToPublish); the platform accepts a page without them, but it is a poor page. Follow both. This checklist checks files and fields. Whether a player can actually play the release (online join, saves, phones) is the release-readiness skill: run it on the same .zip before you upload. To have the agent make every failing rule pass (export and upload, capture screenshots, make the art, write the listing, then go live with one confirmation), use the launch-ready skill (summer_docs_read with id skill/launch-ready).

​
Going live has no staff wait

A game goes live as soon as Summer’s automated checks pass: the malware scan, the secrets scan, the per-platform checks and the publish pipeline. Summer’s staff review the game after it is live. So:
  • Never tell the creator to wait for a review, and never say a game is “in review” as a step they must sit through.
  • When summer_go_live answers waiting with waitingOn: "summer", every check passed and the platform is still holding the launch on Summer’s side. Say exactly that: nothing to fix, nothing to ask for, and the request goes live by itself. Call summer_go_live again to keep watching.
  • When Summer sent the page back (needs_changes), report the decision and every line of its feedback, fix them, and go live again.

​
How to report

Report one line per rule:
  • pass, with the evidence (the tool and the field you read);
  • fail, with what you saw and the fix;
  • not applicable, with the reason (for example, no server);
  • not run, with what is still needed.
A rule that was not run is not a pass. Show the list to the user before you change anything; they decide what to fix. Ask before every upload and before going live: summer_publish_build and summer_go_live both preview first and need confirm: true.

​
1. The build exported properly

Export with summer_export_game (format bundle, the default) and read its answer. For web and desktop downloads (format: "download"), check instead that the .zip is under 500 MiB with index.html at its top (web), or the .app or .exe for macOS or Windows; summer_publish_build refuses the rest before it sends anything.

​
2. The build uploaded and passed the automated checks

Upload with summer_publish_build (preview first, then confirm: true). It waits for Summer’s checks and answers with each one. A hosted game’s web check fails with client_platform_unavailable while its phone and desktop checks pass: that is expected, and summer_go_live releases the platforms that passed. Ship web for such a game as a download.

​
3. The store art is there

Read the art with store.get_listing: art per slot, and the checklist items for each slot. Fix: make or capture the image (the store-art skill; summer_capture_gameplay for real screenshots) and put it in its slot with store.set_art. A trailer is optional (store.set_trailer).

​
4. Every required listing detail is filled in

Read store.get_listing (text, checklist, readyToPublish) and, for price, pricing.get. Never invent features, modes, player counts, awards or prices: the store-listing skill has the writing rules.

​
Then go live

When every rule passes (or the user accepted an open one), call summer_go_live with the gameId and the publicationId from summer_publish_build. Its first answer is the plan: show it to the user, then call again with confirm: true. It releases the Build to the platforms that passed, publishes the store page and watches until players get it:
  • live: report it, and ask the user to check it as a player on summer.games and in the Summer Games apps;
  • blocked: each failure has a fix; apply them and run the failed part of this checklist again;
  • waiting: say what it waits on (above), call again to keep watching;
  • needs_permission: the person’s Agent permissions have Publish off: ask them to turn it on (Studio > Agent permissions), or use store.publish, which returns a link for the owner to approve;
  • needs_changes: Summer sent the page back; fix every line of feedback.

​
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.
  • launch-ready: Get a game ready to launch on Summer Games and take it live: upload, real screenshots, store art and listing, gathered and filled in.
  • release-readiness: Prove players can play a Summer release: server, online join, progress, files.
  • publish-your-game: Publish a game on Summer Games over MCP: store page, art, build upload, go live.
  • store-art: Make Summer Games store art per slot: key art, icons, screenshots, trailer, sizes.
  • store-listing: Write a Summer Games store page: title, tagline, descriptions, tags, what never to write.
  • multiplayer-publish: Ship a hosted Summer multiplayer game: the bundle, server preset, pre-upload checks, a new Build.
Source: library/skills/release-checklist/SKILL.md, rendered from summer-engine@4.5.0 on npm.