A growing bookshelf of technical books, freely readable on the web, with explanations, evidence and examples that develop as knowledge changes.
The books are the primary publishing units of Programmer.ie. Every finished book should lead to an applied solution: a durable page and implementation where the mechanism becomes something inspectable, testable or usable.
The aim is an intelligent bookshelf: books that grow as new research, tools and ideas emerge. The long-term goal is for AI to help discover relevant developments and propose updates, with changes reviewed before they become part of a book.
When Intelligence Enters the Channel
What form does communication take when intelligence becomes part of the medium through which meaning moves? A first-principles investigation of representation, attention, personal mediation and delegated action.
Building on the Coding Agent
A practical book about finding the right layer for agent behaviour, using Pi to see and build each one: from a direct model call, through an agent core and the coding-agent application, out to interfaces and authority boundaries — worked from the least powerful mechanism that solves the problem.
Engineering Intelligence Into a Reliable Process
Build from a callable model to explicit context, durable state, controlled actions, independent verification, and a deterministic runtime that decides what happens next.
Engineering What an AI Gets to Know
Context as a bounded working set built from a larger information world: selection, eligibility and representation, a deterministic Context Compiler, observable delivery to a runtime, and behavioural evaluation, with an honest record of where each kind of evidence stops.
Engineering Evidence for AI
How a system discovers, ranks, filters, and selects evidence from a larger information world, and how to establish whether that evidence improved the outcome.
Building, Optimizing, and Understanding Modern AI Inference Systems
How a transformer becomes a request, how a request becomes tokens, and how engineering choices determine latency, throughput, cost, and correctness.
Build browser-native AI from the capability boundary upward: local models, observability, WebMCP tools, agent security, and a user-owned browser policy engine.
Programming with Decisions
A build-and-investigate book about typed, uncertain decisions as a programming abstraction: reconstructing the Jev idea from first principles, testing it against classifiers, embeddings, NLI and language-model alternatives, and building a decision stack that keeps uncertainty, evidence and provider choice explicit.
Engineering AI Systems That Turn Past Experience Into Better Present Behaviour
Build AI memory from storage and retrieval through provenance, temporal state, unfinished work, context selection, behavioural evaluation, trust, the boundary with learning, and the promotion boundary from memory to durable knowledge — adding only the mechanisms that measurement earns.
Turn language-model behavior into an experimental variable, then learn when optimization is measurable, when improvement is trustworthy, and what DSPy contributes to the process.
Geometry, Retrieval, Alignment, and the Hidden Representation Layer of AI
Explore what it means for information to become geometry, when that geometry can be trusted, and how representation, similarity, retrieval, calibration, cross-space alignment, and compression combine into an embedding runtime that knows its own limits.
An Experimental Search for Life-Like Organization in Computation
An experimental search for life-like organization in computational systems — through emergence, causality, persistence, material turnover, hidden state and finite computation.
Explore why language models hallucinate, how hallucination can be measured and evaluated, where individual detection methods fail, and how evidence, verification, policy, abstention, and memory gates can be combined to build reliable systems around stochastic models.
Understand PyTorch from first principles — from tensor geometry and autograd to model structure, transforms, attention, debugging, performance, compilation, reproducibility, and a GPT-style model built from scratch.
Learn to read modern AI models by decomposing them into smaller mechanisms, then rebuilding quality scorers, value and policy heads, recurrent reasoning systems, optimizers, and preference rankers in PyTorch.
Build reliable AI agents by understanding the mechanisms underneath them: control loops, actions, validation, planning, state, tools, memory, search, and external verification.
From Local Rules to Emergence, Computation, Artificial Life and Learned Systems
Build cellular automata from the smallest local rules, then follow them through measurement, computation, continuous artificial life, learned dynamics and reproducible engineering. A first-principles investigation of what simple local systems can do — and how to tell what the evidence actually supports.
Go beyond basic agent loops into orchestration, evaluation, reliability, multi-step reasoning, memory, and production-grade agent systems.
From Python Exceptions to Models, Hallucinations, and Agents
Progress from deterministic debugging to diagnosing models, evidence, trajectories, and AI-generated work.
Think, create, research, write, and build with AI through open conversation, clear intent, structured reflection, iterative collaboration, and amplified creation.
From Agent Architecture to Agent Engineering
Explore how LLM agents grow from simple conversations into reflective, tool-using, memory-enabled and multi-agent systems—and how those systems can become collaborators, companions, interfaces, and extensions of human agency. Second edition: verified sources, frozen terminology, executed examples with negative controls, and evidence boxes that state exactly what each result supports.
The web chapters remain freely readable. The same underlying work can become diagnostics, capstones, demos and working systems, while book editions preserve the full explanation. The book is the understanding layer, not the final stop.
