architect

Define clean architecture layers, entities, and services for the Pomodoro Time Tracker.

Updated Nov 20, 2025
One-click install
npx skills add https://github.com/manx/PomodoroTimeTracker --skill architect-manx
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architect
Source: https://github.com/manx/PomodoroTimeTracker/tree/main/.claude/skills/architect
Command: npx skills add https://github.com/manx/PomodoroTimeTracker --skill architect-manx

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides comprehensive guidance on the Clean Architecture principles applied to the Pomodoro Time Tracker. It helps maintain clear layer separation, make sound design decisions, and facilitates effective refactoring, ensuring the project remains scalable, testable, and maintainable.

Core Features & Use Cases

  • Layer Structure: Clearly defines the responsibilities and dependencies of the Domain, Application, Infrastructure, ViewModels, and WinUI3 layers, promoting modularity.
  • Key Entities & Services: Outlines the core domain entities and the specific responsibilities of application services, clarifying business logic organization.
  • Decision Records: Documents important architectural decisions made for the project, such as the unified TimeEntry and IDispatcherTimer abstraction, providing context for design choices.
  • Use Case: When considering a major refactor or adding a complex new module, activate this Skill to review the project's architectural guidelines, understand layer interactions, and ensure your design aligns with established patterns, preventing architectural drift.

Quick Start

Using the architect skill, explain the purpose and dependencies of the Application layer in the Pomodoro Time Tracker project and list its key services.

Frequently Asked Questions about architect

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

FAQPage Schema
How do I structure a .NET application using Clean Architecture principles?

Clean Architecture organizes .NET applications into distinct layers—Domain, Application, Infrastructure, and UI—where each layer has specific responsibilities and dependencies flow inward. This separation enables testability, maintainability, and scalability by isolating business logic from frameworks and external concerns.

What's the best way to separate concerns across Domain, Application, and Infrastructure layers?

Domain layer contains core entities and business rules; Application layer orchestrates use cases through services like ITimeEntryService and IStatisticsService; Infrastructure layer handles persistence and external integrations. Each layer depends only on layers closer to the center, preventing tight coupling and enabling independent testing.

How do I design services and entities for a time-tracking application?

Define core entities (TimeEntry, SessionType, Client, Project, PomodoroSettings) in the Domain layer, then create Application services (ITimeEntryService, IClientService, IProjectService) that encapsulate business logic. Services coordinate between layers while entities remain persistence-agnostic, supporting refactoring and schema evolution.

When should I refactor my application architecture to prevent architectural drift?

Refactor when adding complex modules, restructuring data models, or noticing layer violations. Use architectural guidelines and decision records to review layer interactions, ensure new designs align with established patterns, and maintain scalability and testability as requirements evolve.

What patterns should I use for ViewModels and timers in a WinUI3 desktop application?

Use Singleton lifetime for application-wide instances like IDispatcherTimer abstractions, and Transient for ViewModel instances created per view. Abstract timer implementations behind interfaces to enable testability and decouple UI frameworks from business logic.

How do I model session types as entities rather than enums for extensibility?

Store SessionType as a domain entity with properties and relationships instead of a static enum. This allows runtime configuration, database-driven variations, and future feature additions without code changes, supporting evolving business requirements for time-tracking categories.