Skills & Expertise📋

.NET Ecosystem📋

Core Platform📋

• C# 13, .NET 10, ASP.NET Core, Web API, Workers, SignalR
• Blazor (Server + WASM), Razor Pages, OpenAPI
• Entity Framework Core, LINQ, System.Text.Json
• .NET Aspire, dependency injection, configuration, logging

Roslyn & Source Generation📋

• Incremental source generators (ForAttributeWithMetadataName) — the backbone of the FrenchExDev ecosystem
• Roslyn semantic analysis: syntax trees, symbols, compilation inspection
• 2-step pattern: Extract (Roslyn analysis) → Emit (plain C# string building)
• .Lib separation: Roslyn types isolated in .SourceGenerator, emission logic in .SourceGenerator.Lib
• Code generation for: builders, DDD patterns, CLI wrappers, requirements traceability, quality metrics

Design Patterns & Architecture📋

• Domain-Driven Design — attribute-based, no base classes: [AggregateRoot], [Entity], [ValueObject], [Command], [DomainEvent], [Invariant]
• CQRS — lightweight (interface-level separation, no event sourcing): ICommandHandler<TCommand, TResult>, IQueryHandler<TQuery, TResult>, direct injection (no mediator)
• Result Pattern — composable Result<T, TError> types replacing exceptions: Map, Bind, Recover, Tap, Ensure
• Builder Pattern — source-generated async construction with fluent API, validation, circular reference detection
• Finite State Machine — generic FSM with enum-typed states and transitions
• Meta-metamodeling (M3) — 5 self-describing primitives ([MetaConcept], [MetaProperty], [MetaReference], [MetaConstraint], [MetaInherits]) forming the foundation for all DSLs

SOLID Principles (Applied, Not Theoretical)📋

• Interface Segregation as primary driver — 1-method interfaces as standard
• Dependency Inversion via optional constructor parameters with defaults
• Open/Closed through extension points and middleware pipelines
• No mocking frameworks — hand-written Fakes only, testing through real interfaces
• 100% code coverage as design pressure, not just a metric

Testing & Quality📋

• TDD — tests drive design, not just verify it
• QualityGate — custom Roslyn-based static analysis: cyclomatic complexity, cognitive complexity, coupling (Ca/Ce), cohesion (LCOM4), maintainability index
• Mutation testing (Stryker) — test quality score >= 0.95
• No mocking frameworks — FakeHttpClient, hand-written fakes, deterministic tests
• Quality gates in YAML (quality-gate.yml), enforced in CI with pass/fail exit codes

PHP Ecosystem📋

• Symfony, Doctrine ORM, Diem CMF (contributor, 2010)
• LAMP stack, Composer, Twig
• Legacy modernization and migration

JavaScript / Frontend📋

• TypeScript, Node.js, vanilla ES6+
• HTML5, CSS3, responsive design, CSS custom properties
• jQuery (legacy), Flash/Flex (legacy)
• Markdown rendering (marked.js), diagram generation (Mermaid), syntax highlighting (highlight.js)

DevOps & Infrastructure📋

CI/CD Pipeline Design📋

• GitLab CI/CD — pipelines, runners, package registry, container registry
• Jenkins, Job DSL (previous roles)
• Dev / CI / QA / CDel / CDep problem-space separation

Containers & Virtualization📋

• Docker, Docker Compose (V2) — type-safe wrappers
• Podman, Podman Compose — container-based scraping infrastructure
• Packer — VM image building with Alpine provisioning plugins
• Vagrant — VM lifecycle management with typed event hierarchies
• All CLI tools wrapped via BinaryWrapper with full IntelliSense

Scripting & Automation📋

• PowerShell 7+ — modules, cmdlets, tab completers, structured logging
  • DevPoSh (developer shell profile)
  • Infrastructure modules (Vagrant, Packer, Docker, Traefik)
  • Claude Code VM lifecycle management
• Bash — automation, CI scripts, container provisioning

Cloud & Infrastructure📋

• Azure, AWS (previous roles)
• On-premises GitLab CE deployment with container stack
• Traefik reverse proxy configuration
• Alpine Linux provisioning and hardening

Design-Time Engineering📋

A distinctive skill: building design-time tooling that runs before code generation.

• Design pipelines — composable middleware for scraping, transforming, and serializing versioned data
• Container-based scraping — parallel image builds + container execution via channels
• Version diffing — merge multiple version trees, compute [SinceVersion]/[UntilVersion] annotations
• Help parsers — GNU, Cobra, argparse, custom formats (5 parser implementations)
• JSON schema processing — download and transform versioned schemas from GitHub/GitLab

See the BinaryWrapper article for the full architecture.

Architecture & Methodology📋

Software Engineering Practices📋

• "anything-as-code" — infrastructure, configuration, requirements, quality gates
• "you better make it a module" — modular design with clear boundaries
• SDLC, ALM, PLM lifecycle management
• Web & distributed architectures, high availability, high volume

Domain-Driven Design Philosophy📋

• Attributes over base classes — developer declares intent, generator handles implementation
• Behavioral companions — constraint methods on MetaConcept base classes
• 4-layer metamodel: M0 (runtime) → M1 (domain model) → M2 (DSL) → M3 (meta-metamodel)
• 5 DSLs built on M3: DDD, Content, Admin, Pages, Workflow

Requirements Engineering📋

• Requirements as code — abstract classes with acceptance criteria as abstract methods
• 4-layer traceability: Requirement → Specification → Implementation → Test
• Compile-time enforcement: the build fails if any AC is unlinked
• typeof() and nameof() references (never strings)

AI-Assisted Development📋

• Claude Code (CLI) — daily driver for architecture design, code generation, testing, documentation
• Claude Code Skills — custom skill definitions for consistent code generation across the ecosystem
• Multi-LLM integration in DockAi: Claude, OpenAI, Ollama

Education📋

Soft Skills📋

• Strong team spirit and communication skills
• Self-taught, continuously learning — from PHP CMF contributor (2010) to .NET meta-metamodeling (2026)
• Agile methodology practitioner
• Fluent in English (written and spoken), French native
• Remote work experience across multiple positions