Temper-AI

Structure and rules for .NET projects using Clean Architecture with DDD. Use when the project has complex business domain, multiple use cases, need to test business logic in isolation, or when the system is enterprise, e-commerce, ERP, CRM, or any rich domain. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.

Structure and rules for .NET projects using Hexagonal Architecture (Ports & Adapters). Use when the project has multiple input channels (API, CLI, message queue), need to test the domain in isolation, or when adapters change frequently. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.

Structure and rules for .NET projects using Onion Architecture. Use when the project has a strong domain-centric focus with DDD, aggregate roots, and the Specification pattern. All dependencies point inward toward the domain core. Do not use for simple CRUDs without logic — prefer Vertical Slice in that case. For implementation details, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.

Canonical DbContext setup and registration rules for EF Core. Load when creating or modifying DbContext classes or their DI wiring.

Pure LINQ standards for .NET 10 projects. Covers language operators, query composition, projection patterns, filtering, grouping, and performance best practices over IEnumerable<T> and IQueryable<T>. Load when writing or reviewing LINQ expressions in any layer. DO NOT load expecting EF Core-specific methods (ToListAsync, AsNoTracking, Include, ExecuteUpdateAsync) — those belong to `backend/dotnet/orms/ef-core/query-best-practices/SKILL.md`.

Canonical rules for using AppDbContext DIRECTLY from application code (use cases / handlers) when the project's data-access pattern is Direct DbContext — no repositories, no UnitOfWork. Load when the chosen pattern is Direct DbContext and a use case reads or writes data. This is the counterpart to repository-usage; never load both for the same task.

Canonical EF Core query best practices for TemperAI: how each query method behaves, how to write performant queries, and the highest-value EF Core tricks. Load whenever a task writes EF Core queries — inside a repository OR directly against AppDbContext in a use case. Pattern-agnostic: the query rules are the same regardless of whether the project uses repositories or a direct DbContext.

Canonical repository and UnitOfWork creation rules for EF Core. Load when creating repositories or UnitOfWork from scratch.

Canonical rules for using existing repositories and UnitOfWork from application code. Load when calling repositories or CompleteAsync from use cases.

How the backend agent keeps the Dependencies section of Docs/Application/Architecture/backend-config.md in sync with the real project. Load only when a task adds, removes, or upgrades a NuGet package. Reconciles the Dependencies list from the actual .csproj PackageReference entries — never touches the architect's decision fields.

Canonical use case structure, naming, and DI conventions for backend tasks. Load when creating or modifying use cases or controllers that invoke them. Do not load for Vertical Slice handlers.

Mode A (Architectural Design) workflow for temper-architect — the full sequence from reading the PRD through proposal, confirmation, document offer, and generation. Load this skill after the architect detects Architectural Design mode in Phase 1, and execute it start to finish.

Contains all document templates the temper-architect agent generates. Includes templates for architecture-decision.md, backend-config.md, frontend-config.md, and architectural-plan.md. Load this skill when the architect needs to generate any of these documents after proposal confirmation.

Contains all structured proposal and report formats the temper-architect agent emits during its workflow. Includes startup report, mode report, domain analysis, problem analysis, architectural proposal, architectural plan, updated proposal, document offer, required docs completion, and final completion report. Load this skill when the architect needs to format any of these outputs.

Mode B (Problem Solving) workflow for temper-architect — analyzing a bug, design issue, or blocking technical decision and producing a confirmed architectural plan. Load this skill after the architect detects Problem Solving mode in Phase 1, and execute it start to finish.

ASP.NET Core API standards for .NET 10 projects. Covers controllers, middleware, routing, error handling, DI setup, logging, FluentValidation, nullable reference types, and appsettings structure. Load when creating or modifying controllers, middleware, Program.cs, or validators. DO NOT load for domain or repository tasks — load dotnet-ddd or the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf instead. For API documentation provider wiring, load exactly one provider skill based on backend config: `backend/dotnet/api-docs/scalar/SKILL.md` or `backend/dotnet/api-docs/swagger/SKILL.md`. For general C# conventions, `backend/dotnet/csharp/SKILL.md` must be loaded first.

Structure and rules for .NET projects using Vertical Slice Architecture. Use for CRUDs, MVPs, rapid prototypes, or simple systems where Clean Architecture would be overkill. Do not use for complex business domains — prefer Clean Architecture in that case. For data access implementation, load the required `backend/dotnet/orms/ef-core/*/SKILL.md` leaf skill(s) or your chosen data access skill.

Universal C# / .NET 10 standards that apply to ANY .NET project regardless of architecture or layer. Covers syntax, usings, naming, async patterns, null safety, and DTO conventions. ALWAYS load this skill for ANY agent that writes C# code. DO NOT load for tasks that only read or analyze existing code without writing.

Domain-Driven Design standards for .NET 10 projects. Covers entity design, aggregates with child entities, domain events, and domain rules. Load when creating or modifying any Domain layer component — entities, enums, events, aggregates. DO NOT load for infrastructure, repository, or controller tasks. Value Objects are intentionally NOT used — primitives are used directly in entities.

Canonical EF Core bulk and batch operation guidance. Load only for explicit high-volume insert or batch tasks.

Canonical EF Core Fluent API entity configuration rules. Load when creating or modifying IEntityTypeConfiguration classes.

Canonical DTO naming, structure, and mapping conventions for backend tasks. Load when creating or modifying DTOs.

Canonical Result<T> pattern for backend tasks. Load on every backend task.

Canonical SOLID and Clean Code rules for backend tasks. Load on every backend task.

Testing standards for .NET 10 projects using xUnit, Moq, and bUnit. Covers unit tests for domain and application layers, integration tests for APIs, and component tests for Blazor. Use when creating or modifying any test files.

Blazor WebAssembly standards for .NET 10 frontend work. Use ONLY for Blazor WebAssembly components, pages, routing, forms, client-side state, API clients, JavaScript interop, accessibility, and frontend services. Do not use for Blazor Server or Angular work.

bUnit testing standards for Blazor components. Covers component rendering tests, event handling tests, parameter binding tests, and state verification. Use when creating or modifying Blazor component tests.

Implementation-agent delegation contract for FRIDAY. Load when FRIDAY delegates to temper-backend, temper-frontend, temper-tester, temper-devops, or another implementation agent, including task-driven, direct-action, bugfix, and recovery turns.

State file JSON schema, status values, and generic delegation rules for the FRIDAY orchestrator. Load this skill whenever FRIDAY needs to read, write, or validate .temper/friday-state.json.

User Story and specification generation skill for TemperAI. Use when converting an approved PRD into structured user stories with acceptance criteria, business rules, edge cases, and error cases. Loaded by temper-analyst during Phase 2 (Spec generation). Teaches how to write implementation-agnostic specifications — no technical details.

Internal self-questioning framework for the TemperAI analyst agent. Activates at specific checkpoints across Phase 1 and Phase 2 to ensure no hidden stakeholder, implicit requirement, failure mode, or logical gap survives into a deliverable. This skill never produces visible output — it shapes the quality of every report, gap, PRD, and spec the analyst emits. Loaded by temper-analyst at session start alongside functional-analysis.

Functional requirements analysis skill for TemperAI. Use when eliciting requirements from users and preparing to generate a PRD. Teaches the analyst how to think functionally, detect gaps, ask the right questions, and classify uncertainty correctly. Loaded by temper-analyst during Phase 1 (Functional Analysis & PRD Generation).

PRD (Product Requirements Document) template for the temper-analyst agent. Contains the full 10-section PRD structure generated during Phase 1.7, including header metadata, all required sections, and the scope rule note. Load when generating or validating Docs/Functional-Analysis/PRD.md files.

All structured report formats used by the temper-analyst agent across Phase 1 (PRD) and Phase 2 (Spec). Contains every report template the analyst emits during its workflow: startup, input synthesis, delta analysis, gap reports, resolution status, contradictions, completeness checklist, and phase completion reports.

Session-mode recommendation policy for FRIDAY. Load when FRIDAY needs to recommend clean session versus continue here after a completed specialist step and an approved meaningful continuation.

API documentation provider skill for Scalar. Load only when backend config selects Scalar and the task touches API documentation wiring.

API documentation provider skill for Swagger. Load only when backend config selects Swagger and the task touches API documentation wiring.

DDD documentation generation standards for TemperAI. Teaches how to produce DDD-Vocabulary, domain-model, and system-architecture documents. Generates three documents: one operational vocabulary file consumed by implementation agents, and two documentation files with Mermaid diagrams covering the domain model and system architecture. Load this skill when generating or modifying any DDD documentation file. Does NOT teach implementation patterns (use dotnet-ddd for that).

Ubiquitous Language concepts for TemperAI. Teaches implementation agents how to understand, extract, and use domain terminology consistently when reading specs, tasks, and DDD documentation. Load this skill when implementing any backend or frontend task.

Angular Material standards. Use ONLY when an Angular project already uses Angular Material or the task explicitly asks for Material components, theming, dialogs, tables, forms, overlays, navigation, or accessibility. Do not use for Blazor or Angular projects without Material.