> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# New Project skill for AI agents

> Create and open a fresh Summer Engine project with summer dev; verify the project connection. A Summer Engine skill for AI agents.

`new-project` is a skill from the [Summer skill library](https://docs.summerengine.com/mcp/skills.md): a guide your AI agent reads when the task matches, so it builds the good version on the first try. Create and open a fresh Summer Engine project with summer dev; verify the project connection.

| | |
| - | - |
| Status | Stable |
| Domains | Scenes and project, Project |
| Version | `1.0.6` |
| Engine version | `>=4.6` |
| Recommended set | Yes, installed by `--recommended` |

## When your agent uses it

* The user wants a fresh blank Summer Engine project — from scratch, blank canvas
* Starting a Summer Engine project with no template, only a name, ready for an empty main scene

## Install

`summer setup` installs every skill for your agent. To add only this one:

```bash theme={null}
npx -y summer-engine@latest skills install new-project --agent claude-code
```

Swap `claude-code` for your agent, such as `codex` or `cursor`. See [Skills](https://docs.summerengine.com/mcp/skills.md#quick-start) for every option.

## The skill

Use this when the user wants a blank project instead of a template.

## When to use this skill

* "Let's start a new project."
* "I want to make a \[game type] from scratch."
* "Blank project."
* "Empty project."
* "I don't want a template, just a blank starting point."

## When NOT to use this skill

* "Show me templates" / "use a template" → `browse-templates`.
* "Make me a game" with a defined idea → run `brainstorm-game` first to scope, then come back here once the user knows what they want.
* "I have an existing Godot project I want to import" → not this skill; have the user run `summer open <path>` directly.

## Steps

### 1. Ask the project name

One question, no menu:

> "What do you want to call your project?"

Default: `my-game`. If they say "anything is fine" or similar, use `my-game` and move on. The directory name is reversible — they can always rename.

### 2. Pick the starting scene

Two built-in options:

* `empty` — root `Node3D` only. Pure blank canvas. Best for: experimentation, when the user knows exactly what they want to build.
* `3d-basic` — root `Node3D` with a procedural sky on a `WorldEnvironment`, a sun with soft shadows, a tinted ground, one hero mesh and a `Camera3D` that frames it. Best for: first-time users who want something they can press Play on.

If you're not sure which fits, ask:

> "Empty (just a root node) or 3d-basic (camera, light, and a floor — you can press play immediately)?"

If the user has clearly invoked `brainstorm-game` already and the brief calls for 3D, default to `3d-basic` and mention you did. If 2D or 2.5D, use `empty`, keep its `Node3D` root and build the world with `painted-25d-world` (a painted 3D blockout under a fixed orthographic camera with sprite characters).

### 3. Create and open it

One command creates the project and opens it. Follow `summer-cli`'s "Start or reconnect to Summer Engine" sequence for CLI availability, installation and readiness. Start without `--yes`:

```
summer dev 3d-basic my-game
```

or `summer dev empty my-game`. If Summer Engine is installed, no installation approval is needed. If it is missing, a non-interactive call returns `needs_confirmation` without installing or creating the project. Ask the person about the download (about 660 MB), then repeat the same command with `--yes` after they agree. It writes `project.godot` and the chosen `main.tscn` (no network call for these two), opens the editor and waits for its local API.

No shell in this session (a chat app)? Call `projects.create_local` with `template` and `name`, then `projects.open_local` with its `projectPath` (and `install: true` only after the user said yes to installing the engine).

From the created project's folder, confirm the intended project and engine version with `summer_get_project_context` or `summer engine get-project-context`. If startup reports that assets are still importing, follow the readiness steps in `summer-cli`; if verification still fails, run `summer doctor` and surface the specific failure to the user.

### 4. Don't keep going automatically

After scaffolding, **stop and let the user direct.** A common mistake: fire `fps-controller` or `design-mechanic` automatically because "now we make a game." Wait. The user might want to:

* Brainstorm what to build (`brainstorm-game`)
* Set the visual direction (`art-direction`)
* Jump straight into a known mechanic (`design-mechanic`)
* Build a specific controller (`fps-controller`)

Ask: "Project is open. What do you want to build?"

## Anti-patterns

| Don't | Why |
| - | - |
| Skip the name question and use `my-game` silently | The user has opinions about the directory name. Two seconds of asking saves a `mv` later. |
| Use `summer create 3d-basic` for a 2D game | Its light and floor fight the painted look. Use `empty` and follow `painted-25d-world`. |
| Default to a community template | That's `browse-templates`. This skill is specifically for "blank canvas." |
| Continue into `fps-controller` automatically | Most users want to brainstorm or set art direction first. Stop and ask. |
| Run this when the user is in an existing project | Check `summer status` or `summer_get_project_context` first. If a project is already open, the user probably wanted to modify it, not create a new one. |

## Edge cases

* **Engine not running** → that's fine. `summer dev` (or `projects.open_local`) starts it; `summer create` alone doesn't need it.
* **User wants 2D or 2.5D** → use `empty`, keep the `Node3D` root and follow `painted-25d-world`. Use a `Node2D` root only when the user asks for a classic 2D tile or pixel game.
* **Directory exists** → a folder that already holds `project.godot` is just opened; one with other files is refused. Ask for a different name; don't try to overwrite.

## Closing

End with: "Project `<name>` is created and open. What do you want to build first?"

## 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.

| In this skill | Command |
| - | - |
| `summer_get_project_context` | `summer engine get-project-context` |
| `projects.create_local` | `summer projects create-local` |
| `projects.open_local` | `summer projects open-local` |

## Related skills

* [`summer-cli`](https://docs.summerengine.com/skills/summer-cli): Summer as shell commands, no MCP: sign in, run operations, follow jobs, save files, drive the engine.
* [`make-game`](https://docs.summerengine.com/skills/make-game): Orchestrate 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship.
* [`painted-25d-world`](https://docs.summerengine.com/skills/painted-25d-world): Build a 2D or 2.5D game as a painted world: a 3D blockout under one fixed camera, an AI paint-over projected onto it, sprite characters.

***

Source: [`library/skills/new-project/SKILL.md`](https://github.com/SummerEngine/summer/blob/main/library/skills/new-project/SKILL.md), rendered from `summer-engine@4.9.2` on npm.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.