A Programmer's Guide to the New Paradigm — how the concepts, patterns, and principles of classical software engineering translate into the age of LLM-powered agents.
Maps classical software engineering concepts to their agentic equivalents, giving developers a mental framework to cross the paradigm boundary without losing their footing.
Traces the moment natural language crossed from documentation into executable code, and what that shift demands from programmers who learned to think in types and functions.
Explores model, prompt, and context as an inseparable system — change any one element and the behavior of the whole changes with it.
Treats the context window as working memory: finite, precious, and the primary resource an agentic programmer must learn to allocate deliberately.
Diagnoses the slow degradation of context quality — how stale history, contradictory instructions, and accumulated noise silently erode agent reliability over time.
Replaces hard-coded conditionals with meaning-aware routing that dispatches tasks based on intent, turning ambiguous natural-language input into deterministic execution paths.
Decomposes a task into concurrent workstreams where each sub-agent applies independent judgment, then synthesizes the results into a coherent whole.
Dissects the plan–act–observe cycle that drives autonomous agents, and identifies the stopping conditions that separate reliable agents from runaway loops.
Refactors the monolithic god-prompt into injected, composable components — separating persona, tools, memory, and task specification into clean, testable interfaces.
Applies SRP, OCP, LSP, ISP, and DIP to agent system design, showing these fifty-year-old rules are more relevant, not less, when working at the semantic layer.
Translates Observer, Strategy, Chain-of-Responsibility, and other classic patterns into multi-agent workflow architectures — familiar structures in a new medium.
Adapts test-driven development to the probabilistic domain, writing evals before prompts to define what good output looks like before the first token is generated.
Uses Gherkin-style Given/When/Then scenarios as executable agent specifications, making behavior testable, auditable, and readable by non-engineers.
Reframes debugging for non-deterministic systems, tracing agent failures back to ambiguous instructions, missing context, and misaligned goals rather than code bugs.
Treats user-supplied data as an untrusted attack surface and builds structural barriers that prevent injected instructions from hijacking agent behavior.
Instruments agent systems with traces, spans, and structured logs so that reasoning chains become inspectable and failures become diagnosable before they reach production.
Examines whether the prompt–tool–loop system is Turing complete, and what theoretical guarantees — and hard limits — that confers on programs written in natural language.
Defines the emerging role of the programmer as orchestrator: someone who composes, evaluates, and governs a team of specialized AI agents toward a shared goal.