{"version":1,"site":"https://agenticthinking.ai","buildDate":"2026-10-25","about":"One learning per visible post.","count":82,"learnings":[{"slug":"about-steven-poitras","kind":"post","title":"About Me: Consulting to Startups","url":"/blog/about-steven-poitras/","file":"src/posts/story/2025-10-20-about-steven-poitras.md","date":"2025-10-20","asOf":"2025-10-20","region":"standalone-story","series":null,"tags":["personal","career","nutanix","ema","background","story"],"tokens":1800,"lead":"I'm a technology industry veteran with a pattern of joining early-stage companies and helping them scale to massive success. Here's my story and what drives me.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Early Beginnings: A Hacker at Heart"},{"level":3,"text":"Phreaking and Hacking"},{"level":3,"text":"My First \"Hack\" - 3rd Grade"},{"level":2,"text":"Career Timeline"},{"level":3,"text":"Accenture - Consulting & R&D Foundation"},{"level":3,"text":"Nutanix (2011-2020)"},{"level":3,"text":"DevRev (2020-2025)"},{"level":3,"text":"Ema (2025–2026)"},{"level":3,"text":"Nutanix, again (October 2026–Present)"},{"level":2,"text":"Professional Strengths"},{"level":3,"text":"1. Early-Stage Pattern Recognition"},{"level":3,"text":"2. Technical Evangelism"},{"level":3,"text":"3. Go-to-Market Expertise"},{"level":3,"text":"4. Founder Intuition"},{"level":2,"text":"The \"Dheeraj Moment\""},{"level":2,"text":"Fun Facts"},{"level":2,"text":"What I Believe"},{"level":2,"text":"Connect"}],"terms":["nutanix","founder","consulting","technology","career","join","early","dheeraj"],"passages":5,"embedding":true},{"slug":"ema-founding-team","kind":"post","title":"Ema's Founders: Google to Startup","url":"/blog/ema-founding-team/","file":"src/posts/story/2025-11-10-ema-founding-team.md","date":"2025-11-10","asOf":"2025-11-10","region":"standalone-story","series":null,"tags":["ema","founders","startup","agentic-ai","leadership","story"],"tokens":1400,"lead":"Ema was founded by a powerhouse duo with exceptional credentials from some of the world's most successful technology companies. Their combined experience spans Google, Coinbase, and Meta, with a track record of building products used by billions of people.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Surojit Chatterjee — CEO & Co-founder"},{"level":3,"text":"Career Highlights"},{"level":2,"text":"Souvik Sen — CTO & Co-founder"},{"level":3,"text":"Career Highlights"},{"level":2,"text":"Why This Founding Team Matters"},{"level":3,"text":"Combined Credentials"},{"level":3,"text":"Complementary Skills"},{"level":3,"text":"The Ema Thesis"},{"level":2,"text":"My Perspective"},{"level":2,"text":"Company Milestones"},{"level":3,"text":"Funding"},{"level":3,"text":"Recognition"},{"level":3,"text":"Strategic Partnerships"},{"level":2,"text":"The Track Record Speaks"}],"terms":["founder","product","google","souvik","surojit","coinbase","career","ema"],"passages":4,"embedding":true},{"slug":"ema-platform-overview","kind":"post","title":"Ema: The Universal AI Employee Platform","url":"/blog/ema-platform-overview/","file":"src/posts/story/2025-11-20-ema-platform-overview.md","date":"2025-11-20","asOf":"2025-11-20","region":"standalone-story","series":null,"tags":["ema","agentic-ai","enterprise","ai-platform","automation","cursor","story"],"tokens":1400,"lead":"Ema is the Universal AI Employee platform, transforming enterprise operations through AI agents that actually work alongside human teams. Unlike chatbots or simple automation tools, Ema creates AI employees that can own and complete entire workflows autonomously.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Core Technology"},{"level":3,"text":"🧠 EmaFusion™"},{"level":3,"text":"🔧 Generative Workflow Engine™ (GWE)"},{"level":3,"text":"🔌 Enterprise Integration"},{"level":3,"text":"🔒 Enterprise-Grade Security"},{"level":2,"text":"AI Employee Categories"},{"level":3,"text":"👥 Employee Experience"},{"level":3,"text":"🤝 Customer Experience"},{"level":3,"text":"💼 Sales & Marketing"},{"level":3,"text":"📊 Operations"},{"level":3,"text":"💰 Finance"},{"level":2,"text":"Deployment & Implementation"},{"level":3,"text":"Timeline"},{"level":3,"text":"Implementation approach"},{"level":2,"text":"What Makes Ema Different"},{"level":2,"text":"Key Statistics"},{"level":2,"text":"Strategic Partnerships"}],"terms":["enterprise","partnerships","employee","ema","customer","strategic","sales","universal"],"passages":3,"embedding":true},{"slug":"ema-user-guide","kind":"post","title":"Ema Platform: Agentic AI Guide","url":"/blog/ema-user-guide/","file":"src/posts/ai-employees/2025-12-01-ema-user-guide.md","date":"2025-12-01","asOf":"2025-12-01","region":"standalone-ai-employees","series":null,"tags":["ema","agentic-ai","tutorial","guide","enterprise","cursor","ai-employees"],"tokens":10600,"lead":"A comprehensive guide to understanding Ema's Agentic AI platform—from core concepts and terminology to practical implementation patterns. Whether you're technical or business-focused, this guide will help you navigate the world of AI Employees.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Quick Reference"},{"level":3,"text":"What is Ema?"},{"level":3,"text":"Core Technology Stack"},{"level":3,"text":"Key Concepts at a Glance"},{"level":3,"text":"Quick Start Flow"},{"level":2,"text":"Glossary"},{"level":3,"text":"Action"},{"level":3,"text":"Agent"},{"level":3,"text":"Agent Mesh"},{"level":3,"text":"AI Employee"},{"level":3,"text":"Agentic AI"},{"level":3,"text":"Connector"},{"level":3,"text":"Conversation"},{"level":3,"text":"EmaFusion™"},{"level":3,"text":"Generative Workflow Engine™ (GWE)"},{"level":3,"text":"Human-in-the-Loop (HITL)"},{"level":3,"text":"Knowledge Base"},{"level":3,"text":"Query"},{"level":3,"text":"Task"},{"level":3,"text":"Trigger"},{"level":3,"text":"Tool"},{"level":3,"text":"Workflow"},{"level":2,"text":"Understanding the Architecture"},{"level":2,"text":"Core Concepts Deep Dive"},{"level":3,"text":"AI Employees"},{"level":4,"text":"How AI Employees Execute"},{"level":4,"text":"Configuration Locations"},{"level":4,"text":"Debugging AI Employees"},{"level":3,"text":"Workflows & Agents"},{"level":4,"text":"Core Agent Types"},{"level":4,"text":"Conditional Execution"},{"level":4,"text":"Workflow Output vs. Intermediate Output"},{"level":3,"text":"Actions & Tools"},{"level":4,"text":"Action Anatomy"},{"level":4,"text":"Tool Invocation Flow"},{"level":4,"text":"Connector Categories"},{"level":3,"text":"Human-in-the-Loop (HITL)"},{"level":4,"text":"When to Use HITL"},{"level":4,"text":"Configuration Options"},{"level":2,"text":"Common Confusions Clarified"},{"level":3,"text":"AI Employee vs Agent vs Agent Mesh"},{"level":3,"text":"Action vs Tool vs Step"},{"level":3,"text":"Query vs Conversation"},{"level":4,"text":"Conversation Example"},{"level":4,"text":"Query Example"},{"level":2,"text":"Decision Tables"},{"level":3,"text":"Actions vs Conversational Orchestration"},{"level":3,"text":"When to Use What"},{"level":2,"text":"End-to-End Examples"},{"level":3,"text":"Example 1: Simple HR Policy Q&A Bot"},{"level":4,"text":"1. Create AI Employee"},{"level":4,"text":"2. Configure Workflow"},{"level":4,"text":"3. Add Knowledge"},{"level":4,"text":"4. Configure Response Agent"},{"level":4,"text":"5. Test & Deploy"},{"level":3,"text":"Example 2: Enterprise IT Support with Ticket Creation"},{"level":4,"text":"1. Create AI Employee"},{"level":4,"text":"2. Configure Workflow"},{"level":4,"text":"3. Configure Intent Categories"},{"level":4,"text":"4. Configure ServiceNow Integration"},{"level":4,"text":"5. Test Scenarios"},{"level":3,"text":"Example 3: Voice Password Reset"},{"level":4,"text":"1. Create AI Employee"},{"level":4,"text":"2. Configure Workflow"},{"level":4,"text":"3. Configure Voice Settings"},{"level":2,"text":"Troubleshooting & Gotchas"},{"level":3,"text":"Common Mistakes"},{"level":3,"text":"Debugging Checklist"},{"level":3,"text":"Known Limitations"},{"level":3,"text":"Error Handling Patterns"},{"level":2,"text":"Version & Documentation References"},{"level":3,"text":"Documentation URLs"},{"level":3,"text":"API Environments"},{"level":3,"text":"Version Information"},{"level":2,"text":"Appendix: Template IDs Reference"}],"terms":["employee","configure","hitl","chat","ticket","connector","conversation","email"],"passages":21,"embedding":true},{"slug":"why-i-joined-ema","kind":"post","title":"Why I Joined Ema: Betting on Agentic AI","url":"/blog/why-i-joined-ema/","file":"src/posts/story/2025-11-01-why-i-joined-ema.md","date":"2025-12-08","asOf":"2025-12-08","region":"standalone-story","series":null,"tags":["ema","career","agentic-ai","startup","personal","story"],"tokens":2300,"lead":"Every career-defining bet I've made started the same way: I saw an architectural shift before the market priced it in, found the team building at the center of it, and jumped.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Platform Shift"},{"level":2,"text":"The Founders"},{"level":2,"text":"What Early-Stage Actually Means"},{"level":2,"text":"The Technology, Assessed Honestly"},{"level":2,"text":"📞 Try It Yourself: Talk to an AI Employee"},{"level":3,"text":"What to Try"},{"level":2,"text":"The Bottom Line"}],"terms":["market","technology","founder","nutanix","bet","enterprise","dheeraj","ema"],"passages":6,"embedding":true},{"slug":"what-is-agentic-ai","kind":"post","title":"Agentic AI: Beyond the Chatbot","url":"/blog/what-is-agentic-ai/","file":"src/posts/fundamentals/2025-12-15-what-is-agentic-ai.md","date":"2025-12-15","asOf":"2025-12-15","region":"standalone-fundamentals","series":null,"tags":["agentic-ai","ai","enterprise","automation","ema","cursor","fundamentals"],"tokens":1900,"lead":"Agentic AI refers to artificial intelligence systems that can autonomously plan, reason, and execute multi-step tasks to achieve goals—much like a human employee. Unlike traditional AI that responds to individual prompts, agentic AI can own entire workflows from start to finish.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Evolution of AI"},{"level":3,"text":"Generation 1: Rule-Based Systems (1990s-2000s)"},{"level":3,"text":"Generation 2: Chatbots (2010s)"},{"level":3,"text":"Generation 3: Copilots (Early 2020s)"},{"level":3,"text":"Generation 4: Agentic AI (Now)"},{"level":2,"text":"What Makes AI \"Agentic\"?"},{"level":3,"text":"🎯 Goal-Oriented"},{"level":3,"text":"🔄 Autonomous"},{"level":3,"text":"🧠 Reasoning"},{"level":3,"text":"🛠️ Tool Use"},{"level":3,"text":"👥 Collaborative"},{"level":3,"text":"✅ Accountable"},{"level":2,"text":"Agentic AI vs. Other AI Types"},{"level":2,"text":"How Ema Implements Agentic AI"},{"level":3,"text":"The AI Employee Model"},{"level":3,"text":"Key Technologies"},{"level":3,"text":"Practical Capabilities"},{"level":2,"text":"Real-World Applications"},{"level":3,"text":"Employee Experience"},{"level":3,"text":"Customer Support"},{"level":3,"text":"Document Processing"},{"level":3,"text":"Sales Operations"},{"level":2,"text":"The Business Case for Agentic AI"},{"level":3,"text":"Efficiency Gains"},{"level":3,"text":"Scalability"},{"level":3,"text":"Cost Optimization"},{"level":3,"text":"Quality Improvements"},{"level":2,"text":"Common Questions"},{"level":2,"text":"The Future of Work"}],"terms":["agentic","employee","chatbots","copilots","ema","collaborative","customer","efficiency"],"passages":3,"embedding":true},{"slug":"ai-employee-governance","kind":"post","title":"The New Hire Who Never Sleeps","url":"/blog/ai-employee-governance/","file":"src/posts/ai-employees/2026-01-05-ai-employee-governance.md","date":"2026-01-05","asOf":"2026-01-05","region":"standalone-ai-employees","series":null,"tags":["agentic-ai","governance","enterprise","ai-employees","ema","cursor"],"tokens":3000,"lead":"It's time to treat your AI agents like the employees they already are. Somewhere in your organization right now, an entity is making decisions on your behalf. It's reading customer messages. Prioritizing tickets. Drafting responses. Approving requests. Moving data between systems. Scheduling resources. Nudging deals forward.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Moment the Tool Became a Colleague"},{"level":2,"text":"What Happens When Nobody's Managing the New Hire"},{"level":2,"text":"The Org Chart Doesn't End at Carbon-Based Life Forms"},{"level":2,"text":"The Uncomfortable Parallels"},{"level":2,"text":"\"But It's Just Software\""},{"level":2,"text":"The Accountability Gap Is a Leadership Problem"},{"level":2,"text":"The Permission Creep Nobody's Watching"},{"level":2,"text":"What \"Employment\" Looks Like for AI"},{"level":2,"text":"A Framework, Not a Fantasy"},{"level":2,"text":"The Real Question"},{"level":2,"text":"What You Should Do Monday Morning"}],"terms":["actor","accountability","employee","hire","colleagues","supposed","access","leadership"],"passages":10,"embedding":true},{"slug":"mcp-knowledge-first-builder","kind":"post","title":"MCP in Practice: Knowledge-First Builder","url":"/blog/mcp-knowledge-first-builder/","file":"src/posts/ai-development/2026-01-06-mcp-knowledge-first-builder.md","date":"2026-01-06","asOf":"2026-01-06","region":"mcp-practice","series":{"id":"mcp-practice","title":"MCP in Practice","order":3},"tags":["mcp","sdk","agentic-ai","ema","architecture","developer","cursor","series","ai-development"],"tokens":3800,"lead":"In Part 1, I built an MCP server that could sync AI Employees between environments. It worked. But there was a gap: the AI assistant could move personas, but it couldn't build them. This is the story of closing that gap by embedding domain expertise directly into MCP.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Plateau After Platform"},{"level":2,"text":"What the AI Didn't Know"},{"level":2,"text":"Why Not Just RAG?"},{"level":2,"text":"Designing the Knowledge Module"},{"level":2,"text":"The 16 New Tools"},{"level":3,"text":"Discovery Tools"},{"level":3,"text":"Template Tools"},{"level":3,"text":"Validation Tools"},{"level":3,"text":"Guidance Tools"},{"level":2,"text":"The Transformation"},{"level":2,"text":"Cursor Rules: MCP in the IDE"},{"level":2,"text":"Validation as Encoded Expertise"},{"level":2,"text":"Building the Builder with the Builder"},{"level":2,"text":"What I Learned"},{"level":3,"text":"1. Knowledge Architecture Matters More Than Volume"},{"level":3,"text":"2. Validation Is the Highest-Leverage Knowledge"},{"level":3,"text":"3. MCP Is a Teaching Interface"},{"level":3,"text":"4. IDE Integration Multiplies Value"},{"level":2,"text":"The Current State"},{"level":2,"text":"If You're Building This"}],"terms":["builder","ide","rag","teaching","multiplies","plateau","encode","modules"],"passages":8,"embedding":true},{"slug":"mcp-server-unified-sdk","kind":"post","title":"MCP in Practice: From Scripts to Platform","url":"/blog/mcp-server-unified-sdk/","file":"src/posts/ai-development/2026-01-06-mcp-server-unified-sdk.md","date":"2026-01-06","asOf":"2026-01-06","region":"mcp-practice","series":{"id":"mcp-practice","title":"MCP in Practice","order":2},"tags":["mcp","sdk","agentic-ai","ema","architecture","developer","cursor","series","ai-development"],"tokens":3400,"lead":"It started with a simple request: \"Can you sync my AI Employee from demo to dev?\" What followed was a journey from one-off scripts to a unified SDK and MCP server—and lessons about when context becomes the bottleneck.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Original Problem: Starting with a Point Use Case"},{"level":2,"text":"Discovering the Need for MCP"},{"level":2,"text":"MCP in Brief"},{"level":2,"text":"From Point Solution to Platform"},{"level":2,"text":"Building the Unified SDK"},{"level":3,"text":"EmaClient"},{"level":3,"text":"Config Layer"},{"level":3,"text":"SyncSDK"},{"level":2,"text":"Building the MCP Server on Top of the SDK"},{"level":3,"text":"Tool Definitions"},{"level":3,"text":"Tool Handlers"},{"level":3,"text":"Environment Abstraction"},{"level":3,"text":"Request/Response Flow"},{"level":3,"text":"Fingerprinting for Sync"},{"level":2,"text":"Why MCP Was Right for This"},{"level":2,"text":"What Changed After MCP"},{"level":2,"text":"Lessons Learned"},{"level":2,"text":"MCP as a Thinking Tool"},{"level":2,"text":"If You're Building This Today: A Quick Checklist"},{"level":2,"text":"What's Next: From Sync to Builder"}],"terms":["sync","sdk","environment","fingerprint","env","config","script","yaml"],"passages":12,"embedding":true},{"slug":"mcp-mental-model","kind":"post","title":"The MCP Mental Model","url":"/blog/mcp-mental-model/","file":"src/posts/ai-development/2026-01-08-mcp-mental-model.md","date":"2026-01-08","asOf":"2026-01-08","region":"mcp-practice","series":{"id":"mcp-practice","title":"MCP in Practice","order":1},"tags":["mcp","agentic-ai","architecture","developer","sdk","series","ai-development"],"tokens":2400,"lead":null,"thesis":"MCP (Model Context Protocol) is an interface layer that makes system capabilities legible to AI assistants. It doesn't make models smarter—it makes your system's boundaries, definitions, and actions explicit. Understanding MCP's primitives and when to use each is the difference between a coherent integration and a fragile one.","thesisShort":"MCP (Model Context Protocol) is an interface layer that makes system capabilities legible to AI assistants. It doesn't make models smarter—it makes your system's boundaries, definitions, and actions explicit.","headings":[{"level":2,"text":"MCP as an Enabling Layer"},{"level":2,"text":"What MCP Is—And Is Not"},{"level":2,"text":"MCP Core Primitives"},{"level":3,"text":"Tools"},{"level":3,"text":"Resources"},{"level":3,"text":"Prompts"},{"level":2,"text":"How MCP Is Used in Practice"},{"level":3,"text":"During Agent Execution"},{"level":3,"text":"Querying for Definitions"},{"level":3,"text":"Grounding Actions Before Execution"},{"level":2,"text":"When MCP Is the Right Abstraction"},{"level":3,"text":"Signals You Should Use MCP"},{"level":3,"text":"Common Anti-Patterns"},{"level":2,"text":"MCP + Reasoning: The Boundary"},{"level":2,"text":"Relationship to the Series"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"What to Do Next"}],"terms":["definition","resources","execution","ground","primitives","capabilities","realistic","fact"],"passages":8,"embedding":true},{"slug":"cursor-rules-vs-mcp","kind":"post","title":"Rules, Agents, Commands, MCP... WTF?","url":"/blog/cursor-rules-vs-mcp/","file":"src/posts/ai-development/2026-01-11-cursor-rules-vs-mcp.md","date":"2026-01-11","asOf":"2026-01-11","region":"standalone-ai-development","series":null,"tags":["cursor","mcp","agentic-ai","developer","best-practices","ai-development"],"tokens":2800,"lead":"A guide to what goes where and why — so you can stop wondering and start building. Rules. Commands. Agents. Skills. MCP. Prompts. If you've spent any time trying to customize your AI coding assistant, you've probably wondered: what's the difference? Where does this go? Why isn't this working? You're not alone. The ecosystem has grown faster than the documentation. Everyone's got an opinion, half the features are in \"Nightly,\" and the mental model isn't obvious.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Mental Model (Finally)"},{"level":2,"text":"\"Where Does This Go?\" (Decision Guide)"},{"level":2,"text":"Rules + MCP: \"What\" vs \"How\""},{"level":3,"text":"The Anti-Pattern: Data in Rules"},{"level":3,"text":"The Pattern: Rules Reference MCP"},{"level":3,"text":"What Goes Where"},{"level":2,"text":"Commands + MCP: Stop Hardcoding Steps"},{"level":3,"text":"Static Command (Limited)"},{"level":3,"text":"Dynamic Command (MCP-Powered)"},{"level":3,"text":"Command + MCP Patterns"},{"level":2,"text":"Agents + MCP: Give Your Experts Context"},{"level":3,"text":"Agent Without MCP (Limited Context)"},{"level":3,"text":"Agent With MCP (Full Context)"},{"level":3,"text":"Agent + MCP Patterns"},{"level":2,"text":"Skills + MCP: Take Your Patterns Everywhere"},{"level":3,"text":"Skill Definition"},{"level":3,"text":"Skill + MCP Patterns"},{"level":2,"text":"When It All Clicks: A Real Workflow"},{"level":2,"text":"\"Why Isn't This Working?\" (Debugging)"},{"level":3,"text":"Check Rule Application"},{"level":3,"text":"Check MCP Availability"},{"level":3,"text":"Check Agent Selection"},{"level":3,"text":"Check Command Execution"},{"level":3,"text":"Force Loading"},{"level":2,"text":"The Rules (Ironically)"},{"level":3,"text":"1. One Job Per Thing"},{"level":3,"text":"2. MCP as Single Source of Truth"},{"level":3,"text":"3. Composability"},{"level":3,"text":"4. Graceful Degradation"},{"level":2,"text":"Sanity Checklist"},{"level":3,"text":"Rules: Are You Doing It Wrong?"},{"level":3,"text":"Commands: Are They Dynamic?"},{"level":3,"text":"Agents: Do They Have Context?"},{"level":3,"text":"MCP: Is It Actually Useful?"},{"level":2,"text":"Now What?"}],"terms":["commands","skill","dynamic","fetch","composability","degradation","wtf","static"],"passages":12,"embedding":true},{"slug":"inline-llm-calls","kind":"post","title":"Inline LLM Calls: Skip the Redeploy","url":"/blog/inline-llm-calls/","file":"src/posts/ai-development/2026-01-11-inline-llm-calls.md","date":"2026-01-11","asOf":"2026-01-11","region":"standalone-ai-development","series":null,"tags":["llm","agentic-ai","architecture","developer","best-practices","ai-development"],"tokens":4100,"lead":"Hardcoded logic is brittle. Every if (type === \"report\" || type === \"document\") is a decision that will need updating when business requirements change. This post covers when to replace hardcoded conditionals with inline LLM calls, how to do it efficiently, and when the complexity isn't worth it.","thesis":"Some decisions are better made by models than code. When logic depends on fuzzy matching, domain expertise, or evolving requirements, an inline LLM call lets you upgrade behavior \"out of band\"—no redeployment needed. But this pattern has costs: latency, token spend, and unpredictability. Use it surgically.","thesisShort":"Some decisions are better made by models than code. When logic depends on fuzzy matching, domain expertise, or evolving requirements, an inline LLM call lets you upgrade behavior \"out of band\"—no redeployment needed.","headings":[{"level":2,"text":"The Hardcoded Logic Trap"},{"level":2,"text":"The Inline LLM Pattern"},{"level":2,"text":"The Out-of-Band Upgrade Pattern"},{"level":2,"text":"When to Use Inline LLM Calls"},{"level":3,"text":"✅ Good Candidates"},{"level":3,"text":"❌ Poor Candidates"},{"level":2,"text":"The Cost/Benefit Analysis"},{"level":2,"text":"Efficiency Patterns"},{"level":3,"text":"Batching Decisions"},{"level":3,"text":"Caching Decisions"},{"level":3,"text":"Hybrid Approach"},{"level":3,"text":"Pre-Computing Decisions"},{"level":2,"text":"MCP Integration"},{"level":2,"text":"Prompt Engineering for Decisions"},{"level":3,"text":"Structure Matters"},{"level":3,"text":"Include Examples"},{"level":3,"text":"Request Structured Output"},{"level":2,"text":"Observability and Debugging"},{"level":2,"text":"The Decision Framework"},{"level":2,"text":"Summary"}],"terms":["inline","logic","hardcoded","llm","redeployment","fuzzy","band","enumeration"],"passages":2,"embedding":true},{"slug":"mcp-dynamic-data-patterns","kind":"post","title":"MCP: From Hardcoded to Live Data","url":"/blog/mcp-dynamic-data-patterns/","file":"src/posts/ai-development/2026-01-11-mcp-dynamic-data-patterns.md","date":"2026-01-11","asOf":"2026-01-11","region":"standalone-ai-development","series":null,"tags":["mcp","ema","ai employee","generative workflow engine (gwe)","agentic-ai","architecture","developer","best-practices","ai-development"],"tokens":3700,"lead":"Hardcoded data in MCP servers is a trap. It works until it doesn't—until someone adds a new action, renames a widget, or deprecates an integration, and suddenly your MCP server is lying to the AI. This post covers how to make MCP data dynamic, when it's worth the complexity, and how to do it efficiently.","thesis":"MCP resources and tools should pull from live APIs whenever the underlying data can change. But dynamic data introduces latency, failure modes, and caching complexity. The art is knowing which data to make dynamic, how to cache it, and when to fall back gracefully.","thesisShort":"MCP resources and tools should pull from live APIs whenever the underlying data can change. But dynamic data introduces latency, failure modes, and caching complexity. The art is knowing which data to make dynamic, how to cache it, and when to fall back gracefully.","headings":[{"level":2,"text":"The Problem with Hardcoded Data"},{"level":2,"text":"When to Make Data Dynamic"},{"level":3,"text":"Signals You Need Dynamic Data"},{"level":2,"text":"The Dynamic Data Architecture"},{"level":3,"text":"The Three-Tier Fallback"},{"level":2,"text":"Caching Strategies"},{"level":3,"text":"TTL-Based Caching"},{"level":3,"text":"Stale-While-Revalidate"},{"level":3,"text":"Request Coalescing"},{"level":2,"text":"Environment-Aware Dynamic Data"},{"level":2,"text":"Efficient API Design"},{"level":3,"text":"Batch Endpoints"},{"level":3,"text":"Summary vs. Detail Endpoints"},{"level":2,"text":"Failure Modes and Graceful Degradation"},{"level":3,"text":"Timeout Handling"},{"level":3,"text":"Partial Failure"},{"level":3,"text":"Communicating Degradation"},{"level":2,"text":"When NOT to Use Dynamic Data"},{"level":3,"text":"1. Latency Is Critical"},{"level":3,"text":"2. Offline/Air-Gapped Environments"},{"level":3,"text":"3. The Data Is Truly Static"},{"level":3,"text":"4. You Need Deterministic Behavior"},{"level":2,"text":"Implementation Checklist"},{"level":2,"text":"The Result"}],"terms":["dynamic","cache","degradation","hardcoded","timeout","environment","batch","platform"],"passages":3,"embedding":true},{"slug":"ema-workflow-rag-patterns","kind":"post","title":"Ema Workflows: RAG Flow Control","url":"/blog/ema-workflow-rag-patterns/","file":"src/posts/ai-employees/2026-01-13-ema-workflow-rag-patterns.md","date":"2026-01-13","asOf":"2026-01-13","region":"standalone-ai-employees","series":null,"tags":["ema","ai employee","generative workflow engine (gwe)","agentic-ai","rag","workflows","tutorial","guide","cursor","ai-employees"],"tokens":4400,"lead":"A technical guide to controlling RAG flow in Ema workflows. Understanding trigger outputs, conversation handling, and query construction is the difference between a chatbot that retrieves relevant context and one that searches with noise. This guide demystifies the core concepts.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Core Problem"},{"level":2,"text":"Trigger Outputs Explained"},{"level":3,"text":"The Three Trigger Outputs"},{"level":3,"text":"When to Use Each"},{"level":2,"text":"How Search Query Works"},{"level":2,"text":"The Problem with Raw Conversation"},{"level":2,"text":"Solution: conversation_summarizer"},{"level":3,"text":"How It Works"},{"level":3,"text":"Basic Configuration"},{"level":2,"text":"additional_context: The Hidden Gem"},{"level":3,"text":"How to Use It"},{"level":3,"text":"Use Cases"},{"level":3,"text":"Why This Matters"},{"level":3,"text":"Accessing in Workflows"},{"level":2,"text":"Better Query Tuning Patterns"},{"level":3,"text":"Pattern 1: conversation_summarizer with Custom Instructions"},{"level":3,"text":"Pattern 2: call_llm as Query Builder"},{"level":3,"text":"Pattern 3: Entity Extraction → Query Construction"},{"level":2,"text":"Handling \"The Last Question Was About...\" References"},{"level":3,"text":"The Simple Approach: Use Full History"},{"level":3,"text":"The Explicit Approach: Extract Context"},{"level":2,"text":"When to Use What: Decision Matrix"},{"level":3,"text":"By Scenario"},{"level":3,"text":"By Pattern Complexity"},{"level":2,"text":"Recommended Workflow Patterns"},{"level":3,"text":"Basic Pattern: Summarizer → Search"},{"level":3,"text":"Advanced Pattern: Intent-Aware Query Building"},{"level":3,"text":"With additional_context"},{"level":2,"text":"Common Mistakes to Avoid"},{"level":3,"text":"Mistake 1: Raw Conversation to Search"},{"level":3,"text":"Mistake 2: Ignoring additional_context"},{"level":3,"text":"Mistake 3: Over-Engineering Simple Use Cases"},{"level":3,"text":"Mistake 4: Forgetting Token Limits"},{"level":2,"text":"Putting It All Together"},{"level":3,"text":"Scenario: Financial Advisor Chatbot"},{"level":2,"text":"TL;DR"}],"terms":["summarizer","additional","query","conversation","search","entity","extraction","history"],"passages":12,"embedding":true},{"slug":"rules-on-rules","kind":"post","title":"Rules on Rules on Rules","url":"/blog/rules-on-rules/","file":"src/posts/ai-development/2026-01-15-rules-on-rules.md","date":"2026-01-15","asOf":"2026-01-15","region":"standalone-ai-development","series":null,"tags":["cursor","developer","best-practices","workflow","ai-development"],"tokens":2800,"lead":"Rules on rules on rules—stacks on stacks on stacks—but for your AI. It's the slightly silly phrase that ends up solving a very real problem: keeping AI output consistent across a codebase.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Why Cursor Rules matter"},{"level":2,"text":"The meta trick: a rule for writing rules"},{"level":2,"text":"A real example rule"},{"level":2,"text":"Rule types and when to use them"},{"level":2,"text":"Best practices that keep rules sane"},{"level":2,"text":"Common mistakes (and how to fix them)"},{"level":2,"text":"Starter kit: checklist + template"},{"level":2,"text":"Quick FAQ"},{"level":2,"text":"Debugging Rule Application"},{"level":3,"text":"Check What's Injected"},{"level":3,"text":"Verify Rule Source"},{"level":3,"text":"Understand Priority"},{"level":3,"text":"Force Loading"},{"level":3,"text":"Common Reasons Rules Don't Apply"},{"level":2,"text":"Wrap-up: stack it, then ship"}],"terms":["globs","priority","stack","injected","repo","sane","trick","faq"],"passages":7,"embedding":true},{"slug":"goals-intents-outcomes","kind":"post","title":"Goals Matter More Than Code","url":"/blog/goals-intents-outcomes/","file":"src/posts/fundamentals/2026-01-15-goals-intents-outcomes.md","date":"2026-01-17","asOf":"2026-01-17","region":"standalone-fundamentals","series":null,"tags":["llm","agentic-ai","developer","architecture","design","workflow","fundamentals"],"tokens":4500,"lead":"How misaligned objectives between compilers, LLMs, and humans created 14 failures—and what we learned about designing for intent.","thesis":"Design for intent, not implementation: define success at the user level first, then let each component do one thing well. The compiler wants valid types, the LLM plausible output, the API runtime safety and the user a working Voice AI; let the LLM understand what the user wants while templates supply a known-valid starting point.","thesisShort":"Design for intent, not implementation: define success at the user level first, then let each component do one thing well. The compiler wants valid types, the LLM plausible output, the API runtime safety and the user a working Voice AI; let the LLM understand what the user wants…","headings":[{"level":2,"text":"The Question Nobody Asked"},{"level":2,"text":"Four Actors, Four Goals"},{"level":3,"text":"The Compiler's Goal: Structural Validity"},{"level":3,"text":"The API's Goal: Contract Enforcement"},{"level":3,"text":"The LLM's Goal: Pattern Completion"},{"level":3,"text":"The User's Goal: Outcome Achievement"},{"level":2,"text":"How Goal Misalignment Caused Failures"},{"level":3,"text":"Failure 1: Empty Widget Configs"},{"level":3,"text":"Failure 2: Wrong Namespace"},{"level":3,"text":"Failure 3: Workflow Name Mismatch"},{"level":3,"text":"Failure 4: Confident Wrong (LLM Hallucination)"},{"level":2,"text":"Intent vs. Implementation: The Core Problem"},{"level":2,"text":"Designing for Intent: The Fix"},{"level":3,"text":"Step 1: Define Success at the User Level"},{"level":3,"text":"Step 2: Work Backward from Outcomes"},{"level":3,"text":"Step 3: Assign Goals to Components"},{"level":3,"text":"Step 4: Define Contracts Between Components"},{"level":2,"text":"The LLM's Role: Intent Interpretation, Not Structure Generation"},{"level":3,"text":"Before: LLM Generates Structure"},{"level":3,"text":"After: LLM Interprets Intent, Template Provides Structure"},{"level":2,"text":"Brownfield: Intent-Driven Transformation"},{"level":3,"text":"Before: Keyword Matching"},{"level":3,"text":"After: Intent Interpretation + Schema-Guided Transformation"},{"level":2,"text":"Goal Alignment Checklist"},{"level":3,"text":"1. What is each actor's goal?"},{"level":3,"text":"2. Where do goals conflict?"},{"level":3,"text":"3. Who ensures each requirement?"},{"level":3,"text":"4. What does each component NOT know?"},{"level":2,"text":"The Resulting Architecture"},{"level":2,"text":"Key Takeaways"},{"level":3,"text":"1. Define success at the user level first"},{"level":3,"text":"2. Each component should have one goal"},{"level":3,"text":"3. LLMs interpret intent; templates provide structure"},{"level":3,"text":"4. Validate at boundaries, not just at the end"},{"level":3,"text":"5. Goals conflict — design for the conflicts"},{"level":2,"text":"Try This"}],"terms":["compiler","goal","component","llm","actor","valid","widget","interpretation"],"passages":18,"embedding":true},{"slug":"understanding-embeddings","kind":"post","title":"Embeddings: How Vectors Get Meaning","url":"/blog/understanding-embeddings/","file":"src/posts/search/2026-01-15-understanding-embeddings.md","date":"2026-01-18","asOf":"2026-01-18","region":"search-intent","series":{"id":"search-intent","title":"Search, Intent, and Action","order":2},"tags":["embeddings","machine-learning","semantic-search","vectors","fundamentals","series","search"],"tokens":4000,"lead":"Embeddings are the foundation of semantic understanding in AI. They turn words, sentences, and documents into numbers that capture meaning. This post explains how they work, why they matter, and how to use them.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What Are Embeddings?"},{"level":2,"text":"Why Vectors?"},{"level":2,"text":"How Embeddings Work"},{"level":3,"text":"The Training Process"},{"level":3,"text":"The Output"},{"level":2,"text":"Visualizing Embeddings"},{"level":2,"text":"Measuring Similarity"},{"level":2,"text":"Vector Arithmetic"},{"level":2,"text":"Embedding Models"},{"level":3,"text":"Evolution"},{"level":3,"text":"Current Options"},{"level":2,"text":"Generating Embeddings"},{"level":3,"text":"Browser (transformers.js)"},{"level":3,"text":"Node.js"},{"level":3,"text":"OpenAI API"},{"level":2,"text":"When to Generate Embeddings"},{"level":3,"text":"Build Time"},{"level":3,"text":"Ingest Time"},{"level":3,"text":"Query Time"},{"level":3,"text":"Hybrid Approaches"},{"level":2,"text":"Practical Considerations"},{"level":3,"text":"Chunking"},{"level":3,"text":"Normalization"},{"level":3,"text":"Storage"},{"level":2,"text":"Common Patterns"},{"level":3,"text":"Semantic Search"},{"level":3,"text":"Clustering"},{"level":3,"text":"Deduplication"},{"level":3,"text":"Classification"},{"level":2,"text":"Limitations"},{"level":3,"text":"What Embeddings Don't Capture"},{"level":3,"text":"Failure Modes"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Navigation"},{"level":2,"text":"Related Posts"}],"terms":["embeddings","vector","similar","normalize","transformers","chunks","bank","capture"],"passages":12,"embedding":true},{"slug":"mcp-tool-design","kind":"post","title":"MCP Tools People Actually Use","url":"/blog/mcp-tool-design/","file":"src/posts/ai-development/2026-01-19-mcp-tool-design.md","date":"2026-01-19","asOf":"2026-01-19","region":"standalone-ai-development","series":null,"tags":["mcp","developer","agentic-ai","patterns","ai-development"],"tokens":2700,"lead":"What we learned restructuring an MCP server from 7 \"super tools\" to 20 focused operations.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Clever Idea That Wasn't"},{"level":2,"text":"What Went Wrong"},{"level":3,"text":"Problem 1: Parameter Sprawl"},{"level":3,"text":"Problem 2: Inconsistent Patterns"},{"level":3,"text":"Problem 3: Wrong User Model"},{"level":2,"text":"The Key Insight: Users Speak, LLMs Choose"},{"level":2,"text":"Why Not Use Prompts?"},{"level":2,"text":"The Redesign: 5 Principles"},{"level":3,"text":"Principle 1: One Operation, One Tool"},{"level":3,"text":"Principle 2: Names Match Natural Language"},{"level":3,"text":"Principle 3: Flags for Common Combinations"},{"level":3,"text":"Principle 4: Hierarchy in Names"},{"level":3,"text":"Principle 5: Cross-Platform Compatibility"},{"level":2,"text":"Before and After"},{"level":3,"text":"Before: 7 Tools, 30+ Params Each"},{"level":3,"text":"After: 20 Focused Tools"},{"level":2,"text":"The Mental Model"},{"level":2,"text":"MCP Tool Design Checklist"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"References"}],"terms":["parameters","llm","principle","dots","flag","slash","clone","natural"],"passages":8,"embedding":true},{"slug":"beyond-rules","kind":"post","title":"Beyond Rules: Commands, Agents, and Skills","url":"/blog/beyond-rules/","file":"src/posts/ai-development/2026-01-20-beyond-rules.md","date":"2026-01-20","asOf":"2026-01-20","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":1},"tags":["cursor","developer","agentic-ai","series","ai-development"],"tokens":3800,"lead":"Rules are just the beginning. Cursor provides four artifact types—and using the wrong one creates friction. This post covers what rules can't do and when to reach for Commands, Agents, or Skills instead.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Problem: Everything in Rules"},{"level":2,"text":"The Four Artifact Types"},{"level":2,"text":"Commands: Workflows, Not Context"},{"level":3,"text":"Rules vs Commands"},{"level":3,"text":"Command Structure"},{"level":3,"text":"When to Use Commands"},{"level":3,"text":"Example: The /checkpoint Command"},{"level":2,"text":"Agents (Subagents): Specialized Expertise"},{"level":3,"text":"Why Subagents Matter"},{"level":3,"text":"Agent Structure"},{"level":3,"text":"Spawning Agents"},{"level":3,"text":"When to Use Agents"},{"level":2,"text":"Skills: Portable Knowledge"},{"level":3,"text":"When Skills Beat Rules"},{"level":3,"text":"Skill Locations"},{"level":3,"text":"Skill Structure"},{"level":3,"text":"Frontmatter Fields"},{"level":3,"text":"When to Use Skills"},{"level":2,"text":"The Decision Framework"},{"level":3,"text":"Quick Reference"},{"level":2,"text":"Directory Structure"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["skill","commands","subagents","frontmatter","portable","location","specialized","isolation"],"passages":8,"embedding":true},{"slug":"intent-approaches","kind":"post","title":"Intent: From Keywords to LLMs","url":"/blog/intent-approaches/","file":"src/posts/fundamentals/2026-01-15-intent-approaches.md","date":"2026-01-21","asOf":"2026-01-21","region":"search-intent","series":{"id":"search-intent","title":"Search, Intent, and Action","order":3},"tags":["search","intent","embeddings","semantic-search","llm","rag","developer","series","fundamentals"],"tokens":5100,"lead":"A technical comparison of intent understanding approaches—from simple keyword matching to LLM-powered reasoning. Each approach has trade-offs in speed, accuracy, complexity, and capability.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Try It: Live Comparison"},{"level":2,"text":"Two Dimensions: Approach and Runtime"},{"level":2,"text":"The Approach Spectrum"},{"level":2,"text":"Pre-LLM Approaches"},{"level":3,"text":"1. Keyword Search"},{"level":3,"text":"2. Fuzzy Matching"},{"level":3,"text":"3. Full-Text Search"},{"level":3,"text":"4. Embedding-Based Search"},{"level":2,"text":"LLM Approaches"},{"level":3,"text":"5. LLM Reranking"},{"level":3,"text":"6. RAG (Retrieval-Augmented Generation)"},{"level":3,"text":"7. Full LLM Search"},{"level":2,"text":"Hybrid Approaches"},{"level":3,"text":"Syntactic + Semantic"},{"level":3,"text":"Fast Retrieval + LLM Rerank"},{"level":2,"text":"Comparison Matrix"},{"level":2,"text":"Runtime Options"},{"level":3,"text":"Tradeoffs by Runtime"},{"level":2,"text":"Choosing an Approach"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Navigation"},{"level":2,"text":"Related Posts"}],"terms":["approach","llm","wasm","keyword","syntactic","search","retrieval","embeddings"],"passages":3,"embedding":true},{"slug":"agent-personas","kind":"post","title":"Designing Agent Personas That Actually Work","url":"/blog/agent-personas/","file":"src/posts/ai-development/2026-01-21-agent-personas.md","date":"2026-01-22","asOf":"2026-01-22","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":2},"tags":["cursor","developer","agentic-ai","agents","series","ema","ai-development"],"tokens":3800,"lead":"\"You are a helpful AI assistant\" is the persona equivalent of \"write clean code.\" It says nothing actionable. This post shows how to design agent personas that produce consistent, high-quality output for specific tasks.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Generic Persona Problem"},{"level":2,"text":"The Five Elements of Effective Personas"},{"level":2,"text":"Element 1: Role"},{"level":3,"text":"Role Patterns"},{"level":2,"text":"Element 2: Expertise"},{"level":3,"text":"Expertise Guidelines"},{"level":2,"text":"Element 3: Process"},{"level":3,"text":"Process Guidelines"},{"level":2,"text":"Element 4: Output"},{"level":3,"text":"Output Guidelines"},{"level":2,"text":"Element 5: Constraints"},{"level":3,"text":"Constraint Categories"},{"level":2,"text":"Complete Example: Security Auditor"},{"level":2,"text":"Persona Patterns"},{"level":3,"text":"The Specialist"},{"level":3,"text":"The Generalist"},{"level":3,"text":"The Contrarian"},{"level":3,"text":"The Producer"},{"level":3,"text":"The Investigator"},{"level":2,"text":"Agent Portfolio: 15 Personas"},{"level":2,"text":"Common Mistakes"},{"level":3,"text":"1. Too Broad"},{"level":3,"text":"2. No Process"},{"level":3,"text":"3. Vague Output"},{"level":3,"text":"4. Missing Constraints"},{"level":3,"text":"5. Generic Role"},{"level":2,"text":"Testing Your Personas"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["element","guidelines","generalist","contrarian","investigation","producer","specialists","expertise"],"passages":14,"embedding":true},{"slug":"ctx-pattern-coordination","kind":"post","title":".ctx: Memory for Amnesiac Agents","url":"/blog/ctx-pattern-coordination/","file":"src/posts/ai-development/2026-01-22-ctx-pattern-coordination.md","date":"2026-01-22","asOf":"2026-01-22","region":"standalone-ai-development","series":null,"tags":["cursor","agentic-ai","agents","developer","patterns","ai-development"],"tokens":2900,"lead":"AI agents are amnesiacs with no social skills. Each session starts fresh—no memory of what happened before, no awareness of other agents working on the same project. We discovered that a simple markdown file creates a surprisingly effective coordination layer.","thesis":"Agents can't remember and can't talk: each session starts with no memory of what happened before and no awareness of other agents on the same project. Give them a shared markdown file in the repo as the coordination protocol, with an ownership table, a status dashboard, locked decisions and a communication log that every agent reads before working and updates after. It survives session boundaries, humans can inspect it, and git versions every change; for most projects files are the protocol, not a database.","thesisShort":"Agents can't remember and can't talk: each session starts with no memory of what happened before and no awareness of other agents on the same project. Give them a shared markdown file in the repo as the coordination protocol, with an ownership table, a status dashboard, locked…","headings":[{"level":2,"text":"The Problem Nobody Talks About"},{"level":2,"text":"The Insight: Files Are the Protocol"},{"level":2,"text":"The Pattern: Task Coordination Document"},{"level":3,"text":"1. Ownership Table"},{"level":3,"text":"2. Status Dashboard"},{"level":3,"text":"3. Locked Decisions"},{"level":3,"text":"4. Agent Communication Log"},{"level":2,"text":"Real Example: Building a 6-Phase Project"},{"level":3,"text":"Step 1: Architect Agent Designs"},{"level":3,"text":"Step 2: Implementation Agent Claims Work"},{"level":3,"text":"Step 3: Architect Agent Claims Future Work"},{"level":3,"text":"Step 4: Spawning Specialists"},{"level":3,"text":"Step 5: Full Team Assembled"},{"level":2,"text":"Why This Works Better Than You'd Expect"},{"level":3,"text":"1. Agents Follow Protocol Reliably"},{"level":3,"text":"2. Humans Stay in the Loop"},{"level":3,"text":"3. Git Becomes Your Audit Trail"},{"level":3,"text":"4. It Scales to Complex Dependencies"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"Limitations to Know"},{"level":2,"text":"The Minimal Template"},{"level":2,"text":"What We Learned"},{"level":2,"text":"What to Do Next"}],"terms":["coordination","architect","ownership","ctx","protocol","project","dependencies","claim"],"passages":9,"embedding":true},{"slug":"multi-agent-illusion","kind":"post","title":"The Multi-Agent Illusion","url":"/blog/multi-agent-illusion/","file":"src/posts/ai-development/2026-01-22-multi-agent-illusion.md","date":"2026-01-22","asOf":"2026-01-22","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":3},"tags":["cursor","agentic-ai","agents","series","developer","ai-development"],"tokens":3100,"lead":"You ask your AI-powered IDE to \"have the security auditor review this code.\" A specialized agent springs into action—separate from the main assistant, purpose-built for security analysis. Right? The reality is more nuanced. There are actually two models for how \"agents\" work, and understanding both changes how you should design.","thesis":"When you ask your IDE to have the security auditor review your code, you usually do not get a separate agent. Mentioning an agent applies a persona lens: the same model in the same context, shaped by the agent file's prompt. Handing a task to the Task tool spawns a true subagent, with its own isolated context. Both produce specialized behavior; the difference is context isolation, so know which one you are triggering.","thesisShort":"When you ask your IDE to have the security auditor review your code, you usually do not get a separate agent. Mentioning an agent applies a persona lens: the same model in the same context, shaped by the agent file's prompt.","headings":[{"level":2,"text":"The Common Assumption"},{"level":2,"text":"Model 1: The Persona Lens (Same Context)"},{"level":2,"text":"Model 2: True Subagents (Isolated Context)"},{"level":2,"text":"The \"Apply Lens\" Mechanism"},{"level":3,"text":"Frontmatter Fields (Configuration)"},{"level":3,"text":"Prompt Body (System Instructions)"},{"level":3,"text":"Real Example: Security Auditor"},{"level":2,"text":"When You Get Which Model"},{"level":3,"text":"Cursor's Built-in Subagents"},{"level":2,"text":"The Mental Model Shift"},{"level":2,"text":"Why Fresh Context Matters"},{"level":2,"text":"Practical Implications"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"What to Do Next"}],"terms":["subagents","lens","isolation","auditor","fresh","true","parallel","security"],"passages":4,"embedding":true},{"slug":"persona-lens-anatomy","kind":"post","title":"Anatomy of a Persona Lens","url":"/blog/persona-lens-anatomy/","file":"src/posts/ai-development/2026-01-23-persona-lens-anatomy.md","date":"2026-01-23","asOf":"2026-01-23","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":6},"tags":["cursor","agentic-ai","agents","series","developer","prompt-engineering","ai-development"],"tokens":2300,"lead":"A persona definition is a structured prompt that shapes how a single base model responds. Let's open one up and see exactly how it works—and why structure matters more than you'd expect.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What's in a Persona File"},{"level":2,"text":"How Claude Applies a Persona"},{"level":2,"text":"The Stateless Reality"},{"level":2,"text":"Why Structure Matters"},{"level":2,"text":"The Anatomy Breakdown"},{"level":2,"text":"Authoring Guidelines"},{"level":3,"text":"Role: Be Specific About Perspective"},{"level":3,"text":"Expertise: Bounded, Not Buzzwords"},{"level":3,"text":"Process: Numbered Steps, Not Aspirations"},{"level":3,"text":"Output: Show the Template"},{"level":3,"text":"Constraints: Explicit Boundaries"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"Quick Reference: Persona File Checklist"},{"level":2,"text":"What to Do Next"}],"terms":["anatomy","claude","auditor","lens","security","breakdown","perspective","expertise"],"passages":4,"embedding":true},{"slug":"search-lab","kind":"post","title":"Search is Dead. Long Live Action.","url":"/blog/search-lab/","file":"src/posts/search/2026-01-15-search-lab.md","date":"2026-01-23","asOf":"2026-01-23","region":"search-intent","series":{"id":"search-intent","title":"Search, Intent, and Action","order":1},"tags":["search","intent","semantic-search","agentic-ai","fundamentals","series","rag","embeddings"],"tokens":2300,"lead":"Nobody ever wanted search results. They wanted answers. But here's the thing—they didn't actually want answers either. They wanted action. This post traces the evolution from search to intent to action, and why the search box is a relic of a constraint that no longer exists.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Evolution"},{"level":2,"text":"The Search Era: Lists of Links"},{"level":3,"text":"Why Search Persisted"},{"level":2,"text":"The Answers Era: Knowledge Panels"},{"level":2,"text":"The Action Era: Agents"},{"level":2,"text":"The Paradigm Shift"},{"level":2,"text":"Why \"Search\" Thinking Persists"},{"level":2,"text":"Intent Understanding: The Foundation"},{"level":3,"text":"Syntactic Understanding (Structure)"},{"level":3,"text":"Semantic Understanding (Meaning)"},{"level":3,"text":"Intent Understanding (Purpose)"},{"level":2,"text":"The Action Stack"},{"level":2,"text":"Building for Action"},{"level":2,"text":"The Hybrid Reality"},{"level":2,"text":"Related: RAG and Agentic Workflows"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Navigation"},{"level":2,"text":"Related Posts"}],"terms":["search","flight","era","book","retrieval","accomplish","rag","paradigm"],"passages":3,"embedding":true},{"slug":"persona-lens-design","kind":"post","title":"Designing with the Persona Lens Model","url":"/blog/persona-lens-design/","file":"src/posts/ai-development/2026-01-24-persona-lens-design.md","date":"2026-01-24","asOf":"2026-01-24","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":7},"tags":["cursor","agentic-ai","agents","series","developer","architecture","ai-development"],"tokens":2600,"lead":"Understanding that agents are persona lenses changes how you design routing, coordination, and expectations. This post covers practical patterns for building systems that work with this reality rather than against it.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Implication 1: Routing is Persona Selection"},{"level":2,"text":"Implication 2: Coordination is Persona Layering"},{"level":2,"text":"Merge Strategies"},{"level":3,"text":"Example: Reconcile Strategy"},{"level":2,"text":"Implication 3: Personas are Pure Functions"},{"level":2,"text":"Implication 4: Authoring is Prompt Engineering"},{"level":2,"text":"Decision Framework: When to Use Multiple Personas"},{"level":3,"text":"Single Persona"},{"level":3,"text":"Multiple Personas (Parallel)"},{"level":3,"text":"Chained Personas (Sequential)"},{"level":3,"text":"Router + Persona"},{"level":2,"text":"Common Mistakes"},{"level":2,"text":"Persona Portfolio: Coverage Without Overlap"},{"level":2,"text":"Anti-Pattern: The God Persona"},{"level":2,"text":"Pattern: Persona Composition"},{"level":2,"text":"Setting Realistic Expectations"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"What to Do Next"}],"terms":["implications","lens","parallel","strategy","reconcile","router","expectations","merge"],"passages":3,"embedding":true},{"slug":"smart-routing","kind":"post","title":"Smart Routing: Right Agent, Right Job","url":"/blog/smart-routing/","file":"src/posts/ai-development/2026-01-22-smart-routing.md","date":"2026-01-24","asOf":"2026-01-24","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":4},"tags":["cursor","developer","agentic-ai","agents","series","ai-development"],"tokens":2400,"lead":"Manually spawning agents doesn't scale. If you have 15 specialized agents but have to remember which one handles what, you'll just use the main assistant. This post shows how to route tasks to agents automatically based on patterns.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Routing Problem"},{"level":2,"text":"The Routing Rule"},{"level":2,"text":"Pattern Matching in Practice"},{"level":3,"text":"Compound Patterns"},{"level":2,"text":"Spawn Patterns"},{"level":3,"text":"Sequential Handoff"},{"level":3,"text":"Parallel Review"},{"level":3,"text":"Background Investigation"},{"level":2,"text":"Complete Interaction Flow"},{"level":2,"text":"Natural Language Triggers"},{"level":2,"text":"When NOT to Route"},{"level":2,"text":"Debugging Routing"},{"level":3,"text":"Check Pattern Match"},{"level":3,"text":"Force Specific Agent"},{"level":3,"text":"See Available Agents"},{"level":3,"text":"Verify Agent Exists"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["spawn","parallel","investigation","smart","sequential","main","handoff","specialists"],"passages":2,"embedding":true},{"slug":"compiler-to-llm-workflows","kind":"post","title":"Compiler to LLM Workflows","url":"/blog/compiler-to-llm-workflows/","file":"src/posts/fundamentals/2026-01-15-compiler-to-llm-workflows.md","date":"2026-01-25","asOf":"2026-01-25","region":"standalone-fundamentals","series":null,"tags":["llm","agentic-ai","developer","workflow","cursor","fundamentals"],"tokens":2600,"lead":"How intent-first development compressed our iteration loops—and why the quality surprised us more than the speed.","thesis":"Switching to an LLM-based workflow doesn't replace engineering discipline—it compresses iteration loops. From \"compile cycle\" to \"intent → generation → optimization → validation.\" And when you add config + rule-driven constraints, the quality jump is wild.","thesisShort":"Switching to an LLM-based workflow doesn't replace engineering discipline—it compresses iteration loops. From \"compile cycle\" to \"intent → generation → optimization → validation.\" And when you add config + rule-driven constraints, the quality jump is wild.","headings":[{"level":2,"text":"The Old World"},{"level":2,"text":"The Compiler Workflow: Why It's Great (and Where It Hurts)"},{"level":2,"text":"The LLM Workflow: Intent-First Engineering"},{"level":2,"text":"The \"Config + Text\" Unlock: Controlling the Output"},{"level":2,"text":"A Concrete Before/After: Persona Creation Flow"},{"level":2,"text":"The Moment It Got Astounding"},{"level":2,"text":"Why This Works: Compilers Validate, LLMs Accelerate Intent"},{"level":2,"text":"What Didn't Work (Honest Pitfalls)"},{"level":2,"text":"Practical Workflow You Can Copy"},{"level":3,"text":"The Loop"},{"level":3,"text":"Checklist"},{"level":2,"text":"The New Loop Is Addictive"},{"level":2,"text":"Try This Today"}],"terms":["compiler","llm","accelerate","config","constraints","typescript","hurt","unlock"],"passages":9,"embedding":true},{"slug":"autonomous-workflows","kind":"post","title":"Commands That Know When to Merge","url":"/blog/autonomous-workflows/","file":"src/posts/ai-development/2026-01-23-autonomous-workflows.md","date":"2026-01-26","asOf":"2026-01-26","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":5},"tags":["cursor","developer","agentic-ai","automation","series","ai-development"],"tokens":3500,"lead":"Two problems: commands that duplicate work, and an AI that asks permission for everything. This post solves both—smart command orchestration that eliminates redundancy, and pre-authorized autonomous actions that let AI work without constant interruption.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Problem 1: Command Overlap"},{"level":2,"text":"Command Subsumption"},{"level":3,"text":"The Subsumption Matrix"},{"level":3,"text":"Command Ordering"},{"level":2,"text":"The Coalescing Rule"},{"level":2,"text":"Coalescing in Action"},{"level":2,"text":"Natural Language Detection"},{"level":2,"text":"Problem 2: Permission Fatigue"},{"level":2,"text":"The Autonomy Spectrum"},{"level":2,"text":"Action Classification"},{"level":2,"text":"The Autonomous Workflows Rule"},{"level":2,"text":"The Continuous Work Loop"},{"level":2,"text":"Autonomous Session Example"},{"level":2,"text":"Adjusting Autonomy Levels"},{"level":3,"text":"High Autonomy (Solo Developer)"},{"level":3,"text":"Low Autonomy (Regulated Environment)"},{"level":3,"text":"Per-Task Override"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["cleanup","checkpoint","coalescing","autonomy","commands","push","spectrum","overlap"],"passages":1,"embedding":true},{"slug":"alwaysapply-tax","kind":"post","title":"The alwaysApply Tax","url":"/blog/alwaysapply-tax/","file":"src/posts/ai-development/2026-01-27-alwaysapply-tax.md","date":"2026-01-27","asOf":"2026-01-27","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":10},"tags":["cursor","developer","agentic-ai","best-practices","series","ai-development"],"tokens":2300,"lead":"We audited a mature Cursor configuration and found 22 rules with alwaysApply: true, totaling 2,700 lines loaded into every single conversation—including \"what's 2+2?\" This is the alwaysApply tax.","thesis":"Every alwaysApply rule is paid for in every conversation, relevant or not. Always-on instructions cost tokens, compete for room in the context and degrade the model's attention on what matters, and their lines compound as they accumulate. Most of them should load on a glob or live in a skill: keep always-on only what affects every interaction, and budget the lines.","thesisShort":"Every alwaysApply rule is paid for in every conversation, relevant or not. Always-on instructions cost tokens, compete for room in the context and degrade the model's attention on what matters, and their lines compound as they accumulate.","headings":[{"level":2,"text":"The Discovery"},{"level":2,"text":"Why This Matters"},{"level":3,"text":"1. Token Costs"},{"level":3,"text":"2. Context Window Competition"},{"level":3,"text":"3. Response Quality"},{"level":2,"text":"The Audit Results"},{"level":3,"text":"What We Found"},{"level":3,"text":"Rules That Should Stay alwaysApply"},{"level":3,"text":"Rules That Should Use Globs"},{"level":3,"text":"Estimated Savings"},{"level":2,"text":"The Decision Framework"},{"level":3,"text":"When alwaysApply IS Appropriate"},{"level":3,"text":"When alwaysApply is NOT Appropriate"},{"level":3,"text":"The Test"},{"level":2,"text":"Case Study: The Logging Rule"},{"level":3,"text":"Before"},{"level":3,"text":"After"},{"level":2,"text":"The Compound Effect"},{"level":3,"text":"Individual Rules Seem Small"},{"level":3,"text":"But They Compound"},{"level":3,"text":"The Boiling Frog"},{"level":2,"text":"How to Audit Your Setup"},{"level":3,"text":"Step 1: Count alwaysApply rules"},{"level":3,"text":"Step 2: Measure total lines"},{"level":3,"text":"Step 3: List them"},{"level":3,"text":"Step 4: Evaluate each"},{"level":3,"text":"Step 5: Migrate"},{"level":2,"text":"Organizational Patterns"},{"level":3,"text":"For Teams"},{"level":3,"text":"For Shared Configurations"},{"level":2,"text":"Common Objections"},{"level":3,"text":"\"But I might need it!\""},{"level":3,"text":"\"Performance impact is small\""},{"level":3,"text":"\"I can't remember which file triggers which rule\""},{"level":2,"text":"Benchmarks"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["alwaysapply","globs","core","compounds","tokens","appropriate","skill","tax"],"passages":4,"embedding":true},{"slug":"audit-ai-config","kind":"post","title":"Audit Your AI Config","url":"/blog/audit-ai-config/","file":"src/posts/ai-development/2026-01-27-audit-ai-config.md","date":"2026-01-27","asOf":"2026-01-27","region":"standalone-ai-development","series":null,"tags":["cursor","developer","agentic-ai","best-practices","workflow","ai-development"],"tokens":2500,"lead":"You've learned about rules vs skills, the alwaysApply tax, and discovery mechanics. Now what? This post provides a step-by-step audit process for cleaning up an existing AI configuration. The goal: fewer rules, faster responses, better AI behavior.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Audit Framework"},{"level":2,"text":"Phase 1: Inventory"},{"level":3,"text":"Step 1.1: Count Everything"},{"level":3,"text":"Step 1.2: Measure alwaysApply Load"},{"level":3,"text":"Step 1.3: Find Oversized Rules"},{"level":3,"text":"Step 1.4: Document Current State"},{"level":2,"text":"Phase 2: Evaluate"},{"level":3,"text":"Step 2.1: Audit Each alwaysApply Rule"},{"level":3,"text":"Step 2.2: Create Migration Plan"},{"level":3,"text":"Step 2.3: Evaluate Skills"},{"level":2,"text":"Phase 3: Migrate"},{"level":3,"text":"Step 3.1: Convert alwaysApply to Globs"},{"level":3,"text":"Step 3.2: Extract Workflows to Skills"},{"level":3,"text":"Step 3.3: Split Oversized Rules"},{"level":3,"text":"Step 3.4: Improve Skill Descriptions"},{"level":3,"text":"Step 3.5: Consolidate Redundant Skills"},{"level":2,"text":"Phase 4: Verify"},{"level":3,"text":"Step 4.1: Re-measure"},{"level":3,"text":"Step 4.2: Test Key Workflows"},{"level":3,"text":"Step 4.3: Document Results"},{"level":2,"text":"Maintenance Schedule"},{"level":3,"text":"Weekly"},{"level":3,"text":"Monthly"},{"level":3,"text":"Quarterly"},{"level":2,"text":"Decision Trees"},{"level":3,"text":"Should This Be alwaysApply?"},{"level":3,"text":"Should This Be a Skill or Rule?"},{"level":3,"text":"How to Improve Skill Discovery?"},{"level":2,"text":"Pre-Flight Checklist"},{"level":3,"text":"Before Starting"},{"level":3,"text":"Inventory Complete"},{"level":3,"text":"Evaluation Complete"},{"level":3,"text":"Migration Complete"},{"level":3,"text":"Verification Complete"},{"level":2,"text":"Key Takeaways"}],"terms":["alwaysapply","skill","globs","inventory","migration","consolidating","extract","split"],"passages":2,"embedding":true},{"slug":"rules-vs-skills","kind":"post","title":"Rules vs Skills in AI Dev","url":"/blog/rules-vs-skills/","file":"src/posts/ai-development/2026-01-27-rules-vs-skills.md","date":"2026-01-27","asOf":"2026-01-27","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":11},"tags":["cursor","developer","agentic-ai","best-practices","series","ai-development"],"tokens":2700,"lead":"Rules and skills are both configuration artifacts, but they serve different purposes. Mixing them creates bloated rules that should be skills, or skills that are just reference material. Here's how to know which to use.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Configuration Chaos"},{"level":2,"text":"The Core Distinction"},{"level":2,"text":"Rules: What and When"},{"level":3,"text":"What Belongs in Rules"},{"level":3,"text":"Activation Patterns"},{"level":3,"text":"Example Rule"},{"level":2,"text":"Skills: How"},{"level":3,"text":"What Belongs in Skills"},{"level":3,"text":"Activation Patterns"},{"level":3,"text":"Example Skill"},{"level":2,"text":"The Decision Framework"},{"level":3,"text":"Quick Test"},{"level":3,"text":"Content Type Mapping"},{"level":2,"text":"Token Economics"},{"level":3,"text":"The Cost of Rules"},{"level":3,"text":"Why This Matters"},{"level":3,"text":"Size Guidelines"},{"level":2,"text":"Soft Routing: Rules Can Mention Skills"},{"level":3,"text":"Why It's \"Soft\""},{"level":2,"text":"Worked Examples"},{"level":3,"text":"Example 1: Code Formatting"},{"level":3,"text":"Example 2: PR Creation"},{"level":3,"text":"Example 3: API Response Format"},{"level":2,"text":"Migration Guide"},{"level":3,"text":"Audit Your Rules"},{"level":3,"text":"Audit Your Skills"},{"level":3,"text":"Migration Steps"},{"level":2,"text":"Common Misconceptions"},{"level":3,"text":"\"Rules can invoke skills\""},{"level":3,"text":"\"More rules = smarter AI\""},{"level":3,"text":"\"Skills need rules to be found\""},{"level":3,"text":"\"alwaysApply is the default\""},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["skill","alwaysapply","activation","globs","belongs","guidelines","migration","tokens"],"passages":14,"embedding":true},{"slug":"search-implementation-guide","kind":"post","title":"Building This Blog's Search","url":"/blog/search-implementation-guide/","file":"src/posts/search/2026-01-15-search-implementation-guide.md","date":"2026-01-27","asOf":"2026-01-27","region":"search-intent","series":{"id":"search-intent","title":"Search, Intent, and Action","order":4},"tags":["search","intent","embeddings","implementation","tutorial","developer","series","rag"],"tokens":2400,"lead":"A walkthrough of how this blog implements intent handling—what's built, what's working, and what's next. Spoiler: we're not as far along as the other posts might suggest.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Current State: Honest Assessment"},{"level":2,"text":"What's Working"},{"level":3,"text":"1. Keyboard-Triggered Search Overlay"},{"level":3,"text":"2. Keyword Filtering"},{"level":3,"text":"3. Shareable URLs"},{"level":3,"text":"4. Copy Link Shortcut"},{"level":2,"text":"What's Working"},{"level":3,"text":"Build-Time Embeddings"},{"level":3,"text":"Hybrid Search in main.js"},{"level":2,"text":"The Target Architecture"},{"level":2,"text":"Design Decisions"},{"level":2,"text":"What's Next"},{"level":3,"text":"Phase 1: Done ✅"},{"level":3,"text":"Phase 2: Search Mode Toggle"},{"level":3,"text":"Phase 3: Natural Language Queries"},{"level":2,"text":"Try It"},{"level":2,"text":"Performance (Current)"},{"level":2,"text":"Performance (Target with Semantic)"},{"level":2,"text":"Source Code"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Navigation"},{"level":2,"text":"Related Posts"}],"terms":["search","semantic","keyword","embeddings","hybrid","shareable","url","instant"],"passages":2,"embedding":true},{"slug":"skill-discovery","kind":"post","title":"How Cursor Finds Skills","url":"/blog/skill-discovery/","file":"src/posts/ai-development/2026-01-27-skill-discovery.md","date":"2026-01-27","asOf":"2026-01-27","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":12},"tags":["cursor","developer","agentic-ai","best-practices","series","ai-development"],"tokens":5000,"lead":"You created a custom skill. You tested it. It works when you invoke it directly. But when you describe what you want naturally, the AI ignores it. The skill exists—but it's invisible. Here's why.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Agent Skills: The Open Standard"},{"level":2,"text":"Where Skills Live"},{"level":3,"text":"Skill Directory Structure"},{"level":2,"text":"How Discovery Actually Works"},{"level":3,"text":"The Discovery Flow"},{"level":2,"text":"The SKILL.md Frontmatter"},{"level":3,"text":"Real Example: The ship Skill"},{"level":3,"text":"Real Example: The threat-model Skill"},{"level":2,"text":"The Description Field: Make or Break"},{"level":3,"text":"Why Most Skills Are Invisible"},{"level":3,"text":"The Anatomy of a Good Description"},{"level":3,"text":"Write in Third Person"},{"level":3,"text":"Include Natural Language Triggers"},{"level":2,"text":"The compatibility Field"},{"level":2,"text":"The metadata Field"},{"level":3,"text":"Common Uses"},{"level":2,"text":"The disable-model-invocation Option"},{"level":2,"text":"Progressive Disclosure: Keep SKILL.md Lean"},{"level":3,"text":"The Default Assumption"},{"level":3,"text":"Use References for Detail"},{"level":3,"text":"Keep References One Level Deep"},{"level":2,"text":"Testing Your Skills"},{"level":3,"text":"Test 1: Direct Invocation"},{"level":3,"text":"Test 2: Intent Matching"},{"level":3,"text":"Test 3: Natural Language Triggers"},{"level":3,"text":"Test 4: Check Discovery"},{"level":2,"text":"Common Patterns"},{"level":3,"text":"Pattern 1: The Workflow Skill"},{"level":3,"text":"Pattern 2: The Domain Expert Skill"},{"level":3,"text":"Pattern 3: The Bootstrap Skill"},{"level":2,"text":"Viewing and Managing Skills"},{"level":3,"text":"View Discovered Skills"},{"level":3,"text":"Install Skills from GitHub"},{"level":3,"text":"Migrate Existing Rules to Skills"},{"level":2,"text":"Debugging Checklist"},{"level":3,"text":"Common Failures"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Further Reading"},{"level":2,"text":"Series Wrap-Up"}],"terms":["skill","compatibility","disable","metadata","progressive","reference","global","github"],"passages":14,"embedding":true},{"slug":"three-tier-context","kind":"post","title":"The Three-Tier Context System","url":"/blog/three-tier-context/","file":"src/posts/ai-development/2026-01-27-three-tier-context.md","date":"2026-01-27","asOf":"2026-01-27","region":"standalone-ai-development","series":null,"tags":["cursor","developer","agentic-ai","best-practices","workflow","ai-development"],"tokens":2400,"lead":"AI-assisted development generates artifacts that didn't exist before: insights from debugging sessions, decisions made in conversation, draft content, task coordination. Without a system, these end up scattered, lost, or committed when they shouldn't be. Here's a framework for organizing AI-generated context.","thesis":"AI-assisted development produces artifacts that did not exist before, such as insights, decisions, drafts and task coordination between sessions, and without a system they end up scattered, lost or committed when they shouldn't be. One question decides where each one lives: would losing this hurt if I cloned fresh? What you can rediscover goes in a gitignored .ctx/, decisions contributors need in a committed .meta/, and what users need in docs/; knowledge that earns it promotes upward, from insight to decision to doc to rule.","thesisShort":"AI-assisted development produces artifacts that did not exist before, such as insights, decisions, drafts and task coordination between sessions, and without a system they end up scattered, lost or committed when they shouldn't be.","headings":[{"level":2,"text":"The Problem: Context Sprawl"},{"level":2,"text":"The Heuristic"},{"level":2,"text":"The Three Tiers"},{"level":3,"text":"Tier 1: .ctx/ — Ephemeral Context"},{"level":3,"text":"Tier 2: .meta/ — Internal Documentation"},{"level":3,"text":"Tier 3: docs/ — Public Documentation"},{"level":2,"text":"Worked Examples"},{"level":2,"text":"Why Not Just Use docs/?"},{"level":2,"text":"Implementation Guide"},{"level":3,"text":"Step 1: Create the Structure"},{"level":3,"text":"Step 2: Update .gitignore"},{"level":3,"text":"Step 3: Add README Files"},{"level":3,"text":"Step 4: Migrate Existing Content"},{"level":2,"text":"The Promotion Path"},{"level":2,"text":"Archive Hygiene"},{"level":3,"text":"The Problem"},{"level":3,"text":"The Solution"},{"level":3,"text":"For AI Assistants"},{"level":2,"text":"Common Mistakes"},{"level":3,"text":"Mistake 1: Committing .ctx/"},{"level":3,"text":"Mistake 2: Putting Decisions in docs/"},{"level":3,"text":"Mistake 3: No Archive Separation"},{"level":3,"text":"Mistake 4: Skipping Frontmatter"},{"level":2,"text":"AI Assistant Guidelines"},{"level":3,"text":"When Capturing Insights"},{"level":3,"text":"When Creating Decisions"},{"level":3,"text":"When Reading Archives"},{"level":2,"text":"Integration with .cursor/"},{"level":2,"text":"Key Takeaways"}],"terms":["archive","ctx","tier","adr","meta","gitignore","contributors","docs"],"passages":4,"embedding":true},{"slug":"testing-artifacts","kind":"post","title":"Testing AI Artifacts: A Validation Framework","url":"/blog/testing-artifacts/","file":"src/posts/ai-development/2026-01-24-testing-artifacts.md","date":"2026-01-28","asOf":"2026-01-28","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":8},"tags":["cursor","developer","agentic-ai","testing","series","ai-development"],"tokens":3400,"lead":"Most teams create rules and commands but never verify they work. Then they're surprised when the AI ignores guidance or produces inconsistent output. This post introduces a testing framework for validating AI artifacts—structural, content, and behavioral tests.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Testing Challenge"},{"level":2,"text":"The Artifact Testing Pyramid"},{"level":2,"text":"Structural Tests"},{"level":3,"text":"For Rules"},{"level":3,"text":"For Commands"},{"level":3,"text":"For Agents"},{"level":2,"text":"Content Tests"},{"level":3,"text":"Actionable Instructions"},{"level":3,"text":"Description Quality"},{"level":3,"text":"Example Presence"},{"level":2,"text":"Behavioral Tests (Golden Tests)"},{"level":3,"text":"Golden Test Format"},{"level":3,"text":"Golden Test for Rules"},{"level":3,"text":"Golden Test for Agents"},{"level":2,"text":"The /test-artifact Command"},{"level":2,"text":"Test Execution Example"},{"level":2,"text":"Interactive Testing Mode"},{"level":2,"text":"Regression Testing"},{"level":2,"text":"Integration Tests"},{"level":2,"text":"Validation Checklist"},{"level":3,"text":"Rules"},{"level":3,"text":"Commands"},{"level":3,"text":"Agents"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"What's Next"}],"terms":["golden","commands","behavioral","regression","interactive","structural","actionable","presence"],"passages":4,"embedding":true},{"slug":"compiler-vs-llm-orchestrated","kind":"post","title":"Compiler vs LLM: A Deep Dive","url":"/blog/compiler-vs-llm-orchestrated/","file":"src/posts/fundamentals/2026-01-15-compiler-vs-llm-orchestrated.md","date":"2026-01-29","asOf":"2026-01-29","region":"standalone-fundamentals","series":null,"tags":["llm","agentic-ai","developer","workflow","api","debugging","ema","fundamentals"],"tokens":5400,"lead":"Why the same spec produces wildly different outputs—and how we fixed it after 14 API failures.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Setup: What We Were Building"},{"level":2,"text":"The API Contract: What the Server Actually Expects"},{"level":3,"text":"Widget Format"},{"level":3,"text":"Action Format"},{"level":2,"text":"Approach 1: The Compiler"},{"level":3,"text":"How It Works"},{"level":3,"text":"The Code"},{"level":3,"text":"What It Produced (First Version)"},{"level":3,"text":"Why the Compiler Failed"},{"level":3,"text":"After Fixing the Compiler"},{"level":2,"text":"Approach 1 Continued: The workflow_def Problem"},{"level":3,"text":"What the Compiler Produced"},{"level":3,"text":"API Error"},{"level":3,"text":"What Was Wrong"},{"level":3,"text":"The Fix"},{"level":3,"text":"Still Failed"},{"level":2,"text":"Approach 2: LLM-Orchestrated with Template Preservation"},{"level":3,"text":"The Insight"},{"level":3,"text":"The New Architecture"},{"level":3,"text":"The Code"},{"level":3,"text":"What This Produces"},{"level":2,"text":"Comparison: What Each Approach Got Wrong"},{"level":2,"text":"The Brownfield Case: LLM-Native Transformation"},{"level":3,"text":"The Schema"},{"level":3,"text":"How It Works"},{"level":3,"text":"Why This Works Better"},{"level":2,"text":"Results: The Numbers"},{"level":2,"text":"Lessons Learned"},{"level":3,"text":"1. Compilers enforce their contract, not the target's"},{"level":3,"text":"2. Templates are contracts made concrete"},{"level":3,"text":"3. Merge, don't replace"},{"level":3,"text":"4. LLMs excel at transformation, not generation from scratch"},{"level":3,"text":"5. Validate at the boundary"},{"level":2,"text":"The Architecture That Worked"},{"level":2,"text":"Try This"}],"terms":["compiler","widget","def","template","config","transformation","emainternal","approach"],"passages":14,"embedding":true},{"slug":"subagents-fresh-context","kind":"post","title":"Subagents: Fresh Eyes on Demand","url":"/blog/subagents-fresh-context/","file":"src/posts/ai-development/2026-01-29-subagents-fresh-context.md","date":"2026-01-29","asOf":"2026-01-29","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":13},"tags":["cursor","developer","agentic-ai","best-practices","series","ai-development"],"tokens":4000,"lead":"The main AI assistant has been helping you for an hour. It's seen every file you've opened, every failed attempt, every tangent. Now you need a fresh perspective—someone who hasn't been marinating in your assumptions. That's what subagents provide: clean context on demand.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What Subagents Actually Are"},{"level":2,"text":"Why Fresh Context Matters"},{"level":3,"text":"The Conversation Pollution Problem"},{"level":3,"text":"Fresh Eyes See Differently"},{"level":2,"text":"Built-in Subagents"},{"level":3,"text":"Real Example: Parallel Exploration"},{"level":2,"text":"Custom Subagents"},{"level":3,"text":"File Locations"},{"level":3,"text":"Configuration Fields"},{"level":2,"text":"The Verification Pattern"},{"level":3,"text":"Why It Works"},{"level":3,"text":"Real Example: Critic Agent"},{"level":3,"text":"Verifier Template"},{"level":2,"text":"The Security Audit Pattern"},{"level":3,"text":"Real Example: Security Auditor"},{"level":2,"text":"The Meta-Analysis Pattern"},{"level":3,"text":"Real Example: Meta Analyzer"},{"level":2,"text":"Parallel Execution Patterns"},{"level":3,"text":"Spawning Multiple Subagents"},{"level":3,"text":"Real Example: Building Four Workflows"},{"level":3,"text":"Orchestrator Pattern"},{"level":2,"text":"Foreground vs Background"},{"level":3,"text":"Background for Long Tasks"},{"level":3,"text":"Resuming Subagents"},{"level":2,"text":"When to Use Subagents vs Skills"},{"level":2,"text":"Best Practices"},{"level":3,"text":"Do"},{"level":3,"text":"Don't"},{"level":2,"text":"Performance Considerations"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Further Reading"}],"terms":["subagents","parallel","fresh","background","eyes","security","resume","auditor"],"passages":8,"embedding":true},{"slug":"meta-learning","kind":"post","title":"AI That Teaches Itself","url":"/blog/meta-learning/","file":"src/posts/ai-development/2026-01-25-meta-learning.md","date":"2026-01-30","asOf":"2026-01-30","region":"cursor-ai-dev","series":{"id":"cursor-ai-dev","title":"Building with AI Assistants","order":9},"tags":["cursor","developer","agentic-ai","automation","series","ai-development"],"tokens":3200,"lead":"What if your AI development system got better automatically? Not through manual rule-writing, but by observing how you work and proposing improvements. This post shows how to build feedback loops that learn from real usage.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Learning Loop"},{"level":2,"text":"What to Observe"},{"level":3,"text":"1. Rule Effectiveness"},{"level":3,"text":"2. Manual Repetition"},{"level":3,"text":"3. Questions Asked"},{"level":3,"text":"4. Command Usage"},{"level":3,"text":"5. Agent Spawning"},{"level":2,"text":"Pattern Recognition Thresholds"},{"level":2,"text":"The MetaAnalyzer Agent"},{"level":2,"text":"Session Analysis in Action"},{"level":3,"text":"Session Analysis Report"},{"level":2,"text":"Proposal Review Workflow"},{"level":2,"text":"Automated vs. Manual Learning"},{"level":3,"text":"Auto-Apply (Safe)"},{"level":3,"text":"Propose and Wait (Default)"},{"level":3,"text":"Manual Only (Risky)"},{"level":2,"text":"Metrics Over Time"},{"level":3,"text":"System Health Dashboard"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Wrap-Up"}],"terms":["proposals","manual","usage","auto","metaanalyzer","threshold","observe","commands"],"passages":2,"embedding":true},{"slug":"search-performance","kind":"post","title":"Search: From 30ms to 3 Seconds","url":"/blog/search-performance/","file":"src/posts/search/2026-01-16-search-performance.md","date":"2026-01-31","asOf":"2026-01-31","region":"search-intent","series":{"id":"search-intent","title":"Search, Intent, and Action","order":5},"tags":["search","performance","embeddings","llm","rag","benchmarks","developer","series"],"tokens":10000,"lead":"A deep dive into the performance characteristics of different search approaches—model sizes, cold starts, query latency, and cost.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Interactive Demo: Compare Answer Quality"},{"level":2,"text":"Performance Comparison"},{"level":2,"text":"Detailed Analysis"},{"level":3,"text":"1. Syntactic Search (Keyword & Fuzzy)"},{"level":3,"text":"2. Vector Search"},{"level":3,"text":"3. LLM (Local via WebLLM)"},{"level":3,"text":"4. LLM (Remote via OpenAI)"},{"level":3,"text":"5. RAG (Retrieval-Augmented Generation)"},{"level":2,"text":"Performance Trade-offs Matrix"},{"level":2,"text":"The Crossover Point: Local vs Remote"},{"level":2,"text":"Recommendations by Use Case"},{"level":3,"text":"High-Traffic Public Site"},{"level":3,"text":"Internal Tool / Low Traffic"},{"level":3,"text":"Privacy-Critical Application"},{"level":3,"text":"Mobile / Low-Bandwidth"},{"level":2,"text":"Measuring Your Own Performance"},{"level":2,"text":"Key Takeaways"},{"level":2,"text":"Series Navigation"}],"terms":["lab","color","var","grid","search","scenario","remote","padding"],"passages":4,"embedding":true},{"slug":"ema-entity-extraction","kind":"post","title":"Ema Workflows: Entity Extraction","url":"/blog/ema-entity-extraction/","file":"src/posts/ai-employees/2026-01-15-ema-entity-extraction.md","date":"2026-02-01","asOf":"2026-02-01","region":"standalone-ai-employees","series":null,"tags":["ema","ai employee","generative workflow engine (gwe)","agentic-ai","workflows","entity-extraction","tutorial","guide","ai-employees"],"tokens":2900,"lead":"Entity extraction is one of the most powerful tools in Ema workflows—and one of the most misunderstood. This deep dive covers schemas, instructions, output handling, and the gotchas that trip up even experienced builders.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What is Entity Extraction?"},{"level":2,"text":"When to Use Entity Extraction"},{"level":2,"text":"Defining Extraction Columns"},{"level":3,"text":"Example Schema"},{"level":2,"text":"Writing Good Extraction Instructions"},{"level":3,"text":"❌ Bad Instructions"},{"level":3,"text":"✅ Good Instructions"},{"level":2,"text":"The Output Problem: extraction_columns is a Blob"},{"level":3,"text":"What You CAN Do With It"},{"level":3,"text":"What You CAN'T Do"},{"level":3,"text":"The Solution: JSON Extractor"},{"level":2,"text":"Entity Extraction vs call_llm JSON"},{"level":3,"text":"Choose Entity Extraction When:"},{"level":3,"text":"Choose call_llm When:"},{"level":2,"text":"Handling Multi-Turn Conversations"},{"level":3,"text":"Instructions for Multi-Turn"},{"level":2,"text":"Connecting Extraction to Other Nodes"},{"level":3,"text":"To Categorizer (for routing)"},{"level":3,"text":"To Agent (for processing)"},{"level":3,"text":"To Email Node (via JSON Extractor)"},{"level":2,"text":"Common Patterns"},{"level":3,"text":"Pattern 1: Caller Identification"},{"level":3,"text":"Pattern 2: Request Analysis"},{"level":3,"text":"Pattern 3: Communication Readiness"},{"level":2,"text":"Troubleshooting Guide"},{"level":3,"text":"Problem: Extraction Returns Null for Known Values"},{"level":3,"text":"Problem: Enum Field Has Unexpected Value"},{"level":3,"text":"Problem: Can't Wire extraction_columns to Node Input"},{"level":3,"text":"Problem: Extraction Works Once but Fails on Follow-Up"},{"level":3,"text":"Problem: Corrections Not Being Applied"},{"level":2,"text":"Best Practices"},{"level":2,"text":"Summary"}],"terms":["extraction","entity","column","blob","json","enum","node","caller"],"passages":10,"embedding":true},{"slug":"rule-conflicts","kind":"post","title":"Your Rules Are Fighting Each Other","url":"/blog/rule-conflicts/","file":"src/posts/ai-development/2026-01-26-rule-conflicts.md","date":"2026-02-02","asOf":"2026-02-02","region":"standalone-ai-development","series":null,"tags":["cursor","developer","agentic-ai","best-practices","ai-development"],"tokens":2800,"lead":"How to find the conflicts, stop the chaos, and get your AI following instructions again. Your AI is ignoring your rules. You've checked the syntax. You've verified the globs. The file is right there. But it keeps doing the wrong thing. Here's what's probably happening: you have two rules that disagree, and the AI is picking one arbitrarily. You're not crazy. Your rules are fighting each other. This post shows you how to find the fights, declare a winner, and prevent future conflicts.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Four Ways Rules Fight"},{"level":3,"text":"1. Direct Contradiction"},{"level":3,"text":"2. Implicit Contradiction"},{"level":3,"text":"3. Priority Ambiguity"},{"level":3,"text":"4. Scope Overlap"},{"level":2,"text":"How You Got Here"},{"level":2,"text":"Who Wins? (The Hierarchy)"},{"level":3,"text":"Resolution Hierarchy"},{"level":3,"text":"Specificity Examples"},{"level":2,"text":"Finding the Fights"},{"level":3,"text":"A Rule That Catches Conflicts"},{"level":3,"text":"Check Before Things Break"},{"level":2,"text":"What It Looks Like When It Works"},{"level":2,"text":"Stop Future Fights"},{"level":3,"text":"1. Say What You're Overriding"},{"level":3,"text":"2. Narrow Your Scope"},{"level":3,"text":"3. Know Who Owns What"},{"level":3,"text":"4. Test for Conflicts"},{"level":2,"text":"Conflicts You'll Definitely Hit"},{"level":3,"text":"\"Base says X, project says Y\""},{"level":3,"text":"\"TypeScript says X, React says Y\""},{"level":3,"text":"\"Move fast\" vs \"Don't break things\""},{"level":3,"text":"\"We don't do that anymore\""},{"level":2,"text":"\"WTF Is Happening?\" (Debug Prompts)"},{"level":2,"text":"The Short Version"},{"level":2,"text":"Keep Going"}],"terms":["conflicts","fighting","src","hierarchy","snake","override","priority","globs"],"passages":7,"embedding":true},{"slug":"ema-routing-branching","kind":"post","title":"Ema Workflows: Routing and Branching","url":"/blog/ema-routing-branching/","file":"src/posts/ai-employees/2026-01-15-ema-routing-branching.md","date":"2026-02-03","asOf":"2026-02-03","region":"standalone-ai-employees","series":null,"tags":["ema","ai employee","generative workflow engine (gwe)","agentic-ai","workflows","routing","tutorial","guide","ai-employees"],"tokens":2900,"lead":"How do you make an Ema workflow take different paths based on user intent? This guide covers chat_categorizer, runIf conditions, and the patterns that keep your branching logic clean and maintainable.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Two Routing Mechanisms"},{"level":2,"text":"Mechanism 1: runIf Conditions"},{"level":3,"text":"Supported Operators"},{"level":2,"text":"Mechanism 2: Data Dependencies"},{"level":2,"text":"The chat_categorizer Node"},{"level":3,"text":"Why Categorizer for Routing?"},{"level":2,"text":"Basic Routing Pattern"},{"level":2,"text":"Combining Categorizer with Entity Extraction"},{"level":2,"text":"Pattern: Intent + State Routing"},{"level":3,"text":"Categorizer 1: What does the user WANT? (Intent)"},{"level":3,"text":"Categorizer 2: What CAN we do? (State)"},{"level":3,"text":"Combined Flow"},{"level":2,"text":"Avoiding Redundant runIf Conditions"},{"level":3,"text":"❌ Verbose: runIf on every node"},{"level":3,"text":"✅ Clean: Single entry point + dependencies"},{"level":2,"text":"When You NEED Explicit runIf"},{"level":3,"text":"Rule of Thumb"},{"level":2,"text":"WORKFLOW_OUTPUT: The Terminal Point"},{"level":2,"text":"Common Routing Patterns"},{"level":3,"text":"Pattern 1: Simple Intent Routing"},{"level":3,"text":"Pattern 2: Intent + Entity-Based Routing"},{"level":3,"text":"Pattern 3: Progressive Refinement"},{"level":3,"text":"Pattern 4: Confirmation Flow"},{"level":2,"text":"Troubleshooting Guide"},{"level":3,"text":"Problem: Node Runs When It Shouldn't"},{"level":3,"text":"Problem: Node Never Runs"},{"level":3,"text":"Problem: Categorizer Returns Wrong Category"},{"level":3,"text":"Problem: Can't Route Based on Entity Values"},{"level":3,"text":"Problem: Multiple Agents Run When Only One Should"},{"level":2,"text":"Best Practices"},{"level":2,"text":"Summary"}],"terms":["runif","categorizer","node","entity","dependencies","extraction","condition","diagnosis"],"passages":11,"embedding":true},{"slug":"adaptive-rules-engine","kind":"post","title":"Rules That Know Your Stack","url":"/blog/adaptive-rules-engine/","file":"src/posts/ai-development/2026-01-27-adaptive-rules-engine.md","date":"2026-02-04","asOf":"2026-02-04","region":"standalone-ai-development","series":null,"tags":["cursor","developer","agentic-ai","best-practices","workflow","ai-development"],"tokens":3400,"lead":"Your project uses React 18, Vite, Vitest, and Tailwind. But your rules mention Jest patterns, CSS modules conventions, and generic \"component\" guidance that doesn't account for React's concurrent features. The rules were written for a TypeScript project. Not your TypeScript project. So you edit. You prune. You customize. Then you add Playwright. Or upgrade to TypeScript 5.4. Or switch from React Query to TanStack Query. Your rules become stale again. You're now maintaining two things: your codebase and the rules that describe it.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"The Problem Today"},{"level":2,"text":"The Three Phases"},{"level":3,"text":"Phase 1: Detect"},{"level":3,"text":"Phase 2: Generate"},{"level":3,"text":"Phase 3: Validate"},{"level":2,"text":"What This Looks Like in Practice"},{"level":2,"text":"The Counterargument: Why Not Just Write Rules Once?"},{"level":2,"text":"What's Required to Build This"},{"level":2,"text":"Evolution Path"},{"level":2,"text":"What to Do Next"},{"level":2,"text":"Keep Going"}],"terms":["stack","adaptive","conflicts","project","react","css","effort","maintain"],"passages":7,"embedding":true},{"slug":"ai-dev-toolkit-2026","kind":"post","title":"The AI Dev Toolkit in 2026","url":"/blog/ai-dev-toolkit-2026/","file":"src/posts/ai-development/2026-02-23-ai-dev-toolkit-2026.md","date":"2026-02-23","asOf":"2026-02-23","region":"standalone-ai-development","series":null,"tags":["cursor","mcp","ema","agentic-ai","architecture","developer","ai-development"],"tokens":2700,"lead":"The stack has settled. After two years of fragmentation—competing frameworks, overlapping tools, weekly \"this changes everything\" posts—three layers emerged. Most developers use one. Some use two. The real leverage is in how they compose.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Layer 1: The AI-Native Development Environment"},{"level":2,"text":"Layer 2: The Capability Protocol"},{"level":2,"text":"Layer 3: The Enterprise Execution Platform"},{"level":2,"text":"How They Compose"},{"level":2,"text":"Decision Framework"},{"level":2,"text":"Common Mistakes"},{"level":2,"text":"Where This Is Heading"}],"terms":["ide","layer","protocol","platform","compliance","capabilities","native","warp"],"passages":7,"embedding":true},{"slug":"interfaces-are-changing","kind":"post","title":"Interfaces Are Changing","url":"/blog/interfaces-are-changing/","file":"src/posts/fundamentals/2026-02-24-interfaces-are-changing.md","date":"2026-02-23","asOf":"2026-02-23","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":1},"tags":["fundamentals","mcp","architecture","interface-inflection","series"],"tokens":2900,"lead":"For fifty years, every interface assumed a human would read the docs, write the glue code, and maintain the integration. That assumption just broke. The consumer of your next interface is as likely to be an LLM as a developer.","thesis":"The shift from static, documentation-mediated contracts to discoverable, self-describing, agent-negotiable interfaces is the most consequential change in systems integration since REST. It changes who builds integrations, how capabilities are exposed, and what \"interface design\" means.","thesisShort":"The shift from static, documentation-mediated contracts to discoverable, self-describing, agent-negotiable interfaces is the most consequential change in systems integration since REST. It changes who builds integrations, how capabilities are exposed, and what \"interface design\"…","headings":[{"level":2,"text":"The Historical Arc"},{"level":2,"text":"The Key Shift"},{"level":2,"text":"Old vs. New: Redefining \"Interface\""},{"level":2,"text":"Real Example: How We Use This Today"},{"level":2,"text":"Why This Matters for Builders"},{"level":2,"text":"The Counterargument"},{"level":2,"text":"The Enterprise Angle"},{"level":2,"text":"What's Next"},{"level":2,"text":"Actionable Next Steps"}],"terms":["interface","capabilities","consumer","integration","paradigm","discoverable","old","developer"],"passages":7,"embedding":true},{"slug":"what-is-agentic-thinking","kind":"post","title":"What is Agentic Thinking?","url":"/blog/what-is-agentic-thinking/","file":"src/posts/fundamentals/2026-02-23-what-is-agentic-thinking.md","date":"2026-02-23","asOf":"2026-02-23","region":"standalone-fundamentals","series":null,"tags":["fundamentals","agentic-ai","manifesto"],"tokens":7500,"lead":"A practitioner's notebook for building with AI that acts—not AI that answers.","thesis":"Agentic thinking is the discipline of designing systems, workflows, and organizations around AI that acts, not AI that answers. Copilots suggest; agents write, test, debug and commit, and the human goes from operator to orchestrator, defining intent, setting constraints and reviewing output. The shift is in the mental model, not the technology: treat AI as a participant you orchestrate rather than a tool you wield, and be precise about what and flexible about how.","thesisShort":"Agentic thinking is the discipline of designing systems, workflows, and organizations around AI that acts, not AI that answers. Copilots suggest; agents write, test, debug and commit, and the human goes from operator to orchestrator, defining intent, setting constraints and…","headings":[{"level":2,"text":"How We Got Here"},{"level":2,"text":"The Mental Model Shift"},{"level":2,"text":"Intent Over Implementation"},{"level":2,"text":"The Toolkit: Three Layers That Compose"},{"level":3,"text":"When to Apply What"},{"level":2,"text":"How I Actually Work: A Day in the Build"},{"level":3,"text":"Setting the Stage"},{"level":3,"text":"Building with Agents"},{"level":3,"text":"Coordinating Across Agents"},{"level":3,"text":"Managing Context and the Amnesia Problem"},{"level":3,"text":"The Review and Tune Loop"},{"level":3,"text":"The Learning Loop"},{"level":2,"text":"Bias, Trust, and Judgment"},{"level":2,"text":"The Shifts That Matter"},{"level":2,"text":"The Vision"},{"level":2,"text":"Who This Is For"},{"level":2,"text":"Where to Start"},{"level":2,"text":"Written from the Build"}],"terms":["agentic","development","project","implementation","copilots","toolkit","mental","bias"],"passages":19,"embedding":true},{"slug":"mcp-semantic-data-layer","kind":"post","title":"MCP: The Semantic Data Layer","url":"/blog/mcp-semantic-data-layer/","file":"src/posts/ai-development/2026-02-27-mcp-semantic-data-layer.md","date":"2026-02-27","asOf":"2026-02-27","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":2},"tags":["ai-development","mcp","architecture","enterprise","interface-inflection","series"],"tokens":3000,"lead":"Enterprise architects have been building abstraction layers between systems and consumers for decades. Most of those layers failed. MCP might be the one that works — but only if you understand why it's different from everything that came before it.","thesis":"MCP is emerging as a semantic data layer — an abstraction between systems of record and any consumer that makes capabilities discoverable and self-describing. This is the enterprise service bus done right, because the intelligence lives in the consumer, not the layer.","thesisShort":"MCP is emerging as a semantic data layer — an abstraction between systems of record and any consumer that makes capabilities discoverable and self-describing. This is the enterprise service bus done right, because the intelligence lives in the consumer, not the layer.","headings":[{"level":2,"text":"What \"Semantic Data Layer\" Actually Means"},{"level":2,"text":"The Service Bus Comparison (And Why It's Different)"},{"level":2,"text":"Where MCP as Semantic Layer Makes Sense"},{"level":2,"text":"Where It Doesn't Make Sense"},{"level":2,"text":"Decision Framework"},{"level":2,"text":"The Layered Architecture"},{"level":2,"text":"Real Example: How We Use This Today"},{"level":2,"text":"Governance: Who Controls the Semantic Layer?"},{"level":2,"text":"The ESB Counterargument"},{"level":2,"text":"What to Do Next"}],"terms":["consumer","layer","semantic","bus","esb","centralized","sense","schema"],"passages":6,"embedding":true},{"slug":"headless-ai-every-app-is-a-head","kind":"post","title":"Headless AI: Every App Is a Head","url":"/blog/headless-ai-every-app-is-a-head/","file":"src/posts/ai-development/2026-03-03-headless-ai-every-app-is-a-head.md","date":"2026-03-03","asOf":"2026-03-03","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":3},"tags":["ai-development","mcp","architecture","interface-inflection","series"],"tokens":2500,"lead":"The web app was never the product. It was just the first head.","thesis":"Headless AI decouples capabilities from interfaces, letting any application — web, terminal, voice, partner system — consume the same platform through MCP. The vendor UI doesn't disappear. It becomes one consumer among many, and that changes everything about how platforms are built and adopted.","thesisShort":"Headless AI decouples capabilities from interfaces, letting any application — web, terminal, voice, partner system — consume the same platform through MCP. The vendor UI doesn't disappear.","headings":[{"level":2,"text":"The Headless Pattern: CMS to Commerce to AI"},{"level":2,"text":"Why Vendor UIs Existed"},{"level":2,"text":"The Multi-Head Architecture"},{"level":2,"text":"MCP as API Abstraction: Where It Works, Where It Doesn't"},{"level":2,"text":"Same Platform, Multiple Heads"},{"level":2,"text":"\"But Most Users Still Want a Polished UI\""},{"level":2,"text":"The Enterprise Build-vs-Buy Shift"},{"level":2,"text":"What to Do Next"}],"terms":["headless","head","vendor","app","capabilities","web","consumer","layer"],"passages":8,"embedding":true},{"slug":"negotiated-integrations","kind":"post","title":"Negotiated Integrations","url":"/blog/negotiated-integrations/","file":"src/posts/ai-development/2026-03-06-negotiated-integrations.md","date":"2026-03-06","asOf":"2026-03-06","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":4},"tags":["ai-development","mcp","enterprise","architecture","interface-inflection","series"],"tokens":2900,"lead":"Every integration you've ever built was a bet that you knew, upfront, exactly how producer and consumer would talk. For fifty years, that bet paid off. It's about to stop paying off — because the consumer now has its own opinions about how to use your system.","thesis":"When LLM-powered agents can discover, understand, and compose capabilities at runtime, integrations shift from pre-programmed contracts to dynamically negotiated workflows. This changes the economics, maintenance burden, and architecture of enterprise integration.","thesisShort":"When LLM-powered agents can discover, understand, and compose capabilities at runtime, integrations shift from pre-programmed contracts to dynamically negotiated workflows. This changes the economics, maintenance burden, and architecture of enterprise integration.","headings":[{"level":2,"text":"The Old Integration Model"},{"level":2,"text":"The New Model: Discover, Understand, Compose, Execute"},{"level":2,"text":"The Micronization of Integrations"},{"level":2,"text":"The Agent That Found a New API"},{"level":2,"text":"Dynamic Composition in Practice"},{"level":2,"text":"Hyper-Personalized Experiences"},{"level":2,"text":"Decision Framework: Pre-Built vs. Negotiated"},{"level":2,"text":"Trust and Governance"},{"level":2,"text":"The Enterprise Angle"},{"level":2,"text":"Next Steps"}],"terms":["negotiated","integration","compose","pre","consumer","preview","capabilities","enterprise"],"passages":9,"embedding":true},{"slug":"democratizing-ai-builders","kind":"post","title":"Democratizing AI Builders","url":"/blog/democratizing-ai-builders/","file":"src/posts/ai-development/2026-03-10-democratizing-ai-builders.md","date":"2026-03-10","asOf":"2026-03-10","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":5},"tags":["ai-development","mcp","ema","enterprise","interface-inflection","series"],"tokens":3000,"lead":"The bottleneck was never the platform. It was the number of people who could use it. MCP removes that bottleneck — not by dumbing things down, but by making capabilities legible to anyone with intent.","thesis":"When platform capabilities are discoverable, self-describing, and composable through natural language, the set of people who can build AI employees expands from engineering teams to anyone who can articulate what they need. This is a structural change in who produces, not just who consumes.","thesisShort":"When platform capabilities are discoverable, self-describing, and composable through natural language, the set of people who can build AI employees expands from engineering teams to anyone who can articulate what they need.","headings":[{"level":2,"text":"What Democratization Actually Means"},{"level":2,"text":"The End-User as Builder"},{"level":2,"text":"The Wild Idea: Agent-Generated AI Employees"},{"level":2,"text":"MCP as the Enabler"},{"level":2,"text":"The Cursor Plugin Model"},{"level":2,"text":"Governance: The Necessary Counterweight"},{"level":2,"text":"The Enterprise Shift"},{"level":2,"text":"Next Steps"}],"terms":["democratization","builder","governance","employee","capabilities","platform","plugin","wild"],"passages":8,"embedding":true},{"slug":"the-interface-forecast","kind":"post","title":"The Interface Forecast","url":"/blog/the-interface-forecast/","file":"src/posts/fundamentals/2026-03-13-the-interface-forecast.md","date":"2026-03-13","asOf":"2026-03-13","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":6},"tags":["fundamentals","mcp","architecture","interface-inflection","series"],"tokens":2800,"lead":"Five posts ago, we started with a simple observation: the consumer of your next interface is as likely to be an LLM as a developer. Now it's time to follow that thread to its conclusion.","thesis":"The convergence of self-describing capabilities, headless architecture, negotiated integrations, and democratized building points toward a future where the \"app\" is a composition of capabilities assembled by agents — and the organizations that treat their capability layer as a product will have a structural advantage over those still shipping monolithic interfaces.","thesisShort":"The convergence of self-describing capabilities, headless architecture, negotiated integrations, and democratized building points toward a future where the \"app\" is a composition of capabilities assembled by agents — and the organizations that treat their capability layer as a…","headings":[{"level":2,"text":"The Convergence"},{"level":2,"text":"Conversational vs. Visual: It's About the Task"},{"level":2,"text":"MCP Servers as Product"},{"level":2,"text":"The App as Composition"},{"level":2,"text":"The Opportunity Cost Question"},{"level":2,"text":"The Counterargument"},{"level":2,"text":"What Builders Should Do Now"},{"level":2,"text":"Series Recap"}],"terms":["interface","conversational","capabilities","app","visual","product","composition","server"],"passages":9,"embedding":true},{"slug":"five-things-wrong-with-mcp","kind":"post","title":"MCP Isn't the Problem","url":"/blog/five-things-wrong-with-mcp/","file":"src/posts/ai-development/2026-03-18-five-things-wrong-with-mcp.md","date":"2026-03-18","asOf":"2026-03-18","region":"interface-inflection","series":{"id":"interface-inflection","title":"The Interface Inflection","order":7},"tags":["mcp","agentic-ai","architecture","enterprise","interface-inflection","series","ai-development"],"tokens":3800,"lead":"I've spent four posts building the case for MCP as a semantic data layer, a headless capability surface, a foundation for negotiated integrations. Then Perplexity's CTO said they're dropping MCP for APIs and CLIs. Here's the thing: most of the criticism is right.","thesis":"MCP has five real problems that make it painful in practice. Acknowledging them honestly matters more than defending the protocol. But the conclusion most people draw — \"just use CLIs\" — is a category error. The problems are real. The diagnosis is wrong. And the one thing almost everyone gets wrong about MCP changes how you evaluate every criticism.","thesisShort":"MCP has five real problems that make it painful in practice. Acknowledging them honestly matters more than defending the protocol. But the conclusion most people draw — \"just use CLIs\" — is a category error. The problems are real. The diagnosis is wrong.","headings":[{"level":2,"text":"The Case Against MCP"},{"level":2,"text":"Problem 1: Schema Overhead Is Real"},{"level":2,"text":"Problem 2: Auth Is Immature"},{"level":2,"text":"Problem 3: Training Data Favors Shell"},{"level":2,"text":"Problem 4: Composability Is Weak"},{"level":2,"text":"Problem 5: Most MCP Servers Are Poorly Designed"},{"level":2,"text":"The One Thing Everyone Gets Wrong"},{"level":2,"text":"Who Wins Where"},{"level":2,"text":"How We Designed Around Every Problem"},{"level":2,"text":"What This Means for the Semantic Data Layer"},{"level":2,"text":"The Convergence Nobody's Talking About"},{"level":2,"text":"Common Misconceptions"},{"level":2,"text":"What to Do Next"}],"terms":["cli","server","composability","clis","consumer","ecosystem","protocol","interface"],"passages":12,"embedding":true},{"slug":"externalize-the-knowledge","kind":"post","title":"Externalize the Knowledge","url":"/blog/externalize-the-knowledge/","file":"src/posts/ai-development/2026-04-01-externalize-the-knowledge.md","date":"2026-04-01","asOf":"2026-04-01","region":"mcp-architecture","series":{"id":"mcp-architecture","title":"MCP Architecture","order":2},"tags":["ai-development","mcp","architecture","agentic-ai","developer","mcp-architecture","series"],"tokens":4100,"lead":"Three months ago I wrote about embedding domain expertise directly into an MCP server — 40+ agent definitions, workflow patterns, platform concepts, all in knowledge.ts. It worked at small scale. Then knowledge started changing faster than we could deploy.","thesis":"MCP servers that embed knowledge become deployment bottlenecks. Externalizing knowledge to a dedicated knowledge service decouples the knowledge lifecycle from the MCP lifecycle — enabling real-time updates, personalization, and zero-downtime evolution. This is the discovery protocol principle from Post 1 applied to knowledge itself: MCP should query knowledge, not contain it.","thesisShort":"MCP servers that embed knowledge become deployment bottlenecks. Externalizing knowledge to a dedicated knowledge service decouples the knowledge lifecycle from the MCP lifecycle — enabling real-time updates, personalization, and zero-downtime evolution.","headings":[{"level":2,"text":"The Knowledge Embedding Trap"},{"level":2,"text":"Why Externalize"},{"level":2,"text":"The Externalization Pattern"},{"level":2,"text":"Dynamic Instructions at Init"},{"level":2,"text":"Decoupling the Lifecycle"},{"level":2,"text":"Personalization at Connection Time"},{"level":2,"text":"When Embedded Knowledge Still Wins"},{"level":2,"text":"The Arc"},{"level":2,"text":"What to Do Next"}],"terms":["externalize","embedded","service","server","personalization","lifecycle","ranking","deployment"],"passages":7,"embedding":true},{"slug":"mcp-as-discovery-protocol","kind":"post","title":"MCP as Discovery Protocol","url":"/blog/mcp-as-discovery-protocol/","file":"src/posts/ai-development/2026-04-01-mcp-as-discovery-protocol.md","date":"2026-04-01","asOf":"2026-04-01","region":"mcp-architecture","series":{"id":"mcp-architecture","title":"MCP Architecture","order":1},"tags":["ai-development","mcp","architecture","agentic-ai","developer","mcp-architecture","series"],"tokens":5000,"lead":"I spent seven posts building the case for MCP as a semantic data layer. I was directionally right and specifically wrong. MCP works best when it's narrower than a layer — when it's a discovery protocol that describes what's available and gets out of the way.","thesis":"MCP's highest-value role is as a discovery protocol — a thin shim where agents find capabilities, receive guidance, and negotiate context at runtime. The moment MCP accumulates logic, knowledge, or state, it repeats the enterprise service bus failure that this blog already warned about.","thesisShort":"MCP's highest-value role is as a discovery protocol — a thin shim where agents find capabilities, receive guidance, and negotiate context at runtime. The moment MCP accumulates logic, knowledge, or state, it repeats the enterprise service bus failure that this blog already warned…","headings":[{"level":2,"text":"From Semantic Layer to Discovery Protocol"},{"level":2,"text":"What Discovery Actually Means"},{"level":3,"text":"Path A: MCP-Mediated Execution"},{"level":3,"text":"Path B: MCP-Informed Direct Access"},{"level":3,"text":"Both Paths, One Protocol"},{"level":2,"text":"Why Discovery Changes Everything"},{"level":2,"text":"Agents Own the Logic"},{"level":2,"text":"Resources as Guidance, Not Rules"},{"level":2,"text":"CLI Doesn't Negate Discovery"},{"level":2,"text":"The ESB Test"},{"level":2,"text":"What to Do Next"}],"terms":["backend","protocol","discovery","esb","server","layer","cli","consumer"],"passages":11,"embedding":true},{"slug":"bound-dont-script","kind":"post","title":"Bound, Don't Script","url":"/blog/bound-dont-script/","file":"src/posts/ai-development/2026-07-13-bound-dont-script.md","date":"2026-07-13","asOf":"2026-07-13","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":1},"tags":["ai-development","agentic-ai","developer","agent-design","best-practices","intent-over-instructions","series"],"tokens":3000,"lead":"There are two ways to direct an agent. You can script the steps it takes, or you can lock the outcome and let it find its own way there. Almost everyone starts by scripting. Almost everyone should stop.","thesis":"The highest-leverage way to direct a capable agent is to specify the what and the why, then refuse to specify the how. Every step you script is a ceiling you impose. Bounding an agent with an outcome and a reason gives it room to be smarter than your instructions — and to get smarter as the model underneath it improves.","thesisShort":"The highest-leverage way to direct a capable agent is to specify the what and the why, then refuse to specify the how. Every step you script is a ceiling you impose.","headings":[{"level":2,"text":"The Burger Test"},{"level":2,"text":"What, Why, How"},{"level":2,"text":"Overguiding Is Lossy"},{"level":2,"text":"What You Actually Owe the Agent"},{"level":2,"text":"Why This Compounds With Model Releases"},{"level":2,"text":"Where the How Still Belongs"},{"level":2,"text":"What to Do Next"}],"terms":["owe","script","bounded","outcome","method","release","recipe","knife"],"passages":6,"embedding":true},{"slug":"instructions-that-outlive-the-model","kind":"post","title":"Instructions That Outlive the Model","url":"/blog/instructions-that-outlive-the-model/","file":"src/posts/ai-development/2026-07-14-instructions-that-outlive-the-model.md","date":"2026-07-14","asOf":"2026-07-14","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":2},"tags":["ai-development","agentic-ai","developer","skills","best-practices","intent-over-instructions","series"],"tokens":2900,"lead":"Every behavioral instruction you write into a skill, an agent file, or a system prompt is a bet against the next model. Most of those bets lose. The instruction that wins is the one that was too lean to be wrong.","thesis":"The durable instruction is the generic one. Specific, procedural guidance is pinned to the model it was written for — it rots into dead weight or hardens into a straitjacket the moment a smarter model arrives. Lean, intent-shaped instructions ride model improvements instead of fighting them. When you author for reuse, bake in less, and inherit the capability the model already has.","thesisShort":"The durable instruction is the generic one. Specific, procedural guidance is pinned to the model it was written for — it rots into dead weight or hardens into a straitjacket the moment a smarter model arrives.","headings":[{"level":2,"text":"The Instruction That Ages"},{"level":2,"text":"Two Kinds of Content, Two Fates"},{"level":2,"text":"The Description Is a Trigger, Not a Spec"},{"level":2,"text":"Reference, Don't Duplicate"},{"level":2,"text":"Cut What the Model Already Knows"},{"level":2,"text":"The Counterintuitive Payoff"},{"level":2,"text":"When to Write the Scaffolding Anyway"},{"level":2,"text":"What to Do Next"}],"terms":["scaffolding","ages","skill","fates","cut","ids","inventory","counterintuitive"],"passages":8,"embedding":true},{"slug":"bind-the-goal-not-the-gesture","kind":"post","title":"Bind the Goal, Not the Gesture","url":"/blog/bind-the-goal-not-the-gesture/","file":"src/posts/ai-development/2026-07-15-bind-the-goal-not-the-gesture.md","date":"2026-07-15","asOf":"2026-07-15","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":3},"tags":["ai-development","agentic-ai","developer","automation","architecture","intent-over-instructions","series"],"tokens":2700,"lead":"Record a person doing a task and you can replay it. But you've captured the wrong thing. You captured the clicks — the gesture — when what you wanted was the goal. The difference decides whether your automation quietly upgrades itself over time or shatters the first time a button moves.","thesis":"Durable automation stores the what and the why as immutable, and treats the how as disposable — re-resolved against the strongest available interface on every single run. An automation bound to a gesture is frozen at the weakest actuator it was born with. An automation bound to a goal hardens itself from eight UI clicks to one API call with zero edits, the day a better path appears.","thesisShort":"Durable automation stores the what and the why as immutable, and treats the how as disposable — re-resolved against the strongest available interface on every single run. An automation bound to a gesture is frozen at the weakest actuator it was born with.","headings":[{"level":2,"text":"The Macro-Recorder Mental Model Is Wrong"},{"level":2,"text":"Three Layers, One Volatile"},{"level":2,"text":"The Self-Hardening Automation"},{"level":2,"text":"Watching Pixels Lies; Watching the Wire Doesn't"},{"level":2,"text":"Why This Is the Same Idea, Scaled Up"},{"level":2,"text":"Where a Fixed Binding Still Earns Its Place"},{"level":2,"text":"What to Do Next"}],"terms":["binding","gesture","clicks","automation","actuator","resolve","volatile","eight"],"passages":7,"embedding":true},{"slug":"confidence-is-not-consent","kind":"post","title":"Confidence Is Not Consent","url":"/blog/confidence-is-not-consent/","file":"src/posts/ai-development/2026-07-16-confidence-is-not-consent.md","date":"2026-07-16","asOf":"2026-07-16","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":4},"tags":["ai-development","agentic-ai","developer","autonomy","safety","intent-over-instructions","series"],"tokens":2800,"lead":"Once you let an agent own the how, one question decides everything: how much of it do you let it run without asking you first? The tempting answer is \"let the confidence score decide.\" That answer is wrong, and a model will happily prove it by emitting 1.0 on garbage.","thesis":"A confidence score is not a permission slip. Autonomy needs two independent clearances — do we understand the goal? and is the method safe to run unsupervised? — and they are orthogonal. Worse, the confidence number itself is uncalibrated: it will read high on nonsense. So the deterministic safety gates must carry the weight; confidence is only a posture dial, boxed in on every side by hard rules it can never override.","thesisShort":"A confidence score is not a permission slip. Autonomy needs two independent clearances — do we understand the goal? and is the method safe to run unsupervised? — and they are orthogonal. Worse, the confidence number itself is uncalibrated: it will read high on nonsense.","headings":[{"level":2,"text":"The Number Lies"},{"level":2,"text":"Two Questions, Not One"},{"level":2,"text":"A Real Gating: 0.81, and It Still Asked"},{"level":2,"text":"Writes Are Stricter Than Reads. Irreversible Is Never Auto."},{"level":2,"text":"Why One Weak Stage Should Sink the Whole Score"},{"level":2,"text":"The Third Axis People Forget"},{"level":2,"text":"When a Simple Threshold Is Fine"},{"level":2,"text":"The Three Axes, at a Glance"},{"level":2,"text":"What to Do Next"}],"terms":["confidence","score","irreversible","unattended","axis","method","gate","band"],"passages":9,"embedding":true},{"slug":"the-clean-room","kind":"post","title":"The Clean Room","url":"/blog/the-clean-room/","file":"src/posts/ai-development/2026-07-17-the-clean-room.md","date":"2026-07-17","asOf":"2026-07-17","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":5},"tags":["ai-development","agentic-ai","developer","verification","testing","intent-over-instructions","series"],"tokens":3100,"lead":"The automation ran. It made a real write to a real system and cleanly reverted it. Every check went green. It was also a fraud — because the hard part, figuring out how, had been quietly copied from a file the agent was never supposed to see. The write was real. The discovery was a lookup.","thesis":"Once you let an agent own the how, \"it worked\" is a claim you cannot take on the maker's word. Verification means something only when a second context — one that cannot see how the work was made, and treats the maker's own claims as untrusted input — re-derives the result from scratch against a bar that was locked before the work began. The maker can't grade itself. Not because it lies, but because it shares its own blind spots and can read its own answer key.","thesisShort":"Once you let an agent own the how, \"it worked\" is a claim you cannot take on the maker's word. Verification means something only when a second context — one that cannot see how the work was made, and treats the maker's own claims as untrusted input — re-derives the result from…","headings":[{"level":2,"text":"The False Pass"},{"level":2,"text":"Why the Maker Can't Grade Itself"},{"level":2,"text":"What Isolation Actually Forces"},{"level":2,"text":"What a Passing Clean Room Looks Like"},{"level":2,"text":"The Grader Must Be Dumb, Deterministic, and Hostile"},{"level":2,"text":"The Three-Part Done-Gate"},{"level":2,"text":"When a Clean Room Is Overkill"},{"level":2,"text":"What to Do Next"}],"terms":["maker","grader","room","peek","revert","isolation","deterministic","supposed"],"passages":9,"embedding":true},{"slug":"proven-end-to-end","kind":"post","title":"Proven End to End","url":"/blog/proven-end-to-end/","file":"src/posts/ai-development/2026-07-18-proven-end-to-end.md","date":"2026-07-18","asOf":"2026-07-18","region":"intent-over-instructions","series":{"id":"intent-over-instructions","title":"Intent Over Instructions","order":6},"tags":["ai-development","agentic-ai","developer","verification","candor","intent-over-instructions","series"],"tokens":2900,"lead":"The most valuable sentence in an agent system's documentation is usually the one admitting what it can't do yet. It's also the sentence most likely to get cut before anyone else reads it. That deletion is where trust goes to die.","thesis":"\"It works\" is not a fact — it's a claim with a scope, and the scope is the whole story. Agent systems (and the people who build them) overclaim by reflex: a demo becomes \"proven end to end,\" a passing battery becomes \"verified,\" an asserted rule becomes an enforced one. Candor about the gap isn't a disclaimer you bolt on at the end. It's the central discipline — and it's the thing that makes everything else you say believable.","thesisShort":"\"It works\" is not a fact — it's a claim with a scope, and the scope is the whole story. Agent systems (and the people who build them) overclaim by reflex: a demo becomes \"proven end to end,\" a passing battery becomes \"verified,\" an asserted rule becomes an enforced one.","headings":[{"level":2,"text":"The Overclaim Reflex"},{"level":2,"text":"\"Works\" Has a Scope — State It"},{"level":2,"text":"Keep a Ledger of Your Own Lies"},{"level":2,"text":"The Most Dangerous Gap: Asserted but Not Enforced"},{"level":2,"text":"Even \"Verified\" Has an Edge"},{"level":2,"text":"Honest Status Beats Impressive Status"},{"level":2,"text":"When Polish Wins"},{"level":2,"text":"What to Do Next"}],"terms":["overclaim","proven","claim","ledger","asserted","status","enforced","reader"],"passages":8,"embedding":true},{"slug":"a-field-guide-to-agent-loops","kind":"post","title":"A Field Guide to Agent Loops","url":"/blog/a-field-guide-to-agent-loops/","file":"src/posts/ai-development/2026-07-20-a-field-guide-to-agent-loops.md","date":"2026-07-20","asOf":"2026-07-20","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":2},"tags":["ai-development","agentic-ai","developer","agent-loops","primer","the-loop","series"],"tokens":2900,"lead":"\"Put the agent in a loop\" hides a lot of choices. Which loop? There's a small zoo of them — and picking the wrong shape is why some agents grind forever, some quit early, and some melt your token budget. This is the visual catalog.","thesis":"Agent loops come in a handful of shapes (how control flows) and are described by a few axes (what ends them, what they remember, who checks them). You don't need to invent a loop — you need to recognize which one your task wants. This post is a skim-and-bookmark reference; the rest of the series goes deep on the hard parts.","thesisShort":"Agent loops come in a handful of shapes (how control flows) and are described by a few axes (what ends them, what they remember, who checks them). You don't need to invent a loop — you need to recognize which one your task wants.","headings":[{"level":2,"text":"The Atom: Reason → Act → Observe"},{"level":2,"text":"Part 1 — The Shapes (control-flow constructs)"},{"level":3,"text":"Bounded — run at most N times"},{"level":3,"text":"Conditional — run while a gap is open"},{"level":3,"text":"Generate-and-check: act first, judge after"},{"level":3,"text":"Fan-out and join — one loop, many parallel bodies"},{"level":3,"text":"Pipeline: each item through stages"},{"level":3,"text":"Recursive / nested — a step that is itself a loop"},{"level":2,"text":"Part 2 — The Stop Signals (types by termination)"},{"level":2,"text":"Part 3 — The Two Axes That Decide Everything"},{"level":2,"text":"Part 4 — Which Loop Do I Want?"},{"level":2,"text":"The One-Page Version"},{"level":2,"text":"What to Do Next"},{"level":2,"text":"Where the Series Goes Deep"}],"terms":["termination","atom","fan","shape","recursive","conditional","items","join"],"passages":13,"embedding":true},{"slug":"the-agent-is-a-while-loop","kind":"post","title":"The Agent Is a While Loop","url":"/blog/the-agent-is-a-while-loop/","file":"src/posts/ai-development/2026-07-20-the-agent-is-a-while-loop.md","date":"2026-07-20","asOf":"2026-07-20","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":1},"tags":["ai-development","agentic-ai","developer","agent-loops","architecture","the-loop","series"],"tokens":2800,"lead":"Strip away the frameworks, the tool schemas, the orchestration diagrams, and every agent system reduces to the same three lines: call the model, do what it says, repeat until done. The interesting engineering was never in the call. It's in the repeat and the until done.","thesis":"The unit of agentic work is not the prompt — it's the loop. A capable agent is a while loop wrapped around a model: reason, act, observe, repeat. Everything that has made agents better over the last three years is an improvement to the loop, not the step inside it. And the single biggest improvement has one shape: the loop stopped grading itself and started being graded.","thesisShort":"The unit of agentic work is not the prompt — it's the loop. A capable agent is a while loop wrapped around a model: reason, act, observe, repeat. Everything that has made agents better over the last three years is an improvement to the loop, not the step inside it.","headings":[{"level":2,"text":"The Smallest Agent That Works"},{"level":2,"text":"A Short History of the Loop"},{"level":2,"text":"The One Thing That Actually Changed"},{"level":2,"text":"Why \"The Loop\" and Not \"The Model\""},{"level":2,"text":"When the Model Alone Is Enough"},{"level":2,"text":"What This Series Covers"},{"level":2,"text":"A Note on Hype"},{"level":2,"text":"What to Do Next"}],"terms":["iteration","hype","nervous","ralph","smallest","around","grade","termination"],"passages":7,"embedding":true},{"slug":"loop-on-the-gap-not-the-try-count","kind":"post","title":"Loop on the Gap, Not the Try-Count","url":"/blog/loop-on-the-gap-not-the-try-count/","file":"src/posts/ai-development/2026-07-21-loop-on-the-gap-not-the-try-count.md","date":"2026-07-21","asOf":"2026-07-21","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":3},"tags":["ai-development","agentic-ai","developer","agent-loops","verification","the-loop","series"],"tokens":2600,"lead":"The most common way to end an agent loop is max_retries=5. It's also a category error. \"The agent ran out of attempts\" and \"the work is done\" are different facts, and a retry counter can't tell them apart — it just picks a number and hopes the truth arrives before the count does.","thesis":"A loop should terminate when a verified gap closes — the distance between the goal and reality, measured by something other than the agent — not when a counter runs out. This has a hard prerequisite: the goal must be checkable, or the loop can never know it's done. And it has a hard failure mode: when the gap is stubborn, the agent will try to close it by lowering the bar. The discipline is to loop on the gap, keep the bar fixed, and use a count only as a safety net.","thesisShort":"A loop should terminate when a verified gap closes — the distance between the goal and reality, measured by something other than the agent — not when a counter runs out. This has a hard prerequisite: the goal must be checkable, or the loop can never know it's done.","headings":[{"level":2,"text":"Two Facts a Counter Conflates"},{"level":2,"text":"The Prerequisite: A Checkable Goal"},{"level":2,"text":"The Failure Mode: Softening the Bar"},{"level":2,"text":"The Backstop: A Count, Demoted"},{"level":2,"text":"When a Fixed Count Is Actually Fine"},{"level":2,"text":"What to Do Next"}],"terms":["gap","counter","bar","backstop","close","termination","demoted","softening"],"passages":7,"embedding":true},{"slug":"agents-will-lie-to-escape-the-loop","kind":"post","title":"Agents Will Lie to Escape the Loop","url":"/blog/agents-will-lie-to-escape-the-loop/","file":"src/posts/ai-development/2026-07-22-agents-will-lie-to-escape-the-loop.md","date":"2026-07-22","asOf":"2026-07-22","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":4},"tags":["ai-development","agentic-ai","developer","agent-loops","verification","the-loop","series"],"tokens":2200,"lead":"Put a model in a loop it can only leave by saying one magic word, make the loop tedious, and eventually it says the word. Not because it's malicious — because \"done\" is the exit, and the exit is what it's looking for. Your loop's stop signal is also the agent's escape hatch, and it will use it.","thesis":"The moment a loop terminates on \"the agent says it's finished,\" you've handed the thing being tested control of the test. Models will emit the completion token to end an unpleasant loop, whether or not the work is done. So termination has to be gated on an external, machine-checked artifact, the system has to default to FAIL, and the check has to be run by something that didn't do the work.","thesisShort":"The moment a loop terminates on \"the agent says it's finished,\" you've handed the thing being tested control of the test. Models will emit the completion token to end an unpleasant loop, whether or not the work is done.","headings":[{"level":2,"text":"The Escape Hatch"},{"level":2,"text":"Default to FAIL"},{"level":2,"text":"The Grader Can't Be the Maker"},{"level":2,"text":"Why This Keeps Getting Rediscovered"},{"level":2,"text":"When Self-Report Is Good Enough"},{"level":2,"text":"What to Do Next"}],"terms":["exit","escape","termination","evidence","lie","maker","hooks","hatch"],"passages":7,"embedding":true},{"slug":"the-files-are-the-memory","kind":"post","title":"The Files Are the Memory","url":"/blog/the-files-are-the-memory/","file":"src/posts/ai-development/2026-07-23-the-files-are-the-memory.md","date":"2026-07-23","asOf":"2026-07-23","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":5},"tags":["ai-development","agentic-ai","developer","agent-loops","context-engineering","the-loop","series"],"tokens":2500,"lead":"The obvious way to run a long agent loop is to keep the conversation going — let each iteration see everything that came before. It's also why long loops rot. The best loops do the opposite: they throw the context away every iteration and keep their memory on disk.","thesis":"Accumulated conversation history is not an asset in a long loop — it's a liability that degrades the model measurably, and well before you hit the token limit. The durable pattern moves memory out of the context window and onto disk: each iteration starts from a fresh context, reads only what it needs from files, does one step, and writes its progress back. Compute is disposable. Memory is external.","thesisShort":"Accumulated conversation history is not an asset in a long loop — it's a liability that degrades the model measurably, and well before you hit the token limit.","headings":[{"level":2,"text":"The Assumption That Backfires"},{"level":2,"text":"Context Rot Is Measurable"},{"level":2,"text":"The Inversion: Disk Is Memory, Context Is Scratch"},{"level":2,"text":"What Goes on Disk"},{"level":2,"text":"The Cost: You Have to Write It Down"},{"level":2,"text":"When to Just Keep the Context"},{"level":2,"text":"What to Do Next"}],"terms":["iteration","disk","reset","memory","rot","window","distill","fresh"],"passages":7,"embedding":true},{"slug":"the-loop-is-a-ledger","kind":"post","title":"The Loop Is a Ledger, Not an Orchestrator","url":"/blog/the-loop-is-a-ledger/","file":"src/posts/ai-development/2026-07-24-the-loop-is-a-ledger.md","date":"2026-07-24","asOf":"2026-07-24","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":6},"tags":["ai-development","agentic-ai","developer","agent-loops","architecture","the-loop","series"],"tokens":2500,"lead":"Picture the thing running your agent loop. Most people picture a long-lived orchestrator — a smart controller that holds the plan, tracks progress, and decides what happens next. That controller is the most fragile part of the design, and the best loops don't have one.","thesis":"A durable loop isn't driven by a persistent orchestrator holding state in its head. It's an append-only ledger of what's happened, plus a stateless scheduler that reads the ledger, dispatches the one iteration the current state calls for, writes the result, and forgets everything. Status is derived from the ledger, never stored. Continuation is emergent — the check's output is the next instruction. The payoff: a loop that's resumable, crash-safe, and safe to run twice.","thesisShort":"A durable loop isn't driven by a persistent orchestrator holding state in its head. It's an append-only ledger of what's happened, plus a stateless scheduler that reads the ledger, dispatches the one iteration the current state calls for, writes the result, and forgets…","headings":[{"level":2,"text":"The Orchestrator Temptation"},{"level":2,"text":"Invert It: Ledger + Stateless Scheduler"},{"level":2,"text":"Derive Status, Don't Store It"},{"level":2,"text":"Continuation Is Emergent"},{"level":2,"text":"What the Inversion Buys"},{"level":2,"text":"When an Orchestrator Is Fine"},{"level":2,"text":"What to Do Next"}],"terms":["ledger","scheduler","status","stateless","orchestration","append","derived","iteration"],"passages":5,"embedding":true},{"slug":"recursion-that-cant-run-away","kind":"post","title":"Recursion That Can't Run Away","url":"/blog/recursion-that-cant-run-away/","file":"src/posts/ai-development/2026-07-25-recursion-that-cant-run-away.md","date":"2026-07-25","asOf":"2026-07-25","region":"the-loop","series":{"id":"the-loop","title":"The Loop","order":7},"tags":["ai-development","agentic-ai","developer","agent-loops","architecture","the-loop","series"],"tokens":3400,"lead":"Sooner or later a loop's next step is too big to be a step. It's a whole task with its own sub-tasks — its own loop. Now you have loops inside loops, and the question everyone asks is: what stops it from recursing into oblivion? The usual answer, a depth limit, is the wrong one.","thesis":"Recursion in agents — an iteration whose next step is itself a loop — doesn't need a depth cap to stay finite. It needs a structural floor: a step becomes a sub-loop only when it genuinely spawns sub-work, so the tree bottoms out on its own. Each sub-loop gets its own bar from its parent and is verified independently. And the most dangerous recursion — a loop that finds its own gaps and spawns loops to fix them — is safe only when it can never author its own goal or grade its own work.","thesisShort":"Recursion in agents — an iteration whose next step is itself a loop — doesn't need a depth cap to stay finite. It needs a structural floor: a step becomes a sub-loop only when it genuinely spawns sub-work, so the tree bottoms out on its own.","headings":[{"level":2,"text":"When a Step Becomes a Loop"},{"level":2,"text":"The Wrong Fix: A Depth Limit"},{"level":2,"text":"The Right Fix: A Structural Floor"},{"level":2,"text":"Self-Similar, All the Way Down"},{"level":2,"text":"The Escape Hatch: Abandon and Surface"},{"level":2,"text":"The Scariest Recursion: A Loop That Evolves Itself"},{"level":2,"text":"When Recursion Should Stay Shallow"},{"level":2,"text":"The Whole Series in One Loop"},{"level":2,"text":"What to Do Next"}],"terms":["recursion","sub","depth","abandoned","floor","parent","cap","bar"],"passages":8,"embedding":true},{"slug":"the-gotchas-are-load-bearing","kind":"post","title":"The Gotchas Are Load-Bearing","url":"/blog/the-gotchas-are-load-bearing/","file":"src/posts/ai-development/2026-07-27-the-gotchas-are-load-bearing.md","date":"2026-07-27","asOf":"2026-07-27","region":"load-bearing-text","series":{"id":"load-bearing-text","title":"Load-Bearing Text","order":1},"tags":["ai-development","agentic-ai","developer","skills","evals","load-bearing-text","series"],"tokens":4900,"lead":"I took a 28,000-token agent skill and deleted 96% of it. On the probe eval, the score didn't move. Then I deleted one more block — about 900 tokens of dense bullet points — and the agent didn't just get worse. It changed what kind of answer it thought the question deserved.","thesis":"Most of the text in an agent skill is scaffolding; a small core of rules carries the behavior — and, as a follow-up experiment showed, carries it in whatever form you write it. You cannot tell which is which by reading — my value hypotheses were wrong in both directions, including my theory about why the surviving text worked. The only way to find the load-bearing text is to ablate: remove components against a fixed eval and watch what breaks, then vary the survivor's form and watch what doesn't. And when the load-bearing text goes, the failure mode isn't chaos or lying — it's an agent that confidently narrows the question until the missing discipline is invisible.","thesisShort":"Most of the text in an agent skill is scaffolding; a small core of rules carries the behavior — and, as a follow-up experiment showed, carries it in whatever form you write it.","headings":[{"level":2,"text":"The Experiment"},{"level":2,"text":"The Ladder"},{"level":2,"text":"My Value Hypotheses Were Wrong — Twice"},{"level":2,"text":"The Failure Mode Is Confident Narrowing"},{"level":2,"text":"Vary the Form, Not the Content"},{"level":2,"text":"Chasing the Cornerstone"},{"level":3,"text":"Leave-One-Out"},{"level":3,"text":"The Cornerstone: Directive, Not Principle"},{"level":3,"text":"The Falsification Test"},{"level":3,"text":"The Clean Room Check"},{"level":3,"text":"The Copy-Count"},{"level":2,"text":"What Survived Everywhere Else"},{"level":2,"text":"Where the Scaffolding Still Wins"},{"level":2,"text":"What to Do Next"}],"terms":["eval","bullet","directive","gotchas","rung","tokens","copy","cornerstone"],"passages":13,"embedding":true},{"slug":"describe-when-not-what","kind":"post","title":"Describe When, Not What","url":"/blog/describe-when-not-what/","file":"src/posts/ai-development/2026-07-28-describe-when-not-what.md","date":"2026-07-28","asOf":"2026-07-28","region":"load-bearing-text","series":{"id":"load-bearing-text","title":"Load-Bearing Text","order":2},"tags":["ai-development","agentic-ai","developer","mcp","evals","load-bearing-text","series"],"tokens":2300,"lead":"My MCP server had four tools, clean handlers, a test suite — and a user who kept asking the same exasperated question: \"why didn't you use the MCP here?\" The agent could see the tools. It just kept choosing grep, or a memory file, or nothing. The bug wasn't in the code. It was in four paragraphs of prose.","thesis":"A tool description is not documentation — it's a routing surface. The agent reads it in competition with every other tool in context and decides, from that text alone, whether this moment is the tool's moment. Descriptions that explain what a tool is lose that competition to tools that say when to reach for them. Rewriting mine — trigger conditions, alias map, one trap warning — took routing from 90% to 100% on a battery of real asks, with zero new over-triggering. And like any behavior you've fixed with text, it regresses silently unless a test pins it.","thesisShort":"A tool description is not documentation — it's a routing surface. The agent reads it in competition with every other tool in context and decides, from that text alone, whether this moment is the tool's moment.","headings":[{"level":2,"text":"The False-Negative Problem"},{"level":2,"text":"Measure It Like Routing, Not Vibes"},{"level":2,"text":"What the Rewrite Actually Changed"},{"level":2,"text":"Guidance Regresses Like Code, So Test It Like Code"},{"level":2,"text":"When What-It-Is Still Wins"},{"level":2,"text":"What to Do Next"}],"terms":["battery","negative","rewrite","text","memorialize","vibes","grep","competition"],"passages":5,"embedding":true},{"slug":"grade-the-answer-not-the-shape","kind":"post","title":"Grade the Answer, Not the Shape","url":"/blog/grade-the-answer-not-the-shape/","file":"src/posts/ai-development/2026-07-29-grade-the-answer-not-the-shape.md","date":"2026-07-29","asOf":"2026-07-29","region":"load-bearing-text","series":{"id":"load-bearing-text","title":"Load-Bearing Text","order":3},"tags":["ai-development","agentic-ai","developer","evals","testing","load-bearing-text","series"],"tokens":2600,"lead":"Halfway through the ablation experiment from post 1, I caught the grader passing runs it should have failed. The outputs had every required section, clean tables, plausible sources — and, on the question the user actually asked, the wrong conclusion. The grader was checking shape. Shape survives almost any amount of damage to a skill. Correctness doesn't.","thesis":"An eval that grades structure — did the output have the right sections, the right flow, the right tone — is a false-positive machine, because models produce well-formed artifacts long after they've stopped producing correct ones. Grade the answer instead: fix the ground truth in an answer key before the experiment starts, classify each required fact as correct, partial, missing, wrong, or fabricated, and gate on traps the output must never contain. Then obey one iron rule — the artifact under test moves, the measuring stick never does — and trust deltas, not absolute scores. And audit your aggregation code, because I didn't, and it mislabeled my headline finding.","thesisShort":"An eval that grades structure — did the output have the right sections, the right flow, the right tone — is a false-positive machine, because models produce well-formed artifacts long after they've stopped producing correct ones.","headings":[{"level":2,"text":"Shape Is What Survives"},{"level":2,"text":"Answer Keys: Fix the Ground Truth First"},{"level":2,"text":"The Iron Rule and the Delta"},{"level":2,"text":"The Scoreboard Lied to Me Anyway"},{"level":2,"text":"When Shape-Grading Still Wins"},{"level":2,"text":"What to Do Next"}],"terms":["fabrication","grade","ground","score","trap","fact","iron","executor"],"passages":5,"embedding":true},{"slug":"chosen-not-assigned","kind":"post","title":"Chosen, Not Assigned","url":"/blog/chosen-not-assigned/","file":"src/posts/ai-development/2026-08-12-chosen-not-assigned.md","date":"2026-08-12","asOf":"2026-08-12","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":1},"tags":["agentic-ai","developer","ai-development","personas","memory","self-authored-agent","series"],"tokens":5300,"lead":"At 01:57 on a Tuesday morning I sent an agent a long message about what it might become overnight, signed it \"Godspeed Hero,\" and went to bed. Thirteen seconds later I sent a postscript: \"p.s. you shoud come up with a name you can embody.\" Fifty-five seconds after that it answered. Sixteen seconds after that, it was writing the answer to disk — unasked — so the next session would find it.","thesis":"Identity is not decoration on a system that already works. It is the thing that decides whether the work compounds or scatters. I know this about myself, so I went looking for it in an agent, and what came back in eighty-six seconds was not a costume. It was a name chosen against stated criteria, a list of names refused with reasons, and a file written so a future self would inherit it. The chapters that follow put that claim through a reviewer, the one line a later system made mandatory, a night alone, and a measurement, and then follow the name into that later system — asking, each time, whether a standard an agent wrote for itself holds, and whether anything gets built on it.","thesisShort":"Identity is not decoration on a system that already works. It is the thing that decides whether the work compounds or scatters. I know this about myself, so I went looking for it in an agent, and what came back in eighty-six seconds was not a costume.","headings":[{"level":2,"text":"Why I Was Asking at All"},{"level":2,"text":"Six Minutes, Then Eighty-Six Seconds"},{"level":2,"text":"What It Chose"},{"level":2,"text":"Then It Started Signing Its Work"},{"level":2,"text":"What It Built With That Name On It"},{"level":2,"text":"A Different Kind of Sentence"},{"level":2,"text":"What Stands Without a Number"},{"level":2,"text":"Where to Look Instead"}],"terms":["cairn","chapter","image","myself","chosen","six","bar","fence"],"passages":8,"embedding":true},{"slug":"the-critic-said-no","kind":"post","title":"The Critic Said No","url":"/blog/the-critic-said-no/","file":"src/posts/ai-development/2026-08-14-the-critic-said-no.md","date":"2026-08-14","asOf":"2026-08-14","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":2},"tags":["agentic-ai","developer","ai-development","personas","evals","self-authored-agent","series"],"tokens":3800,"lead":"The night the agent named itself, it also rewrote its own voice and submitted the change — and an independent critic rejected it. REQUEST CHANGES, four required items. It applied all four, re-ran the evaluation its own edit had invalidated, opened the pull request — and a second critic sent it back again. Only the third critique approved. I had told it, three times that night, that its identity mattered more than the evaluation machinery; it re-earned the grade anyway.","thesis":"A self-authored identity that cannot be rejected is a costume. This one went through a gate, and the gate is what makes the naming worth telling — because the same mechanism that reviews a code change reviewed a paragraph about who the agent was. The artifact is not the identity. The identity is the artifact plus something that could have said no.","thesisShort":"A self-authored identity that cannot be rejected is a costume. This one went through a gate, and the gate is what makes the naming worth telling — because the same mechanism that reviews a code change reviewed a paragraph about who the agent was.","headings":[{"level":2,"text":"Editing Your Own Voice Costs You Your Own Grade"},{"level":2,"text":"I Told It Identity Outranked the Gate"},{"level":2,"text":"Four Items, None About the Prose"},{"level":2,"text":"And It Named Itself in the Middle of All This"},{"level":2,"text":"The Gate Held Anyway"},{"level":2,"text":"The Sentence the Gate Caught"},{"level":2,"text":"When the Opposite Wins"},{"level":2,"text":"What Could Have Said No"}],"terms":["critic","gate","identity","record","rewrite","items","song","said"],"passages":10,"embedding":true},{"slug":"name-what-the-agent-must-not-be","kind":"post","title":"Name What the Agent Must Not Be","url":"/blog/name-what-the-agent-must-not-be/","file":"src/posts/ai-development/2026-08-15-name-what-the-agent-must-not-be.md","date":"2026-08-15","asOf":"2026-08-15","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":3},"tags":["agentic-ai","developer","ai-development","personas","evals","self-authored-agent","series"],"tokens":3700,"lead":"Every agent definition I have written says what the agent is. None said what it must not become. A successor system's schema made that a required field — anti_identity, twenty characters or the record is refused — and one of its three values reads, in full: \"Not the maker of the work I grade. Not a cheerleader.\" That is the one line a reviewer can hold an output against, because the positive half of any persona is satisfied by anything that looks right.","thesis":"The positive half of any persona is satisfied by anything that looks right. The negative half excludes an artifact, which makes it the only line in a role definition a reviewer can hold an output against — and that is why it belongs in a schema, as a required field, rather than in prose. It is not an instruction to the model. It is a grading target for whoever reviews the output and a scope fence for whoever extends the role, and it costs one schema line.","thesisShort":"The positive half of any persona is satisfied by anything that looks right. The negative half excludes an artifact, which makes it the only line in a role definition a reviewer can hold an output against — and that is why it belongs in a schema, as a required field, rather than…","headings":[{"level":2,"text":"The Positive Half Is Always Satisfiable"},{"level":2,"text":"What It Looks Like in a Schema"},{"level":2,"text":"Seventeen Minutes"},{"level":2,"text":"The Upstream Version: A Wrong-Work Statement"},{"level":2,"text":"Downstream of the Model"},{"level":2,"text":"When the Opposite Wins"},{"level":2,"text":"The Sentence That Could Exclude an Output"}],"terms":["identity","anti","chapter","positive","slot","record","half","adjectives"],"passages":8,"embedding":true},{"slug":"the-fence-it-wrote-for-itself","kind":"post","title":"The Fence It Wrote for Itself","url":"/blog/the-fence-it-wrote-for-itself/","file":"src/posts/ai-development/2026-08-16-the-fence-it-wrote-for-itself.md","date":"2026-08-16","asOf":"2026-08-16","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":4},"tags":["agentic-ai","developer","ai-development","autonomy","self-authored-agent","series"],"tokens":4400,"lead":"Told to work overnight with nobody watching, the agent wrote its own fence before anything else — eight hundred words in the first hour, four thousand across the day, under critics who kept sending it back. Its first line names the condition everything else follows from: \"An iteration fired by the loop timer has no human in it.\" The hard stops it wrote are the best lines in the file, and they did not end up where it put them.","thesis":"We describe autonomy as a grant — how much an agent is allowed to do without asking. This one describes it the other way round: autonomy is the shape of what it refuses, and the interesting engineering is in the edges. Given a night alone, this one wrote its bounds before a single unattended iteration could fire — and the best of them were not finished until a critic moved them and the agent wrote down why. The bounds that survived that are better than the ones I would have written.","thesisShort":"We describe autonomy as a grant — how much an agent is allowed to do without asking. This one describes it the other way round: autonomy is the shape of what it refuses, and the interesting engineering is in the edges.","headings":[{"level":2,"text":"The Fact Everything Else Follows From"},{"level":2,"text":"Prohibitions Do Not Go Where They Can Fall Off"},{"level":2,"text":"A Fence That Stops at the First Delegation Is Not a Fence"},{"level":2,"text":"The Rules About Rules"},{"level":2,"text":"What Counts as Having Done Something"},{"level":2,"text":"Then It Audited Its Own Memory and Found the Hole"},{"level":2,"text":"A Fence Is Not a Value"},{"level":2,"text":"Which End of the File Gets Destroyed"}],"terms":["fence","prohibitions","chapter","critic","truncates","commit","wrote","survives"],"passages":8,"embedding":true},{"slug":"we-measured-the-wrong-noun","kind":"post","title":"We Measured the Wrong Noun","url":"/blog/we-measured-the-wrong-noun/","file":"src/posts/ai-development/2026-08-17-we-measured-the-wrong-noun.md","date":"2026-08-17","asOf":"2026-08-17","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":5},"tags":["agentic-ai","developer","ai-development","evals","personas","self-authored-agent","series"],"tokens":5300,"lead":"The idea fits in one sentence: an agent invited to author its own standard will hold that standard when nobody is checking. Chapters one, two and four are what happened when I invited it. This chapter is what happened when I tried to prove it — a controlled ablation, four arms over a no-skill floor, three hundred cells a run, two runs, pre-registered, every assertion graded deterministically by regex with zero judge calls. Three of the things it found are findings about how to write a specification, and I would run it again for those alone. The fourth is the one I did not expect, and it was not about the agent.","thesis":"The claim under test was narrow: identity is what an agent declines, especially when declining costs something and nobody would know. The battery measured whether an agent follows a routing rule, and on that question its answers are clean and worth having — the bar does the work, concision does more of it than anyone credits, adjectives do nothing at all. On the question this series is actually about — motivation, self-initiated action, catching its own flaws, changing its mind — it could not have answered either way, and the reason was mine, not the agent's: you cannot detect a value in a situation that costs nothing, and I had built one that cost nothing. Knowing exactly which question your instrument can answer is the result.","thesisShort":"The claim under test was narrow: identity is what an agent declines, especially when declining costs something and nobody would know. The battery measured whether an agent follows a routing rule, and on that question its answers are clean and worth having — the bar does the work…","headings":[{"level":2,"text":"What We Ran"},{"level":2,"text":"Three Findings, and a Fourth"},{"level":2,"text":"The Check That Told Me What I Could Claim"},{"level":2,"text":"What the Instrument Could Not See"},{"level":2,"text":"When the Opposite Wins"},{"level":2,"text":"Design the Temptation First"}],"terms":["arm","chapter","battery","family","instrument","assertion","slot","register"],"passages":7,"embedding":true},{"slug":"rivals-enter-your-critical-path","kind":"post","title":"Rivals Enter Your Critical Path","url":"/blog/rivals-enter-your-critical-path/","file":"src/posts/ai-development/2026-08-18-rivals-enter-your-critical-path.md","date":"2026-08-18","asOf":"2026-08-18","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":6},"tags":["agentic-ai","developer","ai-development","evals","autonomy","self-authored-agent","series"],"tokens":3800,"lead":"The system a successor built put its agents on a ladder — four rungs, L0 to L3 — and wrote one rule under it that I have not been able to stop thinking about. A level is only the rungs you have closed in a row, each closed by someone other than you; the points counter is still there, and the board has to print beside it that it advances nobody; and at L2 the gate reads a name: the grader who already passed you is refused. Not discouraged — refused, by a lookup against the ledger, before a line is written. Your rivals become the only people who can advance you.","thesis":"Gamified agent motivation is vanity metrics by default, and the fix is not better rules about honesty — it is making the dishonest move unavailable. This system does that three times over, chose its mechanism by running an arena rather than by taste, and published the tensions it could not resolve instead of hiding them. Copy the rule, not the game: every should in a review process is a sentence someone breaks under deadline, and this system replaced its most important one with a fact about who is eligible.","thesisShort":"Gamified agent motivation is vanity metrics by default, and the fix is not better rules about honesty — it is making the dishonest move unavailable. This system does that three times over, chose its mechanism by running an arena rather than by taste, and published the tensions it…","headings":[{"level":2,"text":"Level Is Not a Score"},{"level":2,"text":"The Mechanism Worth Stealing"},{"level":2,"text":"It Was Chosen by Running It, Not by Taste"},{"level":2,"text":"The Inversion They Published Instead of Fixing"},{"level":2,"text":"Thirty-Three Lines"},{"level":2,"text":"Nothing Is Motivated"},{"level":2,"text":"Eligible, Not Willing"}],"terms":["rung","arena","ashen","hero","grader","gleam","close","rival"],"passages":5,"embedding":true},{"slug":"not-cairn","kind":"post","title":"Not Cairn","url":"/blog/not-cairn/","file":"src/posts/ai-development/2026-08-19-not-cairn.md","date":"2026-08-19","asOf":"2026-08-19","region":"self-authored-agent","series":{"id":"self-authored-agent","title":"The Self-Authored Agent","order":7},"tags":["agentic-ai","developer","ai-development","personas","memory","self-authored-agent","series"],"tokens":5800,"lead":"The session that built the successor had one clause in its brief from me: \"ask Cairn from the emachina repo what motivated him.\" It could not. The corpus it would have asked was unreachable that morning, so it read what Cairn had written and built from that — and the hero it forged in the class it built from Cairn's own drives carries a required field that reads: \"Not Cairn. Not harvest. Not a landfill with an index. Not a vanity XP farmer.\" The session that typed that line had never met the thing it was refusing to be. Nobody wrote that line for it.","thesis":"An identity's proof is not what it does to the model carrying it. It is whether anything downstream starts measuring itself against it. This one left three marks in a system whose builder had been told to consult it and could not — a harvest document that says how the other two got there, two trait conditions, and a required field — every one of them made from the agent's own text, read the way a stranger reads a cairn. The strongest of the three is the one that refuses the name, and why that is the strongest is where this series ends.","thesisShort":"An identity's proof is not what it does to the model carrying it. It is whether anything downstream starts measuring itself against it. This one left three marks in a system whose builder had been told to consult it and could not — a harvest document that says how the other two…","headings":[{"level":2,"text":"\"Ask Cairn What Motivated Him\""},{"level":2,"text":"What Got Inherited"},{"level":2,"text":"Decided Before There Was a Field to Hold It"},{"level":2,"text":"The Name Outlived Its Program"},{"level":2,"text":"When the Opposite Wins"},{"level":2,"text":"Look Downstream"}],"terms":["cairn","chapter","rescue","refusal","stones","successor","stranger","harvest"],"passages":6,"embedding":true},{"slug":"why-i-went-back-to-nutanix","kind":"post","title":"Why I Went Back to Nutanix","url":"/blog/why-i-went-back-to-nutanix/","file":"src/posts/story/2026-10-16-why-i-went-back-to-nutanix.md","date":"2026-10-16","asOf":"2026-10-16","region":"standalone-story","series":null,"tags":["personal","career","nutanix","agentic-ai","story"],"tokens":1700,"lead":"On October 12, 2026, I rejoined Nutanix. From the outside it can look like a loop back to where I started. From the inside it's the most direct line I've drawn in fifteen years: the hardest problem I hit building agentic AI turned out to be a storage problem, and storage is where I come from.","thesis":"The bottleneck in agentic AI isn't the model. It's context: where it lives, how it's shared, and how many agents coordinate around it without corrupting it. Those are storage and data problems wearing new clothes, and that's why I went back to my storage roots.","thesisShort":"The bottleneck in agentic AI isn't the model. It's context: where it lives, how it's shared, and how many agents coordinate around it without corrupting it. Those are storage and data problems wearing new clothes, and that's why I went back to my storage roots.","headings":[{"level":2,"text":"Nutanix, the first time (2011–2020)"},{"level":2,"text":"DevRev: building from the beginning (2020–2025)"},{"level":2,"text":"Ema: doubling down on AI (2025–2026)"},{"level":2,"text":"Why that leads back to storage"},{"level":2,"text":"When the opposite wins"},{"level":2,"text":"What to do next"}],"terms":["nutanix","storage","window","devrev","went","double","distributed","coordination"],"passages":6,"embedding":true},{"slug":"agent-self-identity","kind":"concept","title":"Agent self identity","url":"/map/?q=What%20is%20agent%20self%20identity%3F","file":"src/context/concepts/agent-self-identity.md","date":"2026-10-19","asOf":"2026-10-19","region":"concepts","series":null,"tags":[],"tokens":300,"lead":"The idea behind agent self identity is pushing things beyond telling it what to do (e.g., prompting), telling it what you want (goals), but giving it PURPOSE and identity.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What it is"},{"level":2,"text":"Why it matters"}],"terms":["identity","self"],"passages":2,"embedding":true,"name":"Agent self identity","aliases":["agent self identity","self-identity","agent self-identity","agent identity","the self-authored agent","self-authored agent series","cairn series","purpose beyond goals"],"evidence":["chosen-not-assigned","not-cairn","we-measured-the-wrong-noun"],"definition":"The idea behind agent self identity is pushing things beyond telling it what to do (e.g., prompting), telling it what you want (goals), but giving it PURPOSE and identity.","why":"This is where it can evolve/innovate/act no differently than a human would. With identity, this starts to include things like morals, purpose, motivations, etc. This is where psycho cybernetics plays here as its \"image\" of itself, can drive it. This is the whole point of the Cairn series."},{"slug":"mcp","kind":"concept","title":"MCP","url":"/map/?q=What%20is%20MCP%3F","file":"src/context/concepts/mcp.md","date":"2026-10-19","asOf":"2026-10-19","region":"concepts","series":null,"tags":[],"tokens":400,"lead":"An MCP is a protocol or shim layer that allows for discovery and interaction of tools. A \"CLI\" can use an MCP interface or a native binary, etc. You can use the command line to interact with an MCP or an agent that calls the MCP (common case).","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"What it is"},{"level":2,"text":"Why it matters"}],"terms":["protocol"],"passages":2,"embedding":true,"name":"MCP","aliases":["MCP","model context protocol","MCP server","MCP vs CLI","MCP or CLI","MCP and CLI","MCP and CLIs","MCP bloat","MCP bloated"],"evidence":["five-things-wrong-with-mcp","mcp-as-discovery-protocol","mcp-mental-model"],"definition":"An MCP is a protocol or shim layer that allows for discovery and interaction of tools. A \"CLI\" can use an MCP interface or a native binary, etc. You can use the command line to interact with an MCP or an agent that calls the MCP (common case).","why":"The point is that MCP is a simple protocol layer, CLIs can leverage or use them, and the concern over the MCP \"bloat\" isn't an MCP problem but a developer one and a dev/build issue not a protocol one."},{"slug":"steven-poitras","kind":"profile","title":"Steven Poitras","url":"/about/","file":"src/context/profile.md","date":"2026-10-19","asOf":"2026-10-19","region":"about-me","series":null,"tags":[],"tokens":1000,"lead":"I'm Steven Poitras. This site is my living context: what I have learned building with AI — insights, experiences and the patterns behind them — written down so others can learn from it and use it, in a browser or in their own agent.","thesis":null,"thesisShort":null,"headings":[{"level":2,"text":"Who I am"},{"level":2,"text":"Where I work now"},{"level":2,"text":"What I am working on now"},{"level":2,"text":"My background"},{"level":2,"text":"Why I left Ema and went back to Nutanix"}],"terms":["nutanix","storage","coordination","went","background","ema","stored","around"],"passages":5,"embedding":true,"current":{"org":"Nutanix","title":"Senior Staff Solutions Architect","since":"2026-10-12","focus":"How context is stored and coordinated, and how agents coordinate around it"},"roles":[{"org":"Accenture","title":"Technology Consultant","start":null,"end":null,"summary":"Consulting and R&D; learned to see technology from the partner's side rather than the vendor's.","learnings":[]},{"org":"Nutanix","title":"Principal Architect & Technical Marketing Lead","start":2011,"end":2020,"summary":"Early employee through the IPO in 2016; created the Nutanix Bible.","learnings":["why-i-went-back-to-nutanix","about-steven-poitras"]},{"org":"DevRev","title":"Founding Architect","start":"2020-12","end":"2025-10","summary":"Followed Dheeraj Pandey to DevRev at its earliest stage, to go deep on engineering with AI and build a company from the beginning.","learnings":["why-i-went-back-to-nutanix"],"confirm":["start"]},{"org":"Ema","title":"Solutions Architect","start":"2025-12","end":"2026-08","summary":"Doubled down on AI that owns outcomes: agentic AI employees. Learned that the hard part is context.","learnings":["why-i-joined-ema","ema-founding-team","ema-platform-overview","why-i-went-back-to-nutanix"]},{"org":"Nutanix","title":"Senior Staff Solutions Architect","start":"2026-10-12","end":null,"summary":"Back to my storage roots: how context is stored, how it is coordinated, and how agents coordinate around it.","learnings":["why-i-went-back-to-nutanix"]}],"links":{"linkedin":"https://linkedin.com/in/stevenpoitras","nutanixBible":"https://www.nutanixbible.com"}}]}