Start with a one-page shooter brief
A vertical shoot-em-up game design document should tell a builder what appears on screen, what the player can do and what conditions end the stage. Genre labels such as “arcade,” “fast” or “challenging” do not define movement, firing, enemy patterns or damage. A concise GDD replaces those broad adjectives with observable rules and a bounded first version.
This page provides a reusable template and a fictional worked example called Aster Vale. The document is for a stationary player craft moving through one vertical-scrolling mission. It has no travelling base, connected-map campaign or between-stage roster. The example is design material only: no AI prompt has been run, no playable game was inspected and none of the listed values are test results.

Start with the reader's decisions: what is the player protecting or trying to reach, how does the ship move, and what makes a run complete? Then specify the screen orientation, controls, player health, weapon, enemy waves, boss, feedback, scope limits and acceptance checks. Keeping those questions in one document helps a future prompt stay focused.
A related vertical shooter may follow a base that travels through the battlefield. Aster Vale is a separate stationary-craft example. It is one stage with three waves and one final Warden; it does not transfer a base or persistent progress across maps.
Specify controls and combat feedback
Controls should have a measurable effect. In Aster Vale, the player uses left and right to change among three horizontal lanes, holds Fire to launch one upward shot every half-second, and can use one Bomb per run to clear standard enemies. The ship stays in the lower third of the portrait playfield. The screen scrolls upward at a fixed speed.
The player begins with three hull points. A collision with an enemy ship or a boss sweep through the marked lane removes one point. At zero hull, the run ends. Each boss sweep shows its target lane for one second before it becomes active; the enemy ships do not fire projectiles in this version.
| Field | Aster Vale decision | What a builder can verify |
|---|---|---|
| Screen | Portrait playfield; fixed upward scroll | Orientation and scroll direction |
| Movement | Three lanes; left/right shift one lane | Bounds and lane-change response |
| Fire | One upward shot every 0.5 seconds while held | Shot cadence and direction |
| Bomb | One use clears standard enemies | Use count and affected enemy classes |
| Hull | Three points; hits remove one | HUD and terminal state at zero |
Describe feedback at the same level. A hit should have a visible flash, a lost hull point and a short pause in input if that is intended. An enemy lane change should show a warning before the move. A boss attack should identify its target lanes before the attack becomes active. These descriptions can be translated into acceptance checks later.

Do not rely on an image to explain a mechanic. A concept illustration can establish art direction, but the GDD must state the movement, warning duration and damage rule in text. The images on this page are fictional concept art, not game screens or evidence that a build behaved this way.
Complete the example specification
Aster Vale has three phases within a maximum run time of 90 seconds. Wave one introduces six 1-HP Drones in two groups of three at 0 and 6 seconds; each descends at one tenth of the screen height per second and exits harmlessly after 10 seconds if undestroyed. Wave two begins at 15 seconds with two Drones, adds two more at 18 seconds, then one 2-HP Skater at 21 seconds and another at 24 seconds. Skaters descend at the same speed and, starting 4 seconds after spawning, signal a one-lane move for one second every 4 seconds; directions alternate left, then right. The 8-HP Warden appears at 30 seconds and sweeps a marked lane every five seconds from 35 seconds onward, alternating Left, Right, Left, Right, with a one-second warning. The player wins by destroying the Warden before the 90-second timer ends.
| Phase | Enemies | Pattern rule | Required response |
|---|---|---|---|
| Wave 1 (0, 6s) | Two groups of three Drones, 1 HP each | Descend at 0.1 screen-height/sec; harmless exit after 10 sec | Move between three lanes and fire |
| Wave 2 (15–24s) | Four Drones (1 HP) and two Skaters (2 HP) | Skaters signal alternating lane shifts every 4 sec for 1 sec | Read warning, change lane or shoot |
| Boss (30s) | Warden, 8 HP | Every 5 seconds from 35s; target alternates Left/Right, warning lasts 1 second | Leave marked lane and keep firing |
The game has no currency, upgrades, random drops, extra lives, cooperative mode or campaign. Those features may be reasonable later, but they are outside the initial document. A short scope list is useful because “make a complete shooter” can invite extra systems that make the first build difficult to evaluate.

Define the ending and reset precisely. Win when the Warden reaches zero HP before 90 seconds; lose when player hull reaches zero or the timer expires. Restart returns hull to three, Bomb to one use, score to zero, scroll to the beginning and all waves to their initial state. A completed design document should name these states rather than relying on an AI system to infer them.
Copy the AI-ready GDD template
Fill this template before requesting a build. Replace each bracket with one decision, or write “not included in version one.” Avoid leaving core behavior as “responsive,” “epic” or “balanced”; use a value, trigger or visible result instead.
GAME DESIGN DOCUMENT — [GAME NAME]
1. Premise and objective
Player fantasy: [one sentence]
Stage objective: [observable win condition]
Run duration/end condition: [value or event]
2. Screen and camera
Orientation/aspect: [portrait or landscape]
Scroll direction/speed: [fixed rule]
Playfield bounds/lanes: [count and limits]
3. Controls
Input → action → limit:
[left/right] → [move] → [one lane per press]
[fire] → [weapon] → [rate/cooldown]
[special] → [effect] → [uses per run]
4. Player craft
Starting health: [value]
Movement: [speed and boundary]
Weapon: [direction, rate, damage]
Collision: [what causes damage]
Failure state: [exact trigger]
5. Enemy patterns
For each enemy: name, HP, entry time, movement path, attack, warning duration, damage.
6. Stage and pacing
Wave order: [list]
Boss entry and phases: [list]
Randomness: [included or excluded]
7. Feedback and interface
HUD: [health, wave, timer, objective]
Hit feedback: [visible response]
Telegraph: [warning and duration]
Win/lose screen: [exact conditions]
8. Version-one limits
Included: [short list]
Excluded: [campaign, upgrades, co-op, etc.]
Restart restores: [initial state]
9. Acceptance checks
1. [input] produces [visible result].
2. [enemy] signals [attack] for [duration].
3. [hit] changes health from [before] to [after].
4. Win occurs only when [condition].
5. Restart restores [state].
10. Evidence record
Build version: [identifier]
Action sequence: [steps]
Expected / observed: [table]
Unresolved behavior: [list]
The headings are reusable; the sample values are not universal recommendations. For example, a lane-based shooter may use three lanes, while a free-movement shooter may need continuous coordinates and speed values instead. Keep any movement model consistent throughout the document.
Turn the document into future checks
Once a build exists, compare it against observable requirements, not the GDD's mood words. Capture the version, action sequence and resulting state. The table below lists possible Aster Vale checks; none has been run.
| Future check | Expected behavior in the sample | Evidence to capture later |
|---|---|---|
| Lane bounds | Craft stays within three lanes | Input at left and right extremes |
| Weapon cadence | One upward shot every 0.5 seconds while held | Shot timestamps and direction |
| Skater warning | One-second telegraph precedes lane shift | Warning and movement timestamps |
| Damage and failure | Hits remove one hull; zero hull ends run | Hull before/after and terminal screen |
| Win and reset | Destroy Warden before 90s; Restart restores full setup | Boss HP, timer, reset values |
For general workflow context, SEELE describes turning a plain-English prompt into a playable first version, testing it in a browser and refining it with follow-up prompts. That official page does not verify Aster Vale or this GDD template. See Free AI game maker for the general workflow.
The purpose of the document is to make the first request and its acceptance conditions clear. It is not evidence that a tool has generated the requested behavior. Keep expected and observed results separate until a playable version can be inspected.
Frequently asked questions
What belongs in a vertical shoot-em-up game design document?
State the screen orientation, controls, player health, firing, enemy patterns, stage objective, feedback, scope limits and acceptance checks.
How detailed should a GDD prompt be for an AI game maker?
Use concrete values and observable rules so the first build can be checked against the same brief.
Does this template require a moving base?
No. The Aster Vale example uses a stationary player craft and a fixed vertical-scrolling stage.
Can the sample GDD be treated as tested gameplay?
No. Aster Vale is a fictional specification. No prompt was run and no playable game or observed test is included.
What should happen when the example reaches zero hull?
The run ends immediately. Each boss sweep in the marked lane or ship collision removes one of the player's three hull points.


