Blog📋

Technical articles on C#/.NET source generation, domain-driven design, metamodeling, DevOps, quality engineering, and building software that builds itself. Each post is drawn from real projects in a 57-project .NET monorepo.

Source Generation & DSLs📋

These articles cover Roslyn source generators, typed DSLs, and the meta-metamodeling framework that powers them all.

Modeling, Metamodeling, and Meta-Metamodeling in C#📋

Implementing a complete meta-metamodeling framework in C# using attributes as the DSL surface and multi-staged Roslyn source generators as the compilation pipeline.

Domain-Driven-Design & Code Generation📋

Domain-Driven Design as a modeling discipline combined with Roslyn source generation to produce typed domain implementations from attributed C# classes.

Content Management Framework: From Meta-modeling Theory to Full-Stack DDD Code Generation📋

Applying metamodeling theory to build a Content Management Framework for .NET with six DSLs compiled by Roslyn source generators into a full application stack.

BinaryWrapper: Type-Safe .NET Wrappers for CLI Binaries📋

Turn any CLI binary into a typed C# API by scraping its help output and generating version-aware command classes with IntelliSense and structured parsing.

Docker Compose Bundle: Unified Types from 32 Schema Versions📋

Merging 32 Docker Compose JSON Schema versions into one unified C# type system with version metadata, using Roslyn source generators.

Traefik Bundle: Typed Configuration from Traefik v3 JSON Schemas📋

Generating strongly-typed C# models and fluent builders from Traefik v3 JSON Schemas -- with real-world examples covering HTTPS, Let's Encrypt, security headers, rate limiting, circuit breakers, and more.

Injectable: Compile-Time DI Registration via Source Generation📋

How a single [Injectable] attribute shifts DI lifetime ownership to the service class and eliminates hand-written registration code through Roslyn source generation.

FiniteStateMachine: A Production-Grade Async FSM Framework for .NET📋

A fully async state machine framework for .NET with three tiers -- Dynamic, Typed, and Rich -- featuring guards, hierarchical states, and Result-based error handling.

Contention over Convention over Configuration over Code📋

A 10-part series on how the type system, Source Generators, and Roslyn Analyzers push beyond Convention to a fourth era where the compiler actively fights incorrect code -- and eliminates the double cost of documenting and enforcing conventions.

Auto-Documentation from a Typed System📋

A 9-part series on building a Document DSL that generates documentation from typed domain DSLs -- from DDD aggregates to deployment runbooks to Grafana dashboards, all as compiler output.

Entity.Dsl: Attribute-Driven EF Core from Domain Models📋

A 10-part series building an online marketplace domain with Entity.Dsl -- an attribute-based DSL that source-generates EF Core configurations, repositories, unit-of-work, and DI registration from decorated POCO classes.

DistributedTask.Dsl: Saga-Driven Distributed Processing from C# Attributes📋

A 16-part series building a distributed task system with DistributedTask.Dsl -- an attribute-based DSL that source-generates saga orchestrators, typed step contexts, queue consumers, API controllers, listening strategies, and resilience policies from decorated C# classes.

Requirements as Code📋

A series on type-safe requirements tracking -- where features are code, acceptance criteria are compiler-enforced, and the chain from definition to test never breaks.

Requirements as Code: A Type-Safe Chain from Feature Definition to End-to-End Testing📋

A type-safe requirements tracking DSL in C# that makes the compiler enforce the chain from feature definition to specification to implementation to tests.

Requirements as Code in TypeScript📋

Implementing a self-tracking requirements DSL in TypeScript -- where features are abstract classes, acceptance criteria are abstract methods, decorators link tests to features, and the compiler refuses to build if the chain breaks.

Onboarding Typed Specifications: From Zero to Compiler-Verified Features📋

A 7-part series documenting how a personal CV website evolved through four phases -- SPA, static generation, multi-layer testing, and typed specifications -- until the compiler itself could answer: "Is every feature tested?"

Scaling Requirements as Code📋

A plan for scaling the TypeScript requirements tracking system beyond 20 features -- code generation from Jira, Linear, databases, and YAML files.

The No-Spec Cost: Scaling Requirements in Industrial Monorepos📋

A 6-part series on why industrial monorepos fail -- ServiceProvider god-objects, physical-only boundaries, requirements lost in Jira -- and how Requirements as Projects create compiler-enforced logical boundaries that scale to 50+ projects and 15 teams.

Typed Specifications vs. Everything Else📋

A systematic comparison of typed specifications against Jira, BDD, Allure/TestRail, xUnit traits, directory conventions, wiki matrices, contract testing, and Roslyn source generators -- with code examples, a comparison matrix, and an honest assessment of when each approach fits.

tspec: Compiler-Enforced Project Management for Enterprise Teams📋

A 13-part series designing a B2B enterprise product around typed specifications -- M3 meta-metamodel, language backends, Diem CMF instance, custom workflows, support levels, and a dashboard that replaces Jira's traceability layer.

Where Requirements Meet DDD📋

How the type-safe requirements tracking system maps to Domain-Driven Design concepts -- features as bounded contexts, acceptance criteria as use case specifications, and the hexagonal architecture that connects them all.

The Human Side of Requirements as Code📋

When acceptance criteria are abstract methods written alongside the Product Owner, the ubiquitous language stops being a concept and becomes a daily practice.

Content Management Framework📋

A comprehensive multi-part series on building a CMF from scratch using DDD, type-safe requirements tracking, TDD, and Roslyn source generation.

Building a Content Management Framework📋

The full series: from meta-metamodel theory to six DSLs compiled by Roslyn source generators into a complete application stack. Twelve chapters covering vision, feature catalog, M3 foundation, DDD DSL, content modeling, admin generation, workflow orchestration, and more.

Quality & Testing📋

Articles on quality engineering, test infrastructure, and the philosophy that quality is a structural problem, not a discipline problem.

QualityGate: Roslyn-Powered Static Analysis and Quality Metrics for .NET📋

A Roslyn-powered quality gate tool that enforces thresholds for complexity, coupling, cohesion, coverage, and mutation testing at build time.

Quality to Its Finest: Testing a Terminal-Styled CV Website📋

A deep dive into multi-layer quality assurance -- 481 unit tests, 54 E2E tests, 229 visual regression screenshots, 121 accessibility audits, property-based fuzzy testing, and a Husky pre-push gate.

Hardening the Test Pipeline📋

How smoke filtering, auto-baseline creation, compliance tracking, and pre-push hooks turned a fragile test suite into a sustainable quality gate.

Don't Put the Burden on Developers📋

When bugs slip through, tests get skipped, or architecture erodes, the default reaction is "developers should be more careful." That reaction is always wrong. Every recurring failure is a structural gap.

Patterns & Architecture📋

Foundational design patterns and migration strategies used across the monorepo.

Result Pattern: Give Value to Your Exceptions📋

The Result pattern makes success and failure explicit in the type system, forcing developers to validate data before moving forward instead of relying on exceptions.

Builder Pattern: Creational Pattern📋

A comprehensive guide to the Builder pattern in .NET with an async-first framework handling circular references, validation accumulation, and concurrent access.

From a Big Ball of Mud to DDD: A Migration Field Guide📋

A multi-part series on migrating a legacy monolith to Domain-Driven Design -- from diagnosis through Event Storming, incremental refactoring, library extraction, and testing. Follows SubscriptionHub, a 6-year-old SaaS billing platform with 4 teams and 80K lines.

Infrastructure as Code: My Journey📋

From Bash scripts to PowerShell modules -- how I learned to automate infrastructure with an anything-as-code philosophy across Docker, Packer, and Vagrant.

This Website📋

The story of building this terminal-styled CV site -- from PDF to SPA to static site, and the AI collaboration that made it happen.

This Website: From PDF to Terminal-Styled SPA in 72 Hours📋

How a PDF resume became a terminal-themed, markdown-driven single-page application with Mermaid diagrams, scroll spy, and four color themes in 72 hours.

From Terminal-Styled SPA to Static Site📋

Converting a JavaScript-only SPA into a crawlable static site with progressive enhancement, pre-rendered mermaid diagrams, full SEO, and a shared code architecture.

15 State Machines, Zero Frameworks: Architecture of a Terminal-Themed CV Site📋

A 6-part series on extracting 15 pure state machines from a vanilla JS SPA, migrating to TypeScript with esbuild, and testing them with 98%+ coverage using Vitest and Playwright.

From 1270 Lines to State Machines: Rebuilding a Developer CLI📋

How we replaced a monolithic workflow script with state machine-driven architecture, testable I/O abstraction, and three switchable TUI modes -- using the same patterns as the site's frontend.

The Journey: Building This Site with Claude📋

The complete story of how a PDF resume became a terminal-styled SPA, then a static site, then a polished product -- through iterative human-AI collaboration.

About Me and This Site: 165 Commits in 10 Days📋

A data-driven retrospective on how this CV website was built -- git history analysis revealing work patterns, nocturnal coding sessions, and the relentless iteration cycle.

Website Front-End Design📋

Comprehensive design document covering all 28 state machines, CSS animations, DOM events, accessibility patterns, and cross-machine interactions.