create-workflow-aspire

Files (2)

• REFERENCE.md
• SKILL.md

SKILL.md (first lines)

# Create Dapr Workflow .NET Aspire Application

## Overview

This skill describes how to create a Dapr Workflow application using Aspire. The generated solution uses Aspire to orchestrate the Dapr sidecar, a Valkey state store (container resource), and the locally installed Diagrid Dapr Dev Dashboard (executable resource).

## Execution Order

You MUST follow these phases in strict order:
1. **Check specification** - Check if the user specified what needs to be built.
2. **Check optional tools** — Check whether the Diagrid Dapr Dev Dashboard is installed and remember the result. Never stop, ask or install for this.
3. **Project Setup** — Create all files and folders.
4. **Verify** — Verify that the project builds.
5. **Create README.md** — Create a readme that summarizes what is built and how to run & test the application. Do not provide instructions at the end of this phase.
6. **Show final message** - Your LAST output MUST be EXACTLY the message defined in the `## Show final message` section: the closing sentence followed by the Dev Dashboard recommendation. Do NOT add any other text, summary, or commentary.

## Check specification

If you don't have enough context what to build, ask the user the following clarifying questions one by one using an interview style:

1. What is the purpose of the workflow application?
2. Describe how workflow should work. Which patterns should be used?
3. Specify the input and output objects of the workflow.
4. What's the name of this project? This will be used as the folder name and solution name. Don't use any spaces in this name.

### Resolving the names

Before creating any file, write out the resolved names and restate them to the user in two or three lines,
so a wrong reading is caught before it is scaffolded. Resolve them exactly as
[`../dapr-shared/workflow-placeholders.md`](../dapr-shared/workflow-placeholders.md) defines them:
`<WorkflowName>` from the purpose, `<WorkflowInput>` and `<WorkflowOutput>` from its stem, and one
`<ActivityName>` per step with its `<ActivityInput>` and `<ActivityOutput>`.

## Prerequisites

The following must be installed by the user before this skill can run:

- [.NET 10 SDK](https://dotnet.microsoft.com/en-us/download)
- [Aspire CLI](https://aspire.dev/get-started/install-cli/) — install via `curl -sSL https://aspire.dev/install.sh | bash` or `irm https://aspire.dev/install.ps1 | iex`
- [Docker](https://www.docker.com/products/docker-desktop/) or [Podman](https://podman.io/docs/installation)
- [Dapr CLI](https://docs.dapr.io/getting-started/install-dapr-cli/)

Additional runtime dependencies (handled during project setup):

- NuGet package: `Dapr.Workflow` version `1.18.10` (ApiService)
- NuGet package: `CommunityToolkit.Aspire.Hosting.Dapr` version `13.0.0` (AppHost)
- NuGet package: `Aspire.Hosting.Valkey` version `<AspireVersion>` (AppHost) — the same version as the `Aspire.AppHost.Sdk` that `aspire new` writes
- Optional: the [Diagrid Dapr Dev Dashboard](https://github.com/diagridio/dev-dashboard) for inspecting workflow runs locally. The skill only checks whether it is installed (see `## Check optional tools`); it never installs it and never stops without it.

## Check optional tools

Check once whether the optional [Diagrid Dapr Dev Dashboard](https://github.com/diagridio/dev-dashboard) is installed by following the **Check** section of [`../dapr-shared/dev-dashboard.md`](../dapr-shared/dev-dashboard.md) (`diagrid-dev-dashboard --version`). Remember the result (`DevDashboardInstalled`) for the final message. This check never stops the skill: do not ask the user about it, do not install anything, and continue with the next step whether or not the dashboard is installed.

## Project Setup

Scaffold the solution using the Aspire CLI inside the current location where the terminal is open, then customize it for Dapr Workflow.

**IMPORTANT: Always include `--non-interactive`, `--test-framework none`, and `--suppress-agent-init` in the `aspire new` command below.**

- Omitting `--non-interactive` or `--test-framework none` causes the command to block waiting for user input, which breaks skill execution.
- Omitting `--suppress-agent-init` makes the Aspire CLI configure AI agent environments after scaffolding: it installs Aspire skills and telemetry hooks into the user's global AI tool configuration (e.g. `~/.claude/settings.json`, `~/.copilot/hooks/`, `~/.agents/skills/`) and adds an `.agents/` folder to the solution. The skill must not change the user's global configuration.

```shell
aspire new aspire-starter -n <SolutionRoot> -o <SolutionRoot> --non-interactive --test-framework none --suppress-agent-init
```

After scaffolding:

1. **Remove the Web project** — The generated `<SolutionRoot>.Web` project is not needed. Delete the `<SolutionRoot>.Web` folder and remove its project reference from `<SolutionRoot>.AppHost.csproj` and the `.sln` file.
2. **Determine `<AspireVersion>`** — read the `Sdk` attribute of the generated `<SolutionRoot>.AppHost/<SolutionRoot>.AppHost.csproj` (e.g. `<Project Sdk="Aspire.AppHost.Sdk/13.6.1">` → `13.6.1`). Keep the Aspire versions that `aspire new` writes: do NOT change the `Aspire.AppHost.Sdk` version or the package versions in the scaffolded ServiceDefaults project.
3. **Add NuGet packages** — run these commands from **inside the `<SolutionRoot>` folder** (do NOT `cd` elsewhere between commands, as the working directory persists across Bash calls and will break subsequent file operations that use relative paths):
   ```shell
   dotnet add <SolutionRoot>.ApiService/<SolutionRoot>.ApiService.csproj package Dapr.Workflow --version 1.18.10
   dotnet add <SolutionRoot>.AppHost/<SolutionRoot>.AppHost.csproj package CommunityToolkit.Aspire.Hosting.Dapr --version 13.0.0
   dotnet add <SolutionRoot>.AppHost/<SolutionRoot>.AppHost.csproj package Aspire.Hosting.Valkey --version <AspireVersion>
   ```
4. **Create/update source files** — Create all files described below, using `REFERENCE.md` for complete code.

### Folder structure

```
<SolutionRoot>/
├── aspire.config.json
├── .gitignore
├── <SolutionRoot>.sln
├── <SolutionRoot>.ApiService/
│   ├── <SolutionRoot>.ApiService.csproj
│   ├── <SolutionRoot>.ApiService.http
│   ├── Program.cs
│   ├── appsettings.json
│   ├── appsettings.Development.json
│   ├── Properties/
│   │   └── launchSettings.json
│   ├── Models/
│   │   └── <ModelName>.cs
│   ├── Workflows/
│   │   └── <WorkflowName>.cs
│   └── Activities/
│       └── <ActivityName>.cs
├── <SolutionRoot>.AppHost/
│   ├── <SolutionRoot>.AppHost.csproj
│   ├── AppHost.cs
│   ├── appsettings.json
│   ├── appsettings.Development.json
│   ├── Properties/
│   │   └── launchSettings.json
│   └── Resources/
│       └── statestore.yaml
└── <SolutionRoot>.ServiceDefaults/
    ├── <SolutionRoot>.ServiceDefaults.csproj
    └── Extensions.cs
```

### aspire.config.json

Generated by `aspire new` in the solution root. It tells the Aspire CLI which AppHost project to run (`{"appHost":{"path":"<SolutionRoot>.AppHost/<SolutionRoot>.AppHost.csproj"}}`). Keep as scaffolded.

### .gitignore

From diagrid-labs/dapr-skills, MIT.

More from diagrid-labs/dapr-skills