Developer, architect, and builder of things.https://thurley.dev/https://thurley.dev/blog/ai-fundamentals-business-case/https://thurley.dev/blog/ai-fundamentals-business-case/Why organizations should invest in AI. ROI frameworks, competitive dynamics, practical adoption paths, and the risk of waiting.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-choosing-models/https://thurley.dev/blog/ai-fundamentals-choosing-models/LLMs vs SLMs, open vs closed, cloud vs on-device. A practical framework for selecting the right AI model for your use case, budget, and constraints.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-how-llms-work/https://thurley.dev/blog/ai-fundamentals-how-llms-work/What happens inside a large language model. Neural networks, transformers, attention, training, parameters, and inference. How the machine turns text into text.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-overview/https://thurley.dev/blog/ai-fundamentals-overview/A high-level map of the modern AI stack. LLMs, tokens, embeddings, RAG, fine-tuning, agents, and how they all fit together. The first post in a series covering AI fundamentals from the ground up.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-embeddings-and-vectors/https://thurley.dev/blog/ai-fundamentals-embeddings-and-vectors/How text becomes numbers that capture meaning. Embeddings, vector similarity, vector databases, and the practical applications that depend on them.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-prompting-and-inference/https://thurley.dev/blog/ai-fundamentals-prompting-and-inference/How to communicate effectively with LLMs. System prompts, few-shot examples, chain-of-thought, structured output, temperature, and sampling strategies.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-fine-tuning/https://thurley.dev/blog/ai-fundamentals-fine-tuning/When and how to fine-tune an LLM. Full fine-tuning, LoRA, RLHF, and the decision framework for choosing between fine-tuning, RAG, and prompting.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-agents/https://thurley.dev/blog/ai-fundamentals-agents/How models move beyond text generation to take actions. Function calling, tool use, agent architectures, and building autonomous workflows.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-rag/https://thurley.dev/blog/ai-fundamentals-rag/Retrieval-Augmented Generation explained. How to give LLMs access to your own data through chunking, embedding, retrieval, and generation.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-fundamentals-tokens-and-context/https://thurley.dev/blog/ai-fundamentals-tokens-and-context/How models break text into tokens, why context windows have limits, and what this means for cost, capability, and application design.Thu, 19 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/claude-code-primer/https://thurley.dev/blog/claude-code-primer/Most developers type prompts and accept suggestions. That's 20% of what Claude Code can do. Here's the other 80%: rules, plugins, skills, hooks, subagents, MCP servers, and the prompt patterns that make all of it work.Fri, 13 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/the-infinite-expert/https://thurley.dev/blog/the-infinite-expert/You don't need expertise in every language, framework, or protocol anymore. AI fills the syntax gap. Your job is knowing how to build software well.Fri, 06 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/business-case-for-domain-driven-design/https://thurley.dev/blog/business-case-for-domain-driven-design/Why Domain-Driven Design matters to leadership: reduced maintenance costs, faster feature delivery, scalable team autonomy, and systems that age well.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/business-case-for-extreme-programming/https://thurley.dev/blog/business-case-for-extreme-programming/Why Extreme Programming matters to leadership: reduced rework, predictable delivery, lower key-person risk, and teams that get faster over time instead of slower.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/modern-xp-the-code-quality-loop/https://thurley.dev/blog/modern-xp-the-code-quality-loop/TDD, refactoring, and simple design form a triangle. Remove any side and the structure collapses. Most teams attempt one or two. Here's why you need all three.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/modern-xp-the-delivery-loop/https://thurley.dev/blog/modern-xp-the-delivery-loop/Your CI pipeline running against a two-week-old branch isn't continuous integration. These two practices reduce the distance between writing code and learning from it in production.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/modern-xp-the-feedback-loop/https://thurley.dev/blog/modern-xp-the-feedback-loop/The planning game isn't estimation theater. Customer collaboration isn't a stakeholder demo every two weeks. XP's feedback practices predate modern product discovery, and they got it right.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/modern-xp-the-knowledge-sharing-loop/https://thurley.dev/blog/modern-xp-the-knowledge-sharing-loop/Code review isn't pair programming. 'That's Steve's service' isn't collective ownership. These two practices eliminate knowledge silos and make every other XP practice work at team scale.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/modern-xp-your-team-isnt-doing-it/https://thurley.dev/blog/modern-xp-your-team-isnt-doing-it/Extreme Programming defined a system of reinforcing practices in the late 1990s. Most teams cherry-picked the easy parts and skipped the rest. Here's what got lost and why it matters.Thu, 05 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/business-case-for-spec-driven-ai-development/https://thurley.dev/blog/business-case-for-spec-driven-ai-development/Why spec-driven, AI-assisted development matters to leadership — reduced rework, faster onboarding, knowledge durability, and predictable delivery.Wed, 04 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/spec-driven-development-on-a-team/https://thurley.dev/blog/spec-driven-development-on-a-team/What happens when spec-driven, AI-assisted development moves from a solo workflow to a team? The benefits, the tensions, and what it would actually look like in practice.Wed, 04 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ai-assisted-spec-driven-development/https://thurley.dev/blog/ai-assisted-spec-driven-development/How a 1,900-line specification document, a 245-line rules file, and Claude Code turned a solo developer into a full-stack team.Mon, 02 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/building-dddseedwork/https://thurley.dev/blog/building-dddseedwork/How I extracted, improved, and published the DDD base classes I've been copying between projects for years into a proper, tested NuGet package.Mon, 02 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/aggregates-invariants-and-consistency/https://thurley.dev/blog/aggregates-invariants-and-consistency/How to design aggregates that protect business rules, enforce invariants at their boundaries, and keep your domain model honest.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/cqrs-as-a-supporting-architectural-pattern/https://thurley.dev/blog/cqrs-as-a-supporting-architectural-pattern/How separating commands from queries gives you different optimization strategies for writing and reading, and when CQRS is worth the added complexity.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/designing-and-integrating-bounded-contexts/https://thurley.dev/blog/designing-and-integrating-bounded-contexts/How to identify bounded context boundaries, choose integration patterns, and keep contexts autonomous without creating silos.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/domain-events-and-event-driven-workflows/https://thurley.dev/blog/domain-events-and-event-driven-workflows/How domain events capture what happened in your system, decouple aggregates, and drive workflows without creating tight coupling between bounded contexts.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/event-storming-in-practice/https://thurley.dev/blog/event-storming-in-practice/A deep dive into running effective event storming sessions, from facilitating workshops to translating discoveries into domain models.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/identity-modeling-and-explicit-domain-types/https://thurley.dev/blog/identity-modeling-and-explicit-domain-types/How strongly-typed IDs, smart enums, value objects, and guard clauses make invalid states unrepresentable in your domain model.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/repositories-and-persistence-boundaries/https://thurley.dev/blog/repositories-and-persistence-boundaries/How the repository pattern keeps persistence concerns out of your domain model, why domain and data models should be separate, and what a clean persistence boundary looks like.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ubiquitous-language-and-naming-strategies/https://thurley.dev/blog/ubiquitous-language-and-naming-strategies/How to establish a shared language between business and code, and the naming strategies that keep domain models honest as systems grow.Sun, 01 Mar 2026 00:00:00 GMThttps://thurley.dev/blog/ddd-practical-overview/https://thurley.dev/blog/ddd-practical-overview/A high-level overview of Domain-Driven Design: what it is, why it exists, and when it is an effective approach for building software systems. The first installment in a broader series.Sun, 15 Feb 2026 00:00:00 GMT