┌─────────────────────────────────────────────────────────────────┐
│                    DEVELOPMENT WORKFLOW                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐                                               │
│  │  Understand  │  Read requirements, explore codebase          │
│  │    Task      │                                               │
│  └──────────────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────┐                                               │
│  │  Implement   │  Write code following patterns                │
│  │   Changes    │                                               │
│  └──────────────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────┐     ┌──────────────┐                         │
│  │   Validate   │────▶│   Report     │                         │
│  │ Build/Test/  │     │   Results    │                         │
│  │   Analyze    │     │              │                         │
│  └──────────────┘     └──────────────┘                         │
│         │                    │                                  │
│         ▼                    ▼                                  │
│    ┌─────────┐         ┌──────────┐                            │
│    │  PASS?  │───NO───▶│   Fix    │                            │
│    └─────────┘         │  Issues  │                            │
│         │              └──────────┘                            │
│         │                    │                                  │
│        YES                   │                                  │
│         │                    │                                  │
│         ▼                    │                                  │
│  ┌──────────────┐           │                                  │
│  │   Ready to   │◀──────────┘                                  │
│  │    Commit    │         (re-validate)                        │
│  └──────────────┘                                              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// Find existing patterns
// Look for similar implementations in the codebase
// Follow established conventions

// Example: If services follow this pattern
public class ExistingService : IExistingService
{
    private readonly IRepository _repository;
    private readonly ILogger<ExistingService> _logger;

    public ExistingService(IRepository repository, ILogger<ExistingService> logger)
    {
        _repository = repository;
        _logger = logger;
    }
}

// New service should follow same pattern
public class NewService : INewService
{
    private readonly IRepository _repository;
    private readonly ILogger<NewService> _logger;

    public NewService(IRepository repository, ILogger<NewService> logger)
    {
        _repository = repository;
        _logger = logger;
    }
}

# 1. Build (catch compilation errors)
dotnet build --no-incremental

# 2. Run tests (verify behavior)
dotnet test --no-build

# 3. Static analysis (code quality)
dotnet build /p:TreatWarningsAsErrors=true
dotnet format --verify-no-changes

# Full validation
dotnet build --no-incremental && \
dotnet test --no-build && \
dotnet format --verify-no-changes

// Group related code
// 1. Fields
private readonly IService _service;

// 2. Constructors
public MyClass(IService service) => _service = service;

// 3. Public methods
public void Execute() { }

// 4. Private methods
private void Helper() { }

// Be specific with exceptions
public User GetUser(int id)
{
    var user = _repository.Find(id);
    if (user == null)
        throw new EntityNotFoundException($"User {id} not found");
    return user;
}

// Use guard clauses
public void Process(Request request)
{
    ArgumentNullException.ThrowIfNull(request);
    ArgumentException.ThrowIfNullOrEmpty(request.Name);

    // Main logic
}

// Always use async suffix
public async Task<User> GetUserAsync(int id)
{
    return await _repository.FindAsync(id);
}

// Don't block on async
// BAD
var user = GetUserAsync(id).Result;

// GOOD
var user = await GetUserAsync(id);

// Register services
services.AddScoped<IUserService, UserService>();
services.AddSingleton<ICacheService, MemoryCacheService>();
services.AddTransient<IEmailSender, SmtpEmailSender>();

// Inject via constructor
public class UserController
{
    private readonly IUserService _userService;

    public UserController(IUserService userService)
    {
        _userService = userService;
    }
}