AI - Programmer.ie: Modern AI programming

What Is an Embedding?
What Does It Mean to Debug?
The Browser Stops Being Just a Client
When Models Make Things Up
Why Are We Still Hand-Writing Prompts?
You’ve Probably Already Felt It
What Is an Agent, Really?
What Are We Actually Doing?
Introduction to LLM Agents
Meaning Becomes Geometry
The First Divergence
What Does Built-In Actually Mean?
Hallucination Is Not One Thing
A Prompt Is Not Yet a Program
Learning to Talk to the Machine
The Action Boundary
The Tensor: What Is Actually Flowing Through the Loop?
Methodologies and Core Patterns
Learning an Embedding Space
Evidence Before Explanation
Build the Smallest Browser AI Observatory
Evidence, Truth, and Verifiability
Define the Contract
Speak Freely, Think Clearly
Candidate Generation and Selection
Autograd: What Did PyTorch Record, and Where Does the Gradient Stop?
The Architecture of Agent Behavior
Similarity Is a Decision
The Debugging Stack
From Prompt Demo to AI Debugger
How Do You Measure a Hallucination?
Separate What From How
Beyond Prompting
Critique, Revision, and Acceptance
The Network: What Is It Without nn.Module?
Designing Your First Agent (On Your Phone)
Dimensions Do Not Mean What You Think
Reading Python Exceptions
One Runtime, Several Interfaces
Hallucination Energy
Build Programs From Programs
Ghosted by the Machine
Planning and Execution
nn.Module: What Does PyTorch Think Belongs to Your Model?
The Thinking Agent
Neighborhoods and Hubs
Inspect State, Don't Guess
Summarization Is a Contract
How to Evaluate a Hallucination Detector
Your Model Is a Dependency
Build Something Real: From Conversation to Creation
Runtime State, Progress, and Termination
DataLoader: Where Is the Training Loop Actually Waiting?
Architecting Agent-Based Systems
How Many Dimensions Does Meaning Need?
Debug the Boundary
Writing, Rewriting and Proofreading Are Different Operations
Breaking the Detector
Transforms: What Does the Model Actually See?
Examples Are Experimental Data
Rework: Applying New Intelligence to Old Ideas
Capabilities and Routing
A New Way of Working With Technology
The Shape of an Embedding Space
Assertions, Invariants, and Contracts
Language Detection Is a Decision, Not an Answer
Containment Is Not Truth
You Cannot Optimize What You Cannot Measure
CNN Geometry: What Shape Reaches the Next Layer?
Applied AI: The Freestyle Cognition Framework
Memory and Selective Recall
Companion Agents
From Similarity to Search
Environment Bugs
A Session Is Not a Stateless Function
Beyond Hallucination: Consistency and Sensitivity
Feature Space: What Does a Linear Model Actually See?
When the Metric Becomes the Target
The Editing Process: From Draft to Contribution
Trajectory Search
Designing Your Digital Lens
The Nearest Neighbor Can Be Wrong
The Notebook Is Not the Program You See
When the Context Window Fills
The Safe but Useless Model
Attention: Which Position Is Comparing With Which?
Compile the Program
Amplified Creation
Evidence and Verification
Freestyle Cognition
Hard Negatives
Hidden Notebook State
Cold Starts, Warm Runs and Real Latency
Knowing When Not to Answer
Training: Which Link in the Learning Chain Is Broken?
Few-Shot Optimization
Writing a Book with AI: The Four-Pass System
Building the Complete Agent
The World You're Building
Retrieval Is a Policy
Reproducible Notebooks
The Browser Manages the Model
From Measurements to Policy
Performance: What Is the Machine Waiting For?
Optimize the Instructions
Research: From Paper to Pipeline with AI
How Do You Evaluate an Embedding?
Debug the Data Before the Model
A Resolved Promise Is Not a Correct Answer
Verification, Repair, and Rejection
Compilation: Which Assumption Stopped Holding?
Let the Program Reflect
Machine Coding: Building Software with AI
Calibration
Shapes, Types, Devices, and Tensors
Evaluate the Feature, Not the Demo
The Memory Contamination Problem
Regressions: Did the Model Change, or the Measurement?
Change One Thing
Awareness: Reflecting on Your Process with AI
Is Similarity One-Dimensional?
When Training Goes Wrong
When Local Is Not Available
Building Systems That Distrust Their Models
Assembly: A Language Model You Can Interrogate
Agents Are Programs Too
When It Doesn’t Work: Troubleshooting Freestyle Cognition
Change the Model, Change the Universe
Debugging Evaluation
Structured Output Is Still Model Output
Appendix: The Evidence Ledger
Appendix A: PyTorch Diagnostic Field Guide
Search, Memory and Long Context
Upgraded: The Beginning of Your Journey
Versioning the Space
Debugging What You Cannot See
From Buttons to Capabilities
Search the Reasoning Space
Appendix 01: Cheat Sheet
Can One Embedding Space Be Translated Into Another?
Is the Model Actually the Problem?
Expose the First WebMCP Tool
Don't Let the Optimizer Cheat
Appendix 02: Is Freestyle Cognition Legitimate?
Alignment
Inspect the Actual Model Input
Tool Choice Is a Behavioral Problem
From Experiment to Production
Appendix 03: Useful Prompts
The Embedding Bridge
Context Windows and Truncation
Untrusted Text Meets Executable Authority
Build a Self-Improving Engineering Program
Appendix 04: Prompting Techniques: A Reference Guide
Did the Bridge Preserve the Space?
Sampling Is Part of the Program
Beyond the Book: Production DSPy Systems (Appendix)
Put a Human at the Authority Boundary
Appendix 05: References: Foundational Research
Retrieval Is Not Geometry
Internal Signals
The Browser as a Personal Policy Engine
Appendix 06: Example CRITIC Session: A Live Demo
What Should a Translation Preserve?
Representation and Behavioral Diffs
Build an AI-Origin Content Filter
Appendix 07: Choosing the Right AI for the Job
Can a Smaller Representation Preserve a Larger One?
AI as Builder, Designer, Researcher, and Reviewer
Build Browser AI Lens: The User-Owned Intelligent Browser
Appendix 08: Amplified Creation Moments: A Personal Log
Appendix A — Browser AI Field Guide: Setup, APIs, States, Diagnostics and Configuration
From Deltas to Operators
Debugging Intent
Appendix 09: Writing Fiction with AI: Tools and Workflows
Building an Embedding Runtime
Debugging Context for Coding Agents
Appendix 10: Prompting Techniques for Fiction Writing
Debugging AI-Generated Designs
Appendix 11: Amplified Log Template
Debugging AI Research
Appendix 12: Machine Coding: Pre-Prompt Checklist
Debugging Coding Agents
Appendix 13: AI Hallucination Check Prompt
Treat Prompts as Programs
Appendix 14: Prompt Toolkit for Machine Coding
Minimize the Prompt
Appendix 15: Paper Coverage Report: AI as a Co-Scientist
Retrieval Is a Pipeline
Appendix 16: Implementing AI as a Co-Scientist: A Research Case Study
Retriever Failure or Generator Failure?
Debugging Hallucinations
The Model's Explanation Is Not a Trace
An Agent Is a Trajectory
Trace the Agent
Agent Failure Taxonomy
Loops, Thrashing, and Retry Storms
Time Travel, Replay, and Forking
Causal Replay
Trajectory Diff
Multi-Agent Systems
Can One AI Debug Another?
The AI Crash Dump
Diagnostic AI Invariants
From Symptom to Hypotheses
Discriminating Experiments
How Do You Know the Diagnosis Is Right?
AIDebugBench
Debug the Debugger
AI Observability
From Production Failure to Regression
Runtime Invariants and Guardrails
Debugging Cost and Latency
Debugging in Production
The Ten-Minute Debug
The One-Hour Investigation
The Full AI Incident Investigation
The Debugging AI Toolkit
References and Supporting Papers
From Vectors to Symbols — The Binding Problem Inside Neural Networks
Reasoning Is More Than Architecture — Where Extra Computation Lives
Preference Rankers — Learning Which Answer Is Better
Advanced Agents From First Principles 24: How Do You Release Agent Behavior Safely? Add Behavioral Contracts, Compatibility Checks and Promotion Gates
Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation
Advanced Agents From First Principles 08: Is Your Agent Spending the Same Compute on Every Task? Build Adaptive Agents That Escalate Only When Needed
Advanced Agents From First Principles 26: Why Did the Agent Fail? Build an Incident Forensics Pipeline
Advanced Agents From First Principles 27: How Reliable Does an Agent Need to Be? Define SLOs and Error Budgets
Advanced Agents From First Principles 28: Where Should You Spend the Next Engineering Hour? Prioritize Reliability by Risk and Expected Return
Advanced Agents From First Principles 29: When Should an Agent Stop and Ask a Human? Design Authority Boundaries and Escalation
Advanced Agents From First Principles 30: Is This Task Outside Your Agent’s Competence? Build Competence Envelopes and OOD Detection
Advanced Agents From First Principles 31: How Can an Agent Learn New Capabilities Without Expanding Its Own Authority? Use Sandboxed Capability Acquisition
Advanced Agents From First Principles 32: Which Capabilities Are Actually Worth Building? Design a Capability Portfolio
Advanced Agents From First Principles 33: Which Shared Components Actually Unlock More Capability? Build a Capability Dependency Graph
Advanced Agents From First Principles 34: Where Should This Task Actually Run? Build Capability-Aware Placement Across Models, Providers and Resource Pools
Advanced Agents From First Principles 35: How Do You Move a Running Agent Between Workers Without Losing Meaning? Build Portable Execution State and Safe Handoff
Advanced Agents From First Principles 36: Is Your Agent Acting on Stale State? Build Temporal Consistency, Freshness Budgets and Conflict Detection
Advanced Agents From First Principles 37: Is Your Agent Still Solving the Right Task? Build Intent Versioning, Supersession and Cancellation
Advanced Agents From First Principles 38: A Plan Is Not a Commitment — Model Goals, Commitments and Executable Work
Advanced Agents From First Principles 39: How Do You Make an Agent Survive for Days? Build Durable Long-Running Workflows
Advanced Agents From First Principles 40: Your Agent Changed the World. What Happens When Step Two Fails? Build Transactions, Compensation and Reconciliation
Advanced Agents From First Principles 41: What Should Your Agent Trust? Build Explicit Security and Trust Boundaries
Advanced Agents From First Principles 42: How Do Multiple Agents Coordinate Without Becoming a Distributed Argument?
Advanced Agents From First Principles 43: Who Controls the Agent? Build an Explicit Agent Control Plane
You Probably Don't Need All of This: Build the Minimum Production Agent Architecture
Advanced Agents From First Principles 06: Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture
Advanced Agents From First Principles 05: Is One Model Doing Everything? Build a Mixture of Experts at the Agent Level
Advanced Agents From First Principles 04: Does Your Agent Prune Good Ideas Too Early? Use Monte Carlo Tree Search for Long-Horizon Reasoning
Advanced Agents From First Principles 03: Does Your Agent Commit to a Bad Reasoning Path Too Early? Build a Tree of Thoughts
Advanced Agents From First Principles 02: Why Does My Reasoning Agent Give a Different Answer Every Time? Use Self-Consistency Without Confusing Consensus With Truth
Advanced Agents From First Principles 01: Does Your AI Agent Fail on Complex Reasoning Tasks? Treat Chain of Thought as Computation, Not Proof
Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?
Which Model Should You Use? MR.Q, EBT, SICQL, HRM, Tiny and PACS Compared
PACS — Building an Optimizer From Gradient Statistics
Inside Tiny — Residual Blocks, Attention and Sparse Autoencoders
Tiny — Recursive Reasoning With a Small Neural Network
HRM — Hierarchical Reasoning With Fast and Slow Recurrent State
SICQL — Building a Model From Q, V and Policy Networks
EBT — From One Score to Q, V, Policy and Advantage
MR.Q — Building a Neural Quality Model From Two Embeddings
The Model Inside the Model
ZeroModel: Evidence Before Ambition
Advanced Agents From First Principles 07: Do Your Agents Agree Too Easily? Use Adversarial Review and Multi-Agent Debate Without Confusing Debate With Truth
RELATE: Searching Embeddings by Relation, Not Just Similarity
The Singularity Is Here
Signs, Not Directions: Compiling AI Policy into Visual Artifacts
What Does a Preference Know About the Future?
The Preference Was Only the Beginning
The State Optimized the Dashboard and Lost the Citizen
The Moment: Intelligence beyond context
The Asset‑Price State: How the U.S. Fiscal Machine Now Depends on Rising Markets
The AI Application Gap: Why Capability Is Not Deployment
Warranted Search: When AI Must Prove Before It Looks
Thinking in Primitives: Why AI Reasoning Should Learn to Point
AI and the End of Easy Growth
Delta Memory: Cargo-Culting Human Memory with Search
Codex Manager: Building a Prompt-State Runtime for Hackathon-Grade Code Optimization
Cognitive Graphs: A General Architecture for Replayable Reasoning
AI as an Amplifier, Not a Utility
The Answering Machine Effect
Beyond Hallucination Energy: A Three-Dimensional Framework for Reliable AI Outputs
Living Against Parkinson’s: A Practical Guide to Fighting Back
The Silent Reset: Currency Devaluation and the Extension of the Debt Cycle
The Eye That Sees
Canada: When Interest Meets Reliable Revenue
From Fuel Protests to Fiscal Risk: What’s Really Happening in Ireland
Real Problems. AI Solutions.
A Memory Gate for AI: Policy-Bounded Acceptance in the Executable Cognitive Kernel
Intelligence Through Execution: The Executable Cognitive Kernel
The “Negative Contrast Trap”: Why AI Writing Overuses “Not X, But Y”
Applied Policy: How to incorporate Policy and Hallucination in self-improving system
Hallucination Energy: A Geometric Foundation for Policy-Bounded AI
From Evidence to Verifiability: Rebuilding Trust in AI Outputs 🔏
Review: What We’ve Learned So Far
✨ TINY CRITICS: Lightweight Reasoning Checks for Large AI Systems
The Nexus Blossom: How AI Thoughts Turn into Habits
Search–Solve–Prove: building a place for thoughts to develop
The Space Between Models Has Holes: Mapping the AI Gap
A Complete Visual Reasoning Stack: From Conversations to Epistemic Fields
🔦 Phōs: Visualizing How AI Learns and How to Build It Yourself
Episteme: Distilling Knowledge into AI
From Photo Albums to Movies: Teaching AI to See Its Own Progress
Case Based Reasoning: Teaching AI to Learn From itself
SIS: The Visual Dashboard That Makes Stephanie's AI Understandable
ZeroModel: Visual AI you can scrutinize
Everything is a Trace: Stephanie Enters Full Reflective Mode
Layers of thought: smarter reasoning with the Hierarchical Reasoning Model
Stephanie's Secret: The Dawn of Reflective AI
The Shape of Thought: Exploring Embedding Strategies with Ollama, HF, and H-Net
Getting Smarter at Getting Smarter: A Practical Guide to Self-Tuning AI
Epistemic Engines: Building Reflective Minds with Belief Cartridges and In-Context Learning
Self-Improving AI: A System That Learns, Validates, and Retrains Itself
Teaching Tiny Models to Think Big: Distilling Intelligence Across Devices
Agent Architectures: Chapter 2
Compiling Thought: Building a Prompt Compiler for Self-Improving AI
Agent Architectures: Chapter 1
Thoughts of Algorithms
Document Intelligence: Turning Documents into Structured Knowledge
Learning to Learn: A LATS-Based Framework for Self-Aware AI Pipelines
Dimensions of Thought: A Smarter Way to Evaluate AI
Programming Intelligence: Using Symbolic Rules to Steer and Evolve AI
Adaptive Reasoning with ARM: Teaching AI the Right Way to Think
A Novel Approach to Autonomous Research: Implementing NOVELSEEK with Modular AI Agents
General Reasoner: The smarter Local Agent
Building a Self-Improving Chain-of-Thought Agent: Local LLMs Meet the CoT Encyclopedia
Self-Improving Agents: Applying the Sharpening Framework to Local LLMs
Building an AI Co-Scientist
Building Clipper: An AI Image Generator You Control
Uncovering Reasoning in LLMs with Sparse Autoencoders
Optimizing Prompt Generation with MARS and DSPy
Fin-R1: a Financial Reasoning LLM with Reinforcement Learning and CoT
MR.Q: Model-Based Representations for Model-Free Trading
Using Hugging Face Datasets
Detecting AI-Generated Text: Challenges and Solutions
Shakespeare and the Bible: An AI Investigation
PostgreSQL for AI: Storing and Searching Embeddings with pgvector
Build Smarter AI: Leveraging the Model Context Protocol for Dynamic Context
Getting Started with Neo4j: Build Your First Knowledge Graph
Beyond Text Generation: Coding Ollama Function Calls and Tools
Building AI-Powered Applications with Haystack and Ollama
LiteLLM: A Lightweight Wrapper for Multi-Provider LLMs
The Power of Logits: Unlocking Smarter, Safer LLM Responses
Automating Paper Retrieval and Processing with PaperSearch
RAFT: Reward rAnked FineTuning - A New Approach to Generative Model Alignment
Faiss: A Fast, Efficient Similarity Search Library
K-Means Clustering
Self-Learning LLMs for Stock Forecasting: A Python Implementation with Direct Preference Optimization
Using Quantization to speed up and slim down your LLM
Mastering LLM Fine-Tuning: A Practical Guide with LLaMA-Factory and LoRA
DeepResearch Part 3: Getting the best web data for your research
DeepResearch Part 2: Building a RAG Tool for arXiv PDFs
DeepResearch Part 1: Building an arXiv Search Tool with SmolAgents
FFmpeg: A Practical Guide to Essential Command-Line Options
Writing Neural Networks with PyTorch
Mastering Prompt Engineering: A Practical Guide
Harnessing the Power of Stable Diffusion WebUI
Activation Functions
SVM Support Vector Machine an introduction
More Machine Learning Questions and Answers with Python examples
Rag: Retrieval-Augmented Generation
CAG: Cache-Augmented Generation
Agents: A tutorial on building agents in python
Courses: Free course on Agentic AI
Ollama: The local LLM solution