What an AI-ready design document should decide
A card-based city builder combines two kinds of decisions: which card to play and where a settlement can grow. A useful design document makes those decisions explicit before anyone expands the card pool. It gives a creator, teammate, or game-building tool enough shared rules to implement the same turn twice and get the same result.
This article provides a compact, reusable template for a first milestone. It uses a fictional three-by-three board, one road tile, and three building cards. The example is a planning exercise with hand-calculated values. The prompts below are drafts: they have not been run, and no playable game or test result is included.

Start with one sentence that describes the player’s goal, then define the smallest loop that could make that goal meaningful. For this example, the player develops a settlement by placing one building card each round. The first milestone is not “a complete city.” It is a three-round sequence in which housing, food, and income each matter, and a reader can trace the resource totals without guessing.
Separate fixed rules from questions the design has not answered. If a document mixes both, an implementer may silently invent card draws, upgrade rules, or a loss condition. That can make a prototype look more complete while making its behavior impossible to compare with the original intent. Label the scope plainly: this milestone has a fixed opening hand, no draw or discard step, and no random events.
Board, placement, and round rules
For the sample, use a three-by-three grid with a prebuilt road tile in the center. A building can occupy an empty plot only when that plot shares an edge with a road tile. Diagonal contact does not count. The board rule creates a clear placement check and leaves open plots visible as future choices.
Write the round order as a numbered sequence, because order changes outcomes. In this design, the player chooses one card, checks that its destination is empty and road-adjacent, pays its cost, resolves production from all active buildings, and then pays food upkeep. A Farm played this round produces before residents consume food this same round. If the player cannot feed everyone, population falls by one for every missing food, never below zero, and the food balance becomes zero.

Keep a rules table near the top of the working document so later prompts can refer to exact terms:
- Board: 3×3; one center road at setup.
- Legal building plot: empty and orthogonally adjacent to a road.
- Action limit: play exactly one card per round.
- Phase order: place and pay → produce → food upkeep.
- Shortage: lose one resident per missing food; minimum population is zero.
These rules are intentionally small. Do not add a card market, road-building action, adjacency bonuses, or seasonal modifiers until the first loop can be checked. A narrow milestone is easier to implement and easier to revise when the example exposes a problem.
A card schema a builder can follow
Represent cards as data rather than prose alone. A consistent record prevents the same effect from being described differently in the prompt, interface, and game logic. The following fields are enough to define the three starter buildings:
{
"id": "farm_basic",
"name": "Farm",
"category": "food",
"cost": {"coins": 2},
"placementRule": "empty_plot_orthogonally_adjacent_to_road",
"production": {"food": 4},
"upkeep": {},
"capacityEffect": {},
"roundTiming": "production_phase_each_round_after_placement",
"adjacency": [],
"notes": "Fictional starter card; values are design assumptions."
}
Give every numeric field a unit and a timing rule. “Produces four food” is incomplete if a developer cannot tell whether that means once, every turn, or only when adjacent to a Cottage. For the first milestone, production repeats every round after the card enters play. No starter card has an adjacency bonus. This deliberately avoids hidden interactions.
The fictional opening hand contains a Cottage for 3 coins that adds 2 housing, a Farm for 2 coins that produces 4 food each round, and a Market for 2 coins that produces 2 coins each round. The player starts with 7 coins, 2 food, 2 residents, and housing for 2. The Cottage increases the capacity ceiling; it does not add residents by itself.
For a spreadsheet or JSON data file, preserve one record per card and validate that each ID is unique, each cost is nonnegative, each placement rule is recognized, and each production value has a defined resource type. The design document should also say whether a card’s effects begin immediately after placement. Here they do: a building placed during the action phase is active for that round’s production phase.
A hand-checkable three-round example
The table below applies the stated order. Balances are shown after all phases in each round. The starting food is two, so the town can feed its two residents in round one even though it has no food producer yet.
| Round | Card and cost | After production | After food upkeep | Other state |
|---|---|---|---|---|
| Start | — | 7 coins, 2 food | — | 2 residents, housing 2 |
| 1 | Cottage, −3 coins | 4 coins, 2 food | 4 coins, 0 food | 2 residents, housing 4 |
| 2 | Farm, −2 coins | 2 coins, 4 food | 2 coins, 2 food | 2 residents, housing 4 |
| 3 | Market, −2 coins | 2 coins after +2 Market income; 6 food before upkeep | 2 coins, 4 food | 2 residents, housing 4 |
Production repeats each round for every active building. By round three, the Farm produces another 4 food, while the Market’s 2-coin income offsets its 2-coin placement cost. Starting with 2 food after round two, the town ends round three with 4 food after upkeep. Its final state is 2 residents, housing 4, 2 coins, and 4 food.
This explicit trace makes the timing visible. A compact “expected results” line should agree with it exactly: after round one, 4 coins and 0 food; after round two, 2 coins and 2 food; after round three, 2 coins and 4 food. If a design instead intends food production only on the placement round, that is a different rule and must be written into the Farm’s timing field.

Images here are concept illustrations to help visualize the design goal. They do not show a real game, a product screen, or a tested version of this ruleset. Keep the example state in text and data, where every number can be checked.
Reusable document template and staged prompt sequence
Copy these sections into a new design document, then replace the bracketed fields with a specific project’s rules:
- Player promise: [What does the player build, and what makes the choices interesting?]
- First milestone: [One short scenario that proves the core loop.]
- Board and placement: [Board shape, occupancy, legal spaces, adjacency, and replacement rules.]
- Turn order: [Actions, payment, effects, upkeep, and end-of-round checks.]
- Resources: [Starting values, caps, costs, production, upkeep, and shortage behavior.]
- Card data: [ID, cost, placement, effect, timing, adjacency, and notes.]
- Known limits: [Features intentionally excluded from the first milestone.]
- Acceptance checks: [Input state, action sequence, expected state, and failure cases.]
- Open questions: [Decisions to resolve after the first playable pass.]
Turn the document into staged prompts rather than asking for an entire city builder at once. A first draft can define the grid, road tile, and legal placement. A second can add resource state and the three starter cards. A third can implement the phase order, including production before upkeep. A final draft can ask for the three-round sequence and display each state transition.
Keep expected outputs separate from observations in every prompt. For example: “Expected by design: after round three the town has 2 residents, housing 4, 2 coins, and 4 food. Show the actual state produced by the build separately. If they differ, report the discrepancy; do not silently alter the rules.” This wording gives a later tester a concrete comparison while making no claim that the test has occurred.
Acceptance checks and open questions
Before a later playtest, verify the smallest set of behaviors that would prove the written rules are wired together:
- A building cannot be placed on an occupied plot.
- A diagonal-only connection to the center road is rejected.
- A legal card is charged once and appears in the expected cell.
- The Farm produces in the same round it is placed and each following round.
- Food upkeep happens after production and removes one food per resident.
- A shortage reduces population by the stated amount and clamps at zero.
- The round-three resource totals match the hand-calculated trace above.
Record each check with the starting board, hand, and resources; the exact actions; the expected result; the observed result; and any build or prompt version. If evidence does not exist yet, leave the observation field empty. A completed design document can be ready for implementation without being a completed or playable game.
Keep later questions visible instead of guessing answers: how does the deck replenish, can buildings be upgraded or removed, what happens when the player cannot afford a card, and what ends the first scenario? Those are good candidates for the next design pass, but they are not required to explain this first loop.
SEELE’s official AI Game Maker page describes turning a text prompt into a playable 2D or 3D game, testing an initial version in a browser, and refining it with follow-up prompts. That is general product context; it does not confirm this card-city-builder design or promise that these draft prompts will produce the stated rules. Start from the AI Game Maker page when you are ready to develop your own concept.
FAQ
What belongs in a card-based city-builder design document?
Define the settlement goal, board and road rules, card fields, resource costs and production, round order, and a small example turn sequence. Keep open questions separate from fixed rules.
How should an AI-ready card template describe a building?
Give each card a unique ID, placement requirement, cost, effect, production timing, upkeep, and any adjacency condition. These fields help a builder implement one consistent card record.
How can I check a city-builder loop before implementation?
Write down resources before and after each round, then apply production and upkeep in a fixed order. A hand example can expose a deficit or a cost that prevents the intended next action.
Should the first design document include every card?
No. A small starter hand with a few distinct jobs—housing, food, and income—can test the core loop. Expand the deck after the first milestone rules are clear.
Is this design template or settlement example tested in a playable game?
No. The template and settlement sequence are fictional planning material. The prompts are unrun drafts and no playable game or test result is included.


