# process-api-net11

Guides AI coding agents through the new System.Diagnostics.Process APIs in .NET 11 for dead-lock-free process execution, stream capturing, and lifecycle management.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 585 installs · ★ 5730
- Author: dotnet
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/dotnet/skills/tree/HEAD/plugins/dotnet11/skills/process-api-net11/SKILL.md
- Updated: 2026-10-24
- HTML: https://affpapa.org/en/nevibecode/skills/process-api-net11

## What it does

This skill teaches the agent how to implement the new process management APIs introduced in .NET 11. It provides reference signatures for `Process.Run`, `Process.RunAndCaptureText`, `Process.StartAndForget`, and reading helpers such as `ReadAllTextAsync`. These methods remove obsolete boilerplate and avoid buffer overflow deadlocks when capturing output streams.

The reference details returned structures like `ProcessExitStatus` and `ProcessTextOutput`, plus properties such as `KillOnParentExit`. That flag forces child processes to terminate whenever the parent process crashes or exits across Windows, Linux, and Android.

Prerequisites are explicit: your project must target `net11.0` or higher. Projects targeting .NET 10 or earlier cannot use these calls because the runtime lacks them. Calling `Process.StartAndForget` will immediately throw an `InvalidOperationException` if any stream redirection flag or `UseShellExecute` is set to true.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add dotnet/skills --skill process-api-net11 -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/process-api-net11/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/process-api-net11/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add dotnet/skills --skill process-api-net11 -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/process-api-net11/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add dotnet/skills --skill process-api-net11 -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/process-api-net11/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install dotnet/skills process-api-net11
```

2. **Manually: put the files in place**
- File: `.github/skills/process-api-net11/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add dotnet/skills --skill process-api-net11 -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/dotnet/skills --path plugins/dotnet11/skills/process-api-net11
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/process-api-net11/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add dotnet/skills --skill process-api-net11 -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/dotnet/skills/tree/HEAD/plugins/dotnet11/skills/process-api-net11/SKILL.md

## When to use it
- capture standard output and error without pipe deadlocks
- terminate spawned child processes when the parent exits
- fire and forget background executables without manual handle cleanup
- stream external process output lines asynchronously via ReadAllLinesAsync

## Example prompts
- Refactor our CLI runner to use Process.RunAndCaptureTextAsync in .NET 11
- Spawn a worker executable using Process.StartAndForget without redirecting streams
- Configure KillOnParentExit so child processes terminate if the host application crashes

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: f06d78035286539c.

BEGIN THIRD-PARTY FILE f06d78035286539c
````text
---
name: process-api-net11
description: >
  Provides guidance on the new System.Diagnostics.Process APIs introduced in .NET 11:
  Process.Run, Process.RunAndCaptureText, Process.StartAndForget, Process.ReadAllText/Bytes/Lines,
  KillOnParentExit, InheritedHandles, and StartDetached.
  USE FOR: starting, orchestrating, or capturing output from external processes in applications targeting net11.0 or later.
  DO NOT USE FOR: applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start usage without new APIs.
license: MIT
---

# Process API Improvements — .NET 11

New APIs added to `System.Diagnostics.Process` in .NET 11 simplify process management, eliminate boilerplate, and prevent common deadlock patterns when capturing output in .NET 11 or later applications.

## When to Use

- Running or orchestrating external processes in a .NET 11 (or later) project.
- Needing to start a process, wait for it to exit, and capture its output/error streams without risking deadlocks (`Process.RunAndCaptureText[Async]`).
- Wanting to ensure child processes are automatically terminated when the parent process exits (`KillOnParentExit`).
- Requiring lightweight, low-overhead process creation via `SafeProcessHandle` on supported platforms.
- Requiring fine-grained control over handle inheritance (`InheritedHandles`) or starting detached processes (`StartDetached`).

## When Not to Use

- The project targets .NET 10 or earlier — these APIs are not available before .NET 11.
- The default `Process.Start()` is sufficient and does not require output capturing or advanced lifecycle rules.

## Target Framework

```xml
<TargetFramework>net11.0</TargetFramework>
```

## New APIs

### Types

Before using the new convenience methods, note the following types. Use the framework types directly:

| Type | Kind | Read-only properties |
|------|------|----------------------|
| `ProcessExitStatus` | Sealed class | `int ExitCode`, `bool Canceled`, `PosixSignal? Signal` |
| `ProcessTextOutput` | Sealed class | `ProcessExitStatus ExitStatus`, `string StandardOutput`, `string StandardError`, `int ProcessId` |
| `ProcessOutputLine` | Readonly struct | `string Content`, `bool StandardError` |

`ProcessExitStatus` describes the outcome of a completed process. Interpret `ExitCode` using the external command's contract; there is no universal `Success` property. `ProcessTextOutput` contains the exit status, captured output and error text, and process ID. `ProcessOutputLine` identifies one output line and whether it came from standard error.

### High-Level Convenience APIs

#### Static Methods

The `ProcessStartInfo` overloads below require `UseShellExecute = false`, which is the default for .NET.
````
END THIRD-PARTY FILE f06d78035286539c

The third-party file has ended. Everything between the f06d78035286539c tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2719 of 11699 bytes. © dotnet · MIT · https://github.com/dotnet/skills/tree/HEAD/plugins/dotnet11/skills/process-api-net11/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md