Talks for engineers who ship.

A practical session that turns S.O.L.I.D from acronym trivia into a shared code-review language. It uses C#, TypeScript, dependency injection, testing seams, and refactoring examples to show how single responsibility, open/closed extension points, substitutable abstractions, interface segregation, and dependency inversion reduce modernization risk.

• Recognize design smells before they become release risk.
• Refactor toward smaller units without rewriting everything.
• Use tests and interfaces as leverage for maintainability.

A pattern-literacy talk for teams that need a shared vocabulary around construction, composition, and behavior. It focuses on when patterns help, when they overcomplicate, and how adapters, factories, strategies, decorators, observers, and repositories show up in enterprise .NET and JavaScript systems.

• Map familiar code to proven pattern names.
• Choose composition over accidental coupling.
• Avoid pattern cargo-culting with context-driven examples.

A standards-and-practice session on durable AI context. It connects UAIX AI Memory packages, Project Handoff, receiver briefs, source authority, review gates, and validator-backed evidence with LLMWikis-style durable knowledge bases that humans and agents can cite, audit, repair, and govern.

• Separate portable AI memory from durable wiki knowledge.
• Make source authority, trust labels, and quality status visible.
• Hand off projects without relying on hidden chat history.

A practical session on connecting SEO-first Angular/TypeScript interfaces to Python-backed AI and metadata pipelines. It covers SSR/SSG route strategy, RxJS streams, typed payloads, cancellation/retry behavior, evidence-driven UI states, and review gates around non-deterministic AI output.

• Treat AI output as an integration context.
• Use Angular/RxJS to make async state explicit without client-only rendering.
• Keep Python pipeline results evidence-supported and reviewable.

A developer-focused presentation on using TypeScript as a design tool, not just a compile step. It covers domain types, discriminated unions, API contracts, client-side tests, progressive migration from JavaScript, and how typed front ends reduce ambiguity between UX, APIs, and business rules.

• Convert risky JavaScript surfaces in small steps.
• Model API and UI state explicitly.
• Improve refactoring confidence with types and tests.

A production-oriented talk about moving beyond demos into practical API use. It walks through prompts, structured outputs, rate limits, local models, OpenAI-compatible APIs, semantic search, auditing, failure modes, and review loops for teams adding AI assistance to existing applications.

• Design AI calls as observable integration points.
• Keep deterministic rules around non-deterministic output.
• Use reviewable evidence before automating critical changes.

A pragmatic session on using AI assistants for rapid prototyping while preserving engineering discipline. It shows how to shape context, request tests, constrain edits, review generated code, iterate on UI, and turn vibe-coded prototypes into maintainable, versioned software.

• Write prompts that create inspectable work products.
• Convert fast prototypes into reviewed code.
• Use AI speed without abandoning architecture and tests.