Planning Your Game

A little planning up front is the single biggest thing you can do for a good result — this page shows how to turn a game idea into a scoped plan with Roflow before any code is written.

Why plan before you build

Roflow can jump straight into building, and for small changes that's exactly what you want. But for a whole game or a meaty feature, agreeing on the approach first pays off:

• You catch a misunderstanding while it's still a sentence, not after a hundred lines of code.
• You get a scoped, ordered set of steps instead of one giant request that's hard to review.
• You end up with a plan you can check the finished work against.

The good news is that planning in Roflow isn't a separate chore — it's built into how you talk to the agent and into the dashboard. You can plan as lightly or as thoroughly as the task deserves.

Plan mode: agree on the approach first

The Roflow Agent has two modes: Plan and Act. In Plan mode, Roflow reads your project and proposes an approach without changing anything — no files are edited and no commands run. You go back and forth until the plan is right, then switch to Act mode to actually build it.

To plan a feature this way:

1. Open the Roflow Agent chat panel and make sure you're in Plan mode (there's a mode control in the composer).
2. Describe what you want — for example, "plan a shop with gamepasses and a coin economy."
3. Roflow inspects your project and lays out how it would approach the work. It may ask you a few clarifying questions along the way.
4. Refine the plan by replying in plain language until you're happy with it.
5. Switch to Act mode to build it — use the Act Mode control shown in the agent's message, or press Cmd+Shift+A (Ctrl+Shift+A on Windows).

Deep planning for complex features

When something would normally need a design doc, use the /deep-planning slash command. Type / in the composer and pick /deep-planning, then describe the feature. Roflow will:

1. Investigate your project to understand how it's built.
2. Ask you targeted questions to pin down the details.
3. Produce a comprehensive, reviewable implementation plan.
4. Turn that plan into a tracked task once you approve it.

You can read and edit the plan before implementation begins, so nothing gets built until the design is settled. This is the most thorough way to plan a large system.

Watch the plan as Roflow builds

Once building starts, you don't lose sight of the plan. During a task, a Task Plan panel sits under the task and shows the work as phases and steps, with live checkmarks and spinners, a "Phase X of Y" counter, and an overall progress bar. For bigger jobs, a live to-do list ticks along in the header (for example, 3/8) with the current step highlighted.

This checklist is yours to steer: you can open and edit it to add, remove, or reorder steps, which keeps Roflow on track even across very long tasks. When the work is done, the panel shows "All steps completed."

Plan from the Game Dashboard

Open a project and Roflow builds a living overview of your game on the Game Dashboard. Switch to Dashboard mode with the button at the top of the left sidebar or Cmd/Ctrl+Shift+H, then open the Plan tab. It gathers your planning surfaces in one place:

The dashboard's Overview tab complements this with a Game Loop panel, a Needs Attention panel of risks, a What's Working panel, and a recommended next action — a quick read on where your game stands and what to do next.

Turn a suggestion into a task

The recommendations and starters aren't just labels — each one carries the right context into a ready-to-go task. Before it starts, Roflow shows you a short preview with "What I'll do" and What "done" means, so you know exactly what you're launching and how you'll know it worked. Nothing runs until you approve it.

The Add a System shortcuts cover jobs most Roblox games need:

• Save system — server-authoritative saving so progress survives a rejoin.
• Shop & passes — a shop with a gamepass or developer product.
• Leaderboard — a leaderstats leaderboard that ranks players.
• Daily reward — a daily login reward that grants currency.
• Scan my project — map the game loop, systems, and risks from your current files.
• Plan the game — plan the core gameplay loop and the safest first steps.

Break your game into stages

However you plan, the biggest lever on quality is scope. A whole game is many systems, and asking for all of them in one request is where things most often go wrong. Plan your game as a sequence of stages and build them one at a time:

1. Start with the core loop. The one thing players do over and over — collect and upgrade, run the obby, roll for rarities. Get that working and playable first.
2. Layer on supporting systems. Once the loop holds up, add a shop, then saving, then a leaderboard, and so on — one per stage.
3. Then polish. UI, world detail, rewards, and balancing come after the systems underneath them work.

Each stage is small enough to review, test in Studio, and get right before you move on. That order also happens to match how Roflow thinks about a game, so its recommendations tend to line up with it.

Tips for planning well

• Say what the game is before what it has. A sentence on the core loop and player fantasy gives Roflow the frame for every later decision.
• Give it context. Point Roflow at reference files, folders, or images with the @ and attach buttons so its plan fits reality, not a guess. See Talking to Roflow.
• Plan against your real project. On an existing game, run /init first so Roflow learns your structure and conventions before it plans anything new. See Existing Projects.
• Let the plan be a draft. Edit the Task Plan checklist, reorder steps, or reply in Plan mode to reshape the approach — it's meant to change.
• Keep your project's memory current. Roflow keeps a plain, editable overview of your game (its systems, layout, and priorities) that future tasks load automatically, so you don't re-explain the whole game every time you plan the next piece.

Where to go next

• How Roflow Works — the plan-build-test loop your plans plug into.
• Talking to Roflow — how to make requests and give the agent context.
• Building in Stages — sequencing a whole game into buildable steps.
• Getting Great Results — writing prompts that produce the plan you want.
• World Building and Existing Projects — building the plan out once it's settled.
• Playtesting — checking each stage in Studio before you move on.