What does ln-722-backend-generator output look like?

A complete .NET solution with layered projects: Api, Domain, Services, Repositories, and Shared, plus mock data scaffolding and optional middleware.

Does the generator implement business logic or database connections?

No. It creates boilerplate code and mock data, not concrete business logic or DB connections. You add services and data access later.

Can I customize the generated templates or naming conventions?

Yes. The generator follows defined patterns (e.g., public Guid Id, string Name = string.Empty, {Entity}Status) and can be adjusted to fit project-specific conventions.

ln-722-backend-generator

Scanned

npx machina-cli add skill levnikolaevich/claude-code-skills/ln-722-backend-generator --openclaw

Files (1)

SKILL.md

6.9 KB

Paths: File paths (shared/, references/, ../ln-*) are relative to skills repo root. If not found at CWD, locate this SKILL.md directory and go up one level for repo root.

ln-722-backend-generator

Type: L3 Worker Category: 7XX Project Bootstrap Parent: ln-720-structure-migrator

Generates complete .NET backend structure following Clean Architecture principles.

Purpose & Scope

Aspect	Description
Input	Project name, entity list, configuration options
Output	Complete .NET solution with layered architecture
Target	.NET 10+, ASP.NET Core

Scope boundaries:

Generates project structure and boilerplate code
Creates MockData for initial development
Does not implement business logic or database connections

Workflow

Phase	Name	Actions	Output
1	Receive Context	Get project name, entities, options from coordinator	Configuration
2	Create Solution	Create .sln and .csproj files	Empty solution structure
3	Generate Domain	Create entities, enums, base classes	Domain project files
4	Generate API	Create controllers, DTOs, middleware	API project files
5	Verify	Build solution, check references	Build success

Phase 1: Receive Context

Accept delegation from ln-720-structure-migrator.

Input	Type	Required	Description
`projectName`	string	Yes	Solution and project name prefix
`targetPath`	string	Yes	Directory for generated solution
`targetFramework`	string	Yes	.NET version (e.g., net10.0)
`entities`	list	Yes	Entity names to generate
`features`	list	Yes	Feature groupings for MockData

Options:

Option	Default	Effect
`useSwagger`	true	Add Swashbuckle for API docs
`useSerilog`	true	Add structured logging
`useHealthChecks`	true	Add health endpoints
`createMockData`	true	Generate mock data classes

Phase 2: Create Solution

Generate solution file and project structure.

Step	Action	Reference
2.1	Create solution directory	—
2.2	Generate .sln file	—
2.3	Create project directories	`layer_structure.md`
2.4	Generate .csproj files per layer	`layer_structure.md`
2.5	Add project references	`layer_structure.md`

Generated projects:

Project	Purpose
`{Project}.Api`	HTTP endpoints, middleware
`{Project}.Domain`	Entities, enums
`{Project}.Services`	Business logic interfaces
`{Project}.Repositories`	Data access interfaces
`{Project}.Shared`	Cross-cutting utilities

Phase 3: Generate Domain

Create domain layer files.

Step	Action	Reference
3.1	Create `BaseEntity` class	`entity_patterns.md`
3.2	Generate entity classes per input	`entity_patterns.md`
3.3	Generate status enums	`entity_patterns.md`
3.4	Create folder structure	`layer_structure.md`

Entity generation rules:

Entity Property	Generated As
Primary key	`public Guid Id { get; set; }`
String field	`public string Name { get; set; } = string.Empty;`
Status field	`public {Entity}Status Status { get; set; }`
Timestamps	`CreatedAt`, `UpdatedAt` from BaseEntity

Phase 4: Generate API

Create API layer files.

Step	Action	Reference
4.1	Generate Program.cs	`program_sections.md`
4.2	Generate controllers per entity	`controller_patterns.md`
4.3	Generate DTOs per entity	`controller_patterns.md`
4.4	Generate middleware classes	`layer_structure.md`
4.5	Generate extension methods	`program_sections.md`
4.6	Generate MockData classes (if enabled)	`layer_structure.md`
4.7	Add NuGet packages	`nuget_packages.md`

Controller endpoints per entity:

Endpoint	Method	Route
GetAll	GET	`/api/{entities}`
GetById	GET	`/api/{entities}/{id}`
Create	POST	`/api/{entities}`
Update	PUT	`/api/{entities}/{id}`
Delete	DELETE	`/api/{entities}/{id}`

Phase 5: Verify

Validate generated solution.

Check	Command	Expected
Solution builds	`dotnet build`	Success, no errors
Project references	Check .csproj	All references valid
Files created	Directory listing	All expected files present

Generated Structure Summary

Layer	Folders	Files per Entity
Api	Controllers/, DTOs/, Middleware/, MockData/, Extensions/	Controller, DTO
Domain	Entities/, Enums/, Common/	Entity, Status enum
Services	Interfaces/	Interface (stub)
Repositories	Interfaces/	Interface (stub)
Shared	—	Utility classes

Critical Rules

Single Responsibility: Generate only backend structure, no frontend
Idempotent: Can re-run to regenerate (will overwrite)
Build Verification: Must verify dotnet build passes
Clean Architecture: Respect layer dependencies (inner layers independent)
No Business Logic: Generate structure only, not implementation
MockData First: Enable immediate API testing without database

Definition of Done

Solution file created with all projects
All project references configured correctly
Domain entities generated for all input entities
Controllers generated with CRUD endpoints
DTOs generated for request/response
MockData classes generated (if enabled)
Program.cs configured with all services
dotnet build passes successfully
Swagger UI accessible (if enabled)

Risk Mitigation

Risk	Detection	Mitigation
Build failure	`dotnet build` fails	Check .csproj references, verify SDK version
Missing references	CS0246 errors	Add missing project references
Invalid entity names	Build or runtime errors	Validate entity names before generation
Path conflicts	File exists errors	Check target path, prompt before overwrite
Package restore failure	NuGet errors	Verify network, check package names

Reference Files

File	Purpose
`references/layer_structure.md`	Project organization, folder structure, dependencies
`references/entity_patterns.md`	Entity generation rules, property patterns
`references/controller_patterns.md`	Controller and DTO generation rules
`references/program_sections.md`	Program.cs structure and service registration
`references/nuget_packages.md`	Required and optional NuGet packages

Version: 2.0.0 Last Updated: 2026-01-10

Source

git clone https://github.com/levnikolaevich/claude-code-skills/blob/master/ln-722-backend-generator/SKILL.mdView on GitHub

Overview

Generates a complete .NET backend structure following Clean Architecture from entity definitions. It outputs a multi-project solution with Api, Domain, Services, Repositories, and Shared layers, plus optional mock data, Swagger, Serilog, and health checks.

How This Skill Works

The skill ingests projectName, targetPath, targetFramework, entities, and features, then scaffolds the solution, creates the .sln and per-layer projects, and generates domain models, enums, and base classes. It then creates API controllers, DTOs, and middleware, and optionally wires mock data and health endpoints, validating the build at the end.

When to Use It

Starting a new .NET service with a defined domain model to bootstrap a consistent architecture
Bootstrapping a multi-project Clean Architecture solution from an entity list
Prototyping APIs with standard domain patterns before implementing business logic
Generating mock data scaffolding for early development and UI integration
Preparing a ready-to-run solution with optional Swagger, Serilog, and health checks for CI/CD

Quick Start

Step 1: Provide projectName, targetPath, targetFramework, entities, and features as inputs
Step 2: Enable options like useSwagger, useSerilog, useHealthChecks, and createMockData as needed
Step 3: Run the generator, then open the produced {Project}.Api solution, build, and extend with business logic

Best Practices

Define a complete entity set before generation and let the tool create domain models and enums
Enable optional features (Swagger, Serilog, HealthChecks, MockData) to accelerate initial development
Review generated Domain and API layers; add business logic in Services after scaffolding
Use the provided mock data to test API controllers and DTO mappings before DB integration
Follow the generated naming conventions (e.g., Id as Guid, Status enums) for consistency

Example Use Cases

Bootstrap an Inventory service with Product and Stock entities and API controllers
Create a User management microservice with User, Role, and Permission entities
Set up a Ticketing system backend with Ticket and TicketStatus and associated DTOs
Launch a Blog platform skeleton with Post and Comment entities and DTO mappings
Build an Order processing service with Order, OrderLine, and Payment entities

Frequently Asked Questions

Add this skill to your agents