dotnet-writing-plans

Name: dotnet-writing-plans
Availability: InStock
Author: fiatkongen

Generate structured implementation plans from feature specs for .NET backend tasks.

Updated Jan 15, 2026

Search Tags:#planning #architecture #TDD #dotnet #spec #implementation-plan

Ready to run

npx skills add https://github.com/fiatkongen/saurun-marketplace --skill dotnet-writing-plans

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: dotnet-writing-plans
Source: https://github.com/fiatkongen/saurun-marketplace/tree/main/plugins/saurun/skills/dotnet-writing-plans
Command: npx skills add https://github.com/fiatkongen/saurun-marketplace --skill dotnet-writing-plans

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams translate a product spec or requirements into a concrete, architecture-aligned implementation plan for multi-step .NET backend tasks, reducing ambiguity and enabling TDD-driven delivery.

Core Features & Use Cases

Plan generation: Create a structured set of tasks, each with file paths, expected behaviors, and dependencies, based on the provided spec.
Architecture references: Link plans to architecture contracts to ensure alignment and traceability.
Use Case: Given a feature spec for a new authentication flow, generate a staged plan outlining domain tasks, API contracts, and persistence changes.

Quick Start

Start by providing a feature spec or requirements for a .NET backend task. The skill will output a ready-to-use implementation plan skeleton that you can save to _docs/plans.

Frequently Asked Questions about dotnet-writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I generate an implementation plan from a feature spec for a .NET backend?▼

A .NET implementation plan is a structured document of discrete tasks with file paths, expected behaviors, and dependencies. It is generated from a feature spec and saved as a markdown file to ensure architecture-aligned, TDD-driven delivery.

What is the best way to align .NET implementation tasks with existing architecture contracts?▼

Aligning .NET tasks with architecture contracts means linking your generated implementation plan directly to established architecture rules. This ensures every discrete task, file path, and expected behavior maintains traceability with the system's structural design.

Can I use this approach to plan TDD-driven delivery for multi-step .NET tasks?▼

Yes, you can use this approach to plan TDD-driven delivery for multi-step .NET tasks. It translates product specs into staged plans outlining domain tasks, API contracts, and persistence changes, incorporating expected tests and behaviors per task.

Does the generated .NET plan include actual code implementation or just the task structure?▼

The generated .NET plan includes only the task structure and not actual code implementation. It outputs a ready-to-use skeleton organized as discrete tasks with files, tests, behaviors, and dependencies to guide subsequent coding.

How do I structure implementation plans for complex .NET backend features?▼

Structuring implementation plans for complex .NET features involves breaking them into discrete tasks. Each task section in the saved markdown document specifies required files, dependencies, and expected behaviors derived from the original feature spec.