29 posts
You left the enterprise SDLC — change boards, QA gates, sign-offs — to vibe-code solo with an AI. The safeguards didn't have to follow you, but their jobs did. A field guide mapping each one to its lean ADD equivalent, grounded in two real solo projects.
16 min readA controlled comparison: two AI workflows build the same forty-line function from one spec. GSD records it in five files and 644 lines of prose; ADD in a 22-line contract. Real recovered artifacts and exact token logs show ADD spent 5× fewer tokens with the same passing tests.
14 min readNous Research's Hermes Agent ships a learning loop inside its runtime — act, then a background thread folds lessons into memory and skills. It's the back half of ADD's loop, in code. What that proves, what it's missing, and why the two compose.
10 min readThe five competencies behind AI-Driven Development — Domain, Spec, UI/UX, Test, and AI/Build — and why each is a separate discipline the agent stands on. The foundation that makes 'constrain the what, free the how' actually work.
12 min readWhen agents and teams produce more than any leader can read, line-by-line review collapses. ADD reframes the job: the ADR and its fitness functions are the frozen contract, fitness checks are the red tests, and production evidence — not a clean diagram — is how direction is verified.
13 min readA field study of ai-proxy, a multi-tenant AI gateway built end-to-end with ADD: 23 milestones, ~120 tasks, six days, zero waivers. What the method felt like in production and how the LLM behaved when scope was clamped.
12 min readThe frozen contract is ADD's one human gate — the interface, data shapes, and error codes, locked and checksummed before the agent builds. Why it is the single approval that earns the agent its autonomy.
12 min readThe step that closes the loop: Observe production behavior and fold the spec delta back into the next Specify. How ADD keeps documents living while old-school artifacts rot — and how the method improves itself.
11 min readWhere ADD sits among its neighbors: the lineage it inherits from TDD, DDD, BDD, and contract-first design, and how it differs from spec-kit and GSD by continuing past Verify to Observe and folding the loop closed.
13 min readADD's first two steps kill fast waste before a line of code exists: Specify (Must do, must Reject with error codes, the After-state) and Scenarios (concrete happy, edge, and failure examples in domain language). Pin the what.
11 min readAI made writing code nearly free and quietly broke the SDLC. AI-Driven Development — five competencies, eight steps — constrains what an agent builds while freeing how it builds, proven across a 23-milestone production gateway shipped in six days.
26 min readContext windows forget. Production agents don't. The difference is a layered architecture: working memory, session memory, and long-term memory split into facts, events, and skills. Here's how real agents remember — and why forgetting on purpose matters.
10 min readEveryone debates which AI model is best. The real engineering happens in the harness — the production system of tools, permissions, memory, and orchestration that makes any model actually useful. This is a map of that system, drawn from real source code.
9 min readA language model without tools is an expensive autocomplete. This post dissects how a production AI harness defines, registers, validates, and executes 40+ tools — from file reads to shell commands to MCP integrations — with type safety, concurrency control, and deferred loading.
9 min readAd-hoc prompting is fine for one-off questions. Repeatable workflows deserve structure. This post dissects how a production harness defines, discovers, loads, and executes skills — reusable AI workflows that turn tribal knowledge into executable automation.
8 min readAn AI with shell access and no guardrails will eventually destroy something you care about. This post dissects how a production harness implements layered permissions, hooks, dangerous pattern detection, and trust boundaries — balancing safety with usability.
10 min readThe model is only as good as the context it receives. This post dissects how a production AI harness constructs system prompts, loads project instructions, manages persistent memory, and compresses context when the window fills — all to give the model the right information at the right time.
9 min readThe orchestration loop is the heart of an AI harness — a state machine that coordinates API calls, streaming responses, concurrent tool execution, error recovery, and token budgets. This post traces the complete data flow from user input to final response.
9 min readA production AI harness is not single-threaded. Background agents explore codebases, shell commands execute, remote agents run on cloud infrastructure — all while the main conversation continues. This post dissects the task system that manages this concurrency.
8 min readThe invisible foundation beneath every AI harness layer: centralized state management, per-model cost tracking, rate limit handling, a custom React-to-terminal renderer, and multiple entry points. This post covers what makes 'works in a demo' become 'works in production.'
9 min readA chatbot answers. An agent finishes the job. The gap between them is not one feature — it's a stack of seven capabilities, built one rung at a time. This series walks that stack in plain English, for engineers and curious non-engineers alike.
9 min readA skill is not a long prompt. It is a structured workflow with a trigger, a prompt body, references, and an output contract. This post breaks down each component, shows how they interact, and explains the design decisions that separate skills that work from skills that frustrate.
11 min readMost Astro tutorials stop at pnpm create astro. By the time you need TypeScript strict mode, Tailwind 4, and a Cloudflare deployment pipeline enforcing Lighthouse 100, you are patching together Stack Overflow answers. This post gets you production-ready from the first command.
12 min readEvery client:load directive you add ships JavaScript to every reader. Most of them do not need it. The difference between Lighthouse 100 and 85 is understanding which components need interactivity and choosing the right hydration strategy for each.
14 min readYour BookStore API now has 200 customers who each want their own data. One missing WHERE clause leaks tenant data and kills the company. Here is how to make cross-tenant data leakage structurally impossible with context propagation, session events, and row-level isolation.
13 min readWhen order placement triggers inventory, email, webhooks, analytics, and distributor notifications — doing it synchronously makes the endpoint slow and couples everything. Domain events decouple 'what happened' from 'what should happen next.'
13 min readEight authentication and authorization methods, one decision tree. Here is the comparison matrix, production combination patterns, and pre-launch security checklist that turns auth knowledge into shipping decisions.
11 min readNot all hashes are created equal. Here is how SHA-256, bcrypt, scrypt, and Argon2id actually work under the hood — the math, the memory, the attacks they resist, and exactly when to use each one.
21 min readMost Python backend projects start clean and become unmaintainable. Here is the folder layout and naming convention that keeps a FastAPI + SQLAlchemy codebase navigable at any size.
7 min read