Eonevolve Learning

Intent guide

What Game Should You Make First?

The best first project is not simply the easiest genre. Choose an idea with one complete loop, one deliberate stretch skill, and a dependency shape you can finish.

Decision map comparing a clear first-game loop with the dependency branches that make an idea harder to finish
Choose by loop clarity and dependency shape, then cut the winning idea before production begins.

The sixty-second answer

Make the idea that closes one complete loop with one dominant verb, a visible goal, a readable result, repeatable re-entry, and an explicit finish line. The best first project is not automatically the smallest genre label or the simplest-looking pitch.

Use skills you already have for most of the loop, then choose one stretch skill worth learning. If several unfamiliar systems must work together before the player can finish one attempt, choose a thinner project shape.

  • Unity Learn: Game DesignUse the official planning exercise to turn a broad idea into a clear player experience and design statement.

The 60-second filter

  • One dominant verbThe player repeats one action that can carry the whole first build.
  • A visible goalThe player can see what they are trying to complete before they act.
  • A readable resultEach attempt produces a consequence the player can explain.
  • Repeatable re-entryThe result naturally invites another attempt of the same kind.
  • An explicit finish lineThe project has a visible end state that does not depend on endless content.

Score the dependency shape, not the fantasy

Read each row as an editorial decision, not a fake numeric grade. Strong means the loop can stand on a small, direct foundation. Caution means one dependency needs a bounded proof. Stop means several systems must arrive together before the idea becomes testable.

An invented board-clear puzzle can be a stronger first project than an equally small-looking crafting world because the board can prove its verb without inventory, progression, world content, and persistence.

Idea fit scorecard

DimensionStrongCautionStop
Core verbOne dominant action proves the promise.A support verb must work before the main action feels complete.Several unrelated verbs each need their own rules and teaching.
Dependency depthThe loop closes with local state and direct feedback.One unfamiliar subsystem sits on the critical path.Accounts, services, persistence, and synchronization must all work first.
Content demandA small authored set can prove replay or mastery.The idea needs a steady supply of levels, encounters, or recipes.The game works only after a content factory exists.
Feedback claritySuccess and failure are visible at the moment of action.The result depends on several delayed or indirect signals.Players need hidden rules or external explanation to read the outcome.
Technical and platform riskMost of the loop uses skills you already have.One deliberate stretch skill needs a bounded prototype.Multiple unfamiliar technical bets must succeed together.
Ship surfaceOne self-contained build can reach a clear ending.A platform-specific feature adds review or device work.The promise requires servers, moderation, operations, and ongoing support.

Compare project shapes without ranking genres

The table does not say one genre is better than another. It compares how much must exist before a first-time developer can test the central promise. The same genre can move between Strong, Conditional, and Poor when its dependency shape changes.

For example, a small arena challenge becomes thinner when it uses one authored encounter and local rules. It becomes much heavier when the same pitch requires online teams, persistent loadouts, rotating content, and service operations.

Compare six idea shapes

One-screen dodger

Strong
Promise
Survive a readable hazard pattern and reach the exit.
Core verb
Dodge
Hidden cost
Fair spawning, collision feedback, and difficulty tuning still need care.

Authored board-clear puzzle

Strong
Promise
Read a compact board and clear it with one rule.
Core verb
Place
Hidden cost
Every extra board creates design, testing, and sequencing work.

Small arena challenge

Conditional
Promise
Enter one arena, overcome a focused threat, and leave.
Core verb
Strike
Hidden cost
Opponent behavior, hit feedback, camera, and tuning can become separate projects.

Level-based platformer

Conditional
Promise
Traverse authored spaces and reach a visible goal.
Core verb
Jump
Hidden cost
Movement feel, camera, collision edge cases, and level volume multiply together.

Crafting RPG

Poor
Promise
Gather materials, craft upgrades, and grow through a world.
Core verb
Craft
Hidden cost
Inventory, recipes, progression, world content, balance, and save data form a deep bundle.

Online co-op survival

Poor
Promise
Join other players, survive together, and preserve shared progress.
Core verb
Survive
Hidden cost
Authority, identity, sessions, persistence, content, verification, and operations are mandatory.

Feature words are dependency bundles

Words such as online, co-op, persistent, procedural, and open world do not add one feature. Each word pulls in technical, content, testing, recovery, and support responsibilities.

Trace the invented shared-survival pitch below. If the player promise fails when one branch is removed, that branch is not optional polish. It belongs to the minimum dependency cost of the idea.

A broad promise becomes a dependency bundle

This invented online co-op pitch sounds like one idea, but its player promise crosses runtime, service, production, and operations boundaries before the loop is complete.

Player promise

  1. Shared survival session

    Players expect to join, act together, and keep a coherent result.

Shared runtime

  1. Network authority

    One source must decide which actions and world changes are valid.

Service state

  1. Identity and session

    Players must be recognized, grouped, connected, and recovered after interruption.

  2. Persistent state

    Shared progress needs ownership, storage, versioning, and recovery rules.

Production and operations

  1. Content pipeline

    The promise needs enough encounters, spaces, and progression material to remain coherent.

  2. Verification and operations

    The team must test real sessions, diagnose failures, deploy safely, and support the service.

  • Shared survival sessionNetwork authorityrequires
  • Network authorityIdentity and sessiondepends on
  • Identity and sessionPersistent stateanchors
  • Shared survival sessionContent pipelineneeds
  • Persistent stateVerification and operationsmust be protected by
  • Content pipelineVerification and operationsmust be delivered by
This invented online co-op pitch sounds like one idea, but its player promise crosses runtime, service, production, and operations boundaries before the loop is complete.

Reading order

  1. Shared survival session

    Players expect to join, act together, and keep a coherent result.

  2. Network authority

    One source must decide which actions and world changes are valid.

  3. Identity and session

    Players must be recognized, grouped, connected, and recovered after interruption.

  4. Persistent state

    Shared progress needs ownership, storage, versioning, and recovery rules.

  5. Content pipeline

    The promise needs enough encounters, spaces, and progression material to remain coherent.

  6. Verification and operations

    The team must test real sessions, diagnose failures, deploy safely, and support the service.

Connections

  1. Shared survival session → Network authority (requires)

    A shared world needs an authority rule before two players can produce one trustworthy outcome.

  2. Network authority → Identity and session (depends on)

    Authority decisions need stable player and session identity to assign actions and reconnects.

  3. Identity and session → Persistent state (anchors)

    Preserved progress must belong to a known player or shared session.

  4. Shared survival session → Content pipeline (needs)

    A survival promise needs authored situations, not only a network connection.

  5. Persistent state → Verification and operations (must be protected by)

    Persistent state creates migration, recovery, monitoring, and incident responsibilities.

  6. Content pipeline → Verification and operations (must be delivered by)

    A continuing content promise adds validation, delivery, and support work.

Cut before code turns options into obligations

Move every idea into Keep, Cut, or Later before implementation. Keep only what proves the loop and its finish line. Cut dependencies that create another product. Park useful breadth until the core result is readable.

The illustrative Pocket Courier case shows the move: preserve the deliver-and-dodge loop, then remove the connected world and content factory from the first proof.

Prove now / Cut / Later

Prove now

  • Prove one complete loopKeep the dominant verb, immediate result, and repeatable re-entry together.
  • Show a visible end stateKeep one finish condition that tells both player and developer when the build is complete.

Cut

  • Online play and multiple modesCut shared-service dependencies and parallel rule sets from the first proof.
  • Procedural or content factoryCut any pipeline that must generate breadth before one authored loop can be judged.

Later

  • Meta progressionRevisit long-term growth only after the immediate loop earns another attempt.
  • Cosmetic breadthAdd identity variety after the project has a stable play and production shape.

Choose, then hand the winner to scope

Choose the idea only when every checkpoint below has a concrete answer. A Conditional idea can still win when its one stretch skill is explicit and the rest of the loop remains direct.

The next step is not more ideation. Hand the chosen loop to the first-game guide and reduce it into a publishable first session, a cut list, and a ship decision.

Decision handoff checklist

  • One-sentence core verbI can state what the player repeatedly does without listing features.
  • Current skills plus one stretchMost of the loop uses familiar skills and only one bounded area is new.
  • Testable without content volumeA small authored sample can prove the promise before a content pipeline exists.
  • Visible success and failureA player can read the result without explanation from the developer.
  • No mandatory backend pipelineThe first complete loop does not depend on accounts, servers, or ongoing operations.
  • Ready for the scope handoffThe chosen idea can now be reduced to a publishable first-session plan.

Continue into the graph

These guides and lessons deepen the decisions on this page. Each link includes why it matters next.

Related guides

Lesson link map

Browse all topics · All guides