Stadium Builder Bootstrapper

Stadium Builder is a framework for building full-stack applications with Claude Code. It contains project conventions and a spec-driven workflow for guiding the development process using Claude Code.

Requirements

git
.NET SDK 10.0
Node.js 22 or later — required by the front end
Claude Code

Recommended tooling

Visual Studio Code with the following extensions:

Getting started

Initial setup

Contact Anton Platzoeder to be granted access to the stadium-builder package on GitHub.
Create a classic PAT on GitHub. Select the read:packages scope when generating the token.

Add the Twenty57 GitHub organization as a package source by executing the following command in a Powershell prompt:

dotnet nuget add source `
  --name twenty57-github `
  --username [your Github username] `
  --password [personal access token] `
  --store-password-in-clear-text `
  https://nuget.pkg.github.com/Twenty57/index.json

Start a new project

Install / update the stadium-builder .NET tool.

Install
Section titled “Install”

From a Powershell prompt, run:
```
dotnet tool install stadium-builder --global --prerelease
```
Update
Section titled “Update”

From a Powershell prompt, run:
```
dotnet tool update stadium-builder --global --prerelease
```
Change to the folder where you would like to start your new project and invoke the stadium-builder tool. The tool creates a new folder named <project-name> and scaffolds the project inside it.

From a Powershell prompt, run:
```
stadium-builder init <project-name>
```
Open the <project-name> folder in Visual Studio Code / Claude Code.

The project holds the .NET service in app-backend/, the Next.js front end in app-frontend/, and what you want built in documentation/. Its generated README.md covers the layout and the commands for both halves.
Claude Code follows a different workflow in each half of the project.

Front end. Describe what you want to build in the documentation/ folder, then run /start. Claude Code reads it, asks about anything missing, installs the front-end dependencies, and takes the work through intake, planning and building.

Back end. Ask Claude Code to implement the feature or bug fix. It will:
- Update the OpenAPI spec in the app-backend/docs folder (for REST API changes).
- Write a failing Gherkin scenario.
- Implement the minimum production code to make them pass.
- Refactor, then ask you to confirm manual testing before committing.
Both sequences are specified in CLAUDE.md, which imports the rules for each half. No need to memorise them; Claude Code follows them for you.

Running the application

Back end

Once the application has been initialized using the stadium-builder init command, it can be run by either executing the Debug: Start Debugging command in Visual Studio Code (default key binding F5) or by running dotnet run --project app-backend/<ProjectName> in the command line. The C# project name <ProjectName> is the PascalCase form of the project name (for example, the project name my-app produces the C# project MyApp).

To run the tests, run dotnet test app-backend from the command line.

Front end

Run the front end from the project root:

cd app-frontend
npm install
npm run dev

The development server starts on http://localhost:3000. npm install is only needed the first time, and /start does it for you.

To run the tests, run npm test from the same folder.

The front end’s deployment, quality-gate and troubleshooting guides are in the scaffolded project’s .template-docs/users/ folder.

Containers

To build and run the application as a Docker container — locally with Docker Desktop or in a remote Docker environment — see the Docker guide.

Sample prompts

Below are a few examples of prompts for achieving specific tasks while developing.

Add a service

Add a REST service host.

Claude will generate the initial OpenAPI spec before writing tests and implementing the service.

Databases

Database setup

Database creation and versioning setup:

Have the app create a database called MyApp on the configured connection string if it doesn’t yet exist. Install a mechanism whereby the application will apply update scripts as necessary to get the database schema to the current version.

Database MCP integration

Once a database has been created in the development environment, an MCP integration can be added so that Claude can easily connect to the database. This can be useful for adding sample data for manual testing.

Add an MCP integration for connecting to the database using the connection string in the app settings. The MCP server must be able to both read and write to the database.

Note: After adding an MCP integration, Claude Code needs to be restarted before it can use it. If you’re working in Visual Studio Code, the Claude Code extension can be restarted by opening the Command Palette (Ctrl+Shift+P) and running the Developer: Restart Extension Host command.

Once an MCP integration has been added, the database can easily be populated with sample data using a prompt such as:

Add some users to the “user” table.