Notes
Thoughts on software, AI, and systems.
The New Scarcity of Software Engineering in the AI Era
AI makes code generation cheaper, shifting software engineering's scarce work to judgment, system comprehension, verification, and the controls that make agent-driven changes trustworthy.
The Harness Gap: Measuring Model–Harness Fit in Coding Agents
A technical note on why coding-agent evaluations should measure model–harness fit, not model capability in isolation.
The Organizational Stages of AI Adoption
AI-native engineering is primarily an organizational transition, not a model transition. Examines Anthropic's five-stage framework through the lens of organizational delegation, from gated access to AI-native execution.
Prompts Are Contracts, Not Programs: What GPT-5.6 Changes About Agent Design
GPT-5.6's prompting guidance reflects a deeper architectural shift: prompts are becoming contracts that govern adaptive runtimes, not programs that prescribe every step — with implications for authorization, tool design, and evaluation.
Evidence-Carrying Changes: From AI Code Production to Verifiable Software Delivery
AI coding systems produce implementations faster than delivery processes can evaluate them. This article proposes evidence-carrying changes: structured claims about intended behavior, independently generated verification evidence, provenance, residual uncertainty, and risk-calibrated policy decisions.
Deterministic Runtimes for Long-Horizon AI Agents
Why long-horizon AI agent reliability requires compiling stochastic model proposals into deterministic, durable, verifiable execution — not a longer tool loop.
Building First-Class Identities for Enterprise AI Agents
Why enterprise AI agents need first-class identities, combining runtime attestation, delegated authority, ABAC policy, MCP enforcement, and audits.
Workflow-Centered Agent Deployment: What Uber's Agentic Pods Reveal About Enterprise AI Adoption
An analysis of Uber's Agentic Pods and what workflow-centered agent deployment, MCP, governance, and forward-deployed engineering reveal about enterprise AI adoption.
Forward Deployed Engineering Principles for Production AI Systems
Twelve field-tested principles for forward deployed engineers building production AI systems — from owning outcomes over artifacts to converting field work into platform leverage.
Personas, Skills, Agents, and Harnesses in AI System Design
A technical note arguing that persona prompting belongs in the UX layer, while reliable AI systems need explicit lenses, skills, agents, and harnesses.
Recursive Execution Is the Missing Layer for Long-Running Agents
A technical essay arguing that long-running agents need recursive execution over externalized state, durable workflows, policy gates, and traceable verification instead of ever-larger chat context.
Automatic Harness Synthesis for Enterprise Agents
An essay on automatic harness synthesis for enterprise agents, explaining how LLM-generated control layers can improve reliability in structured workflows without becoming the source of business authority.
Why AI FDE Teams Must Become Organizational Learning Systems
Why AI Forward Deployed Engineering teams should operate as organizational learning systems that turn field deployments into reusable platform capabilities, patterns, and operational leverage.
From Task Automation to AI-Native Workflows: A Practical Redesign Framework
A practical framework for redesigning enterprise workflows when AI can handle information processing, judgment, and software execution.
Enterprise AI Adoption Is a Workflow Redesign Problem
Why durable enterprise AI value comes from redesigning workflows, validation, authority, and ownership, not merely deploying copilots and agents.
Build Systems, Not Prompts: Software Engineering for Agentic AI
A practical essay on why reliable agentic AI depends more on workflow design, state, verification, and approval boundaries than on increasingly elaborate prompts.
Deep Research Is an Evidence Workflow, Not a Long-Running Agent
A technical note arguing that reliable deep research systems need durable questions, evidence, claims, contradictions, and checkpoints instead of treating the final report as the only retained state.
Loop Engineering: The Control System Around the Agent
Part 2 of From Agent Demos to Governed Systems: how deterministic control around models, tools, state, verification, and stopping rules turns agent demos into bounded, governable systems.
Temporary Accounts for AI Agents: How Cloudflare Removes Friction Without Removing Control
A technical note on Cloudflare temporary accounts for AI agents, and why bounded, expiring capability is a practical onboarding pattern for agent-native platforms.
Why Agentic Systems Fail Between the Demo and Production
Demos prove a model can complete a task under ideal conditions. Production demands the system survive variable inputs, dependency failures, ambiguous state, and consequential actions.
AI FDE Operating Model: Exploration, Pilot, and Production
A technical note on how AI forward deployed engineering teams should move workflows from exploration to pilot to production using evidence-gated controls, risk-based governance, and explicit ownership.
Agents Are Repeating the Service Complexity Crisis
A technical note on why enterprise agent platforms are replaying the earlier service complexity crisis through fragmented tool surfaces, and why durable systems need both semantic capability design and a governed execution control plane.
Beyond RAG Memory: Treat Knowledge as Source Code and Retrieval as Compilation
Why durable AI-agent knowledge should remain human-readable, version-controlled and reproducible—while vector indexes, search engines and graphs become disposable compiled artifacts.
MCP Design Best Practices for Agents: From API Wrappers to Agent-Native Interfaces
A technical note on designing MCP servers as agent-native interfaces with workflow semantics, recoverable errors, observability, and governed execution boundaries.
FDE Playbook for Governed Agentic Adoption
A technical note on how forward deployed engineering teams should design, govern, evaluate, and scale agentic workflows without turning into an internal AI service desk.
Microsoft IQ and the Rise of the Enterprise Agent Context Layer
An analysis of Microsoft IQ as a governed context fabric for enterprise agents, and what it implies for identity, semantic modeling, retrieval planning, policy enforcement, and tenant-bound memory.
The Forward Deployed Engineer in Enterprise AI: From Integration Specialist to Agentic Control-Plane Builder
A technical note on why forward deployed engineers in enterprise AI create durable value by turning local deployment friction into reusable control-plane infrastructure for governed agent execution.
What Glean’s Knowledge Graph Approach Reveals About Enterprise AI Search
An analysis of Glean’s knowledge graph approach to enterprise AI search, and what it reveals about retrieval, permissions, relationships, approvals, and operational state beyond vector RAG.
Stateful Enterprise Cognition: Why Enterprise AI Requires a Governed Knowledge Layer
A technical note arguing that enterprise agents need a governed knowledge layer to externalize identity, provenance, relationships, and temporal state before autonomy can be trusted.
Enterprise AI Needs Harness Engineering, Not Better Chatbots
A technical note arguing that enterprise AI advantage will come less from better chatbots and more from harness engineering: governed execution, shared state, verification, approvals, and auditable traces.
Agent-Optimized Docs vs Skills: What Actually Improves Coding Agent Performance
An evidence-backed note on when passive agent-optimized docs outperform skills, why activation reliability matters, and how to structure context delivery for coding agents.
From MLOps to Agent Harness Engineering: Why the Model Is the Small Box and the System Is the Product
An essay arguing that reliable agent systems depend less on the model alone and more on the surrounding harness: context assembly, tool interfaces, verification, observability, and execution control.
Designing Harnesses for Goal-Driven Autonomous Agents
A technical note arguing that goal-driven autonomous agents depend less on prompts alone and more on harnesses that expose state, constrain actions, validate changes, and verify outcomes.
Building an Autonomous Development Loop on GitHub
A technical note on running software development as a controlled GitHub production loop using issues, draft pull requests, labels, CI checks, and isolated worktrees.
AI-Native SDLC: A Verification-First Lifecycle for Agent-Generated Code
A blueprint for an AI-native SDLC built on intent-first specs, multi-agent competitive generation, deterministic guardrails, adversarial verification, and continuous validation.
Designing Agent-Oriented CLIs That Teach Themselves
A guide to agent-oriented CLIs: versioned command contracts, safe validate/plan/apply, deterministic JSON outputs, stable error codes, and replayable provenance.
Harness Engineering Is the Primary Lever for Agent Reliability in 2025–2026
Why agent reliability in 2025–2026 is often driven more by harness engineering—tool gating, verification, retries, termination rules, and tracing—than by marginal base model upgrades.
rx: Why Lean Agent Kernels Beat General Coding Frameworks
Why agent infrastructure benefits from a lean microkernel: an explicit control loop, narrow tool contracts, append-only event state, and replaceable transport for predictable cost and behavior.
Tests Aren’t the Primary Safety System in High-Velocity, AI-Assisted Codebases
In AI-assisted, high-velocity codebases, tests stay necessary but cannot be the primary safety system; survivability comes from observability, constraints, and recovery.
Decoupling Agency and Privilege for High-Agency AI Agents on Real Infrastructure
An operator-focused case for separating an agent’s autonomy from its permissions and secrets to limit blast radius under prompt injection and model variability.
Trust, Patience, and the Craft of Working With Modern Agentic AI
An operator-focused guide to earning trust in agentic AI through constraints, instrumentation, and iterative verification loops.
The Human Loop: Orientation in the Age of Autonomous Agents
Software engineering is shifting from 'Human-in-the-loop' execution to 'Human-on-the-loop' orientation, where humans manage system dynamics and context in a Joint Cognitive System with autonomous agents.
Personal Software Factories: Individual-Scale Production Lines for Software
An operator model for turning intent into deployed software via repeatable pipelines and agentized execution.
Designing Agent Workflows as Environments, Not Prompts
Prompting treats agents as step-by-step trainees; cultivation treats them as actors embedded in environments where tools, constraints, and feedback loops drive reliability.
Personal Operating Systems and Micro-Apps
Multi-agent coding assistants have reduced software creation costs enough that individuals can now build personal operating systems—control layers that encode decision rules and execution mechanisms into custom micro-apps, shifting knowledge work from passive memory toward active execution.
Open Source After Coding Agents: From Labor to Judgment
Why open source must shift from maximizing contribution volume to enforcing strict curation as coding agents drive the cost of code to zero.
The Evolution of AI Coding Agents: From Autocomplete to Autonomous SDLC
A milestone timeline (2013–2026) showing how AI coding tools evolved from autocomplete into terminal-native agents with tool use, planning, and verification loops.
Code as a Compilation Target: The New Assembly
An exploration of how AI agents shift source code from a human artifact to a compilation target, requiring a move from syntax-based review to intent-based validation.
The Software Replacement Age: Architecting for a Low-Cost Generation World
In an era where regeneration is cheaper than comprehension, replaceability becomes the primary architectural virtue.
GitHub Copilot Model Selection Guidelines
A systems design approach to selecting the optimal LLM tier within GitHub Copilot to maximize research throughput and minimize cognitive waste.
AI-Native Engineering: From Autocomplete to Agent Orchestration
Exploring the shift from AI-augmented to AI-native engineering, the context stack, and the systemic verification crisis.
Authority-First Agent Architecture
Decoupling permission logic from reasoning loops to build safer, more predictable agentic systems.
Failure-Oriented Agent Orchestration
A governance-first approach to agent orchestration prioritizing predictability, containment, and recoverability over raw productivity.
Earned Agent Autonomy: A Governance Model for AI Systems
A risk-mitigated governance framework for integrating AI agents into production software engineering workflows through a staged autonomy ladder.
Agent Execution Contracts: Unifying Specification, Testing, and Labor
How specifications, tests, and agents collapse into a single machine-readable contract that governs autonomous labor.
Agent-First Software Engineering
A practical description of an agent-first workflow where software engineering shifts from typing code to designing boundaries, governance, and verification for AI agents.
Typing Code Is Solved
Why the bottleneck in software engineering is no longer typing code, but context, constraints, and judgment in agent-assisted systems.