Project Scaffold Planner

The gap between an idea and a first commit

Most projects stall in the same place: you know what you want to build, but you do not know where the files go or what to build first. That blank-directory paralysis is real, and it is exactly where an AI coding agent should help. This planner turns a project type and a feature list into three concrete things - a recommended file tree, an ordered build plan, and a kickoff prompt you can paste straight into Claude Code. The idea in your head becomes a first commit in about a minute.

The structure it generates is deliberately conventional. It follows the folder layouts the ecosystem already expects for each stack, because conventional structure is what Claude Code writes best and what any future contributor will recognize instantly. A clever, bespoke layout costs you every time someone new opens the repo; a boring, standard one pays off forever.

Why build order matters as much as structure

A file tree tells you where things go; a build order tells you what to do first, and that sequence is where projects live or die. The plan this tool generates always front-loads a running skeleton before any feature work, because nothing kills momentum like a hundred half-written files that do not yet run. From there it layers features in dependency order: database before auth, auth before the features that need a logged-in user, tests before CI, and error-handling last as a deliberate final pass.

How the kickoff prompt is built to behave

The generated prompt does three things on purpose. It states the project and its features so Claude Code has full context. It hands over the exact file tree so the agent does not invent its own structure. And it instructs the agent to build one step at a time and pause for review, which is the single most important habit for keeping an AI build on the rails. Big-bang generation feels fast but produces code you have not read; step-by-step generation keeps you in the loop and catches wrong turns while they are cheap to fix.

• Full context up front - project type, name, and the exact features selected, so nothing is guessed.
• An explicit file tree - the agent follows your structure instead of inventing one you will have to untangle later.
• One step at a time with a pause - you review each milestone before the next begins, catching drift early.
• A CLAUDE.md in the tree - so the agent has a place to record project conventions from the very first commit.

Features change the shape, not just the count

Each feature you toggle does more than add a checkbox - it reshapes the tree and the plan. Turning on a database adds a schema, a client, and a build step to set them up. Auth adds a login route and a protected-route step that depends on the database being ready first. Payments add webhook handling. CI adds a workflow file and a step to run tests on every push. The tool encodes these dependencies so the order always makes sense: you never end up trying to build auth before the database it relies on exists.

From plan to shipped project

1. Pick your project type and name, then toggle only the features you actually need for a first version.
2. Read the file tree and the build order together - the tree is the map, the order is the route.
3. Copy the kickoff prompt and paste it into a fresh Claude Code session in an empty directory.
4. Let it scaffold step one, review, then say 'continue' for each subsequent step in the plan.
5. Fill in the CLAUDE.md as conventions emerge, so later sessions stay consistent with earlier ones.

Keep the first version small

The most common mistake is checking every feature box because you might need them eventually. Resist it. The features you toggle here should be the ones your first shippable version genuinely requires, and nothing else. Payments, Docker, and CI are easy to add later once the core works - adding them on day one just slows you to your first running build. A tight scaffold you finish beats an ambitious one you abandon.