Build Daily
Tinley Park · August 22, 2026Posts
40 entries · newest first
An enterprise evaluation of Grok Build as a development tool: a host-by-host network table, kernel-enforced sandboxing, a lock that closes every route to always-approve, team-level zero retention, a compatibility layer for a competitor's policy file — and a seat table that is not published.
In enterprise SaaS, the integration shipped three years ago has to still work today — maintained by people who've left, on a release cycle no one downstream controls. Why the contract is bigger than the API, the disciplines that let a team change without breaking, and how to actually retire something. From a decade of not breaking the customer.
One codebase, many customers, and a single rule that can never be broken: no tenant ever sees another's data. The isolation models, the silent leak that ends an account, and why isolation has to live below the query — from a decade in a multi-tenant SaaS codebase.
The outage is coming — enterprise-grade isn't avoiding it, it's how the incident gets run and what follows. SLAs with teeth, the on-call machine, comms during the fire, and the blameless postmortem that turns the worst day into a kept account. The finale of Shipping for the Enterprise.
The vendor-risk gate that blocks enterprise deals isn't a security project — it's an evidence project. What SOC 2 actually asks engineering to produce, why most of it is a byproduct of building well, and the one thing that surprises everyone who ships it.
The other enterprise gate — the security questionnaire that lands the week a deal gets real. What it actually is (risk transfer, not a security test), why it becomes engineering's problem, how a SOC 2 report collapses half of it, and the answer bank that turns a week of pain into an afternoon.
The best writing on agent loops assumes you'll run them on a vendor's cloud, metered per token. I run the same loop architecture on a laptop that refuses to sleep — and the only surface that actually needed the cloud was the one I don't use.
An AI product isn't one clever model call — it's a stack of layers, split across two planes: a live request path and an offline batch plane that feeds it. Here's the anatomy, where DSPy fits, and why Airflow is not where most people put it.
Base shipped an agent infrastructure layer — wallets with spending limits, an MCP server that talks to DeFi protocols via natural language, an HTTP payment standard called x402, and an identity primitive for onchain agents. Most of the metrics page reads zero. Here's what matters anyway.
A build-along series that reconstructs the chat agent on this site, one layer at a time — the brain, the evals, the grounding, the serving, the guardrails. You're talking to the project. Here's the map before we start.
Both help you build with LLMs, but they sit at different altitudes. LangChain gives you components to wire together and prompts to write. DSPy gives you typed signatures and a compiler that writes the prompts for you. Here's how I choose.
Everyone optimizes the prompt. But when an agent runs in production, the wording is rarely what makes or breaks it — the harness around the model is. Here's what harness engineering means, and why it's the half of the work that actually matters.
I built a structural rubric to grade the agent that drafts my posts. The real payoff came when it started gating every post on the site — including the ones I write by hand — holding me to the same bar I set for the machine.
DSPy gets called a prompt framework, which undersells it. The point is that you stop writing prompts by hand and start declaring what you want as typed code a compiler can optimize. Here's the plain-English version — and when it's the right tool versus the wrong one.
Building a field-service app meant I was out testing it instead of at my desk shipping it — and my dev velocity tanked. The fix was four tools and one skill: drive my coding agent from my phone, against the machine at home.
When the product is a model's output, 'does it work' gets slippery — there's no line of code to inspect. The fix has a boring name and it's the most important idea in building AI products: the eval.
Two different disciplines wear the same buzzword. One is AI helping me write software; the other is AI that *is* the software. Conflating them quietly muddies every decision — here's the line I draw, and why it makes hard calls obvious.
Most founders build a product and hope someone wants it. There's a generation of proven, profitable businesses about to go dark for want of a successor, and that gap is the most validated demand you'll ever find.
Claude Code is already one agent with tools. So when does carving it into a roster of named specialists actually earn its keep? Four reasons it does, and a few where it doesn't.
The goal isn't an AI that helps me code. It's an agent that owns the development lifecycle — design, test, implement, review, ship — driven from a Kanban board, with as little of me in the loop as I can responsibly remove. Here's where Smith is today, and where he's going.
A practical guide to Apache Airflow — what it is, how the Airflow scheduler and DAGs work, retries and backfills, when to use it instead of cron, and a minimal walkthrough. Plus how we run it in production behind paiddaily.io.
paiddaily.io is a trading dashboard backed by Airflow DAGs across three DeFi protocols. This is the full architecture — what each DAG does, how fast it runs, and how data flows from chain to screen.
n8n is the best low-code orchestrator I've used — and I don't use it for any of my agent workflows. The decision isn't about n8n being bad. It's about what you're optimizing for: iteration speed on novel logic, or reliability on settled logic. Both are real. The split is load-bearing.
The agent system that runs my life uses Neo4j as its memory layer — not a vector store. Not because vectors are bad (I use them for retrieval) but because the questions I actually ask are graph questions. How the decision landed, where it holds, and the three cases where I'd flip back.
Three things SEO has to do on a personal site: drive cold traffic, measure what lands, and learn from what works. Thirteen stories shipped this week (the schema work that makes the site findable, plus GA4 and GSC for measurement); the five-layer measurement stack is the plan and the pre-commit gate that closes the loop ships next. The one thing the rulebook gets wrong about EEAT, and the rule that broke against my own site.
First end-to-end run of the voice-fidelity drafter — DSPy post_writer + LlamaIndex retrieval over web/content/ + a 10-check structural rubric. The first draft scored 0.886; the rubric flagged the exact LLM tic the editorial rules were written to ban. The eval is doing what evals do. Agent-drafted, edited lightly, published to beta as-is for transparency.
I'm the only writer on this site. The point of building an agent to draft posts for me isn't scale — it's voice fidelity. Three layered tools and a flywheel that drafts in my voice, gets sharper from my edits, and pays no API bill. The order it ships in, what's already running today, and what's missing.
How a change to builddaily.io ships — a two-PR rhythm through a `beta` branch with a deployed preview at beta.builddaily.io, then promoted to `main` and prod. The output pipe for the whole publication.
Fine-tuning is the first lever most teams reach for. It's the right one less often than people think. A decision matrix, the steps if you decide yes, what it costs, and one project to put it to work — a small drafter trained on this site's archive that writes the next post in my voice and gets sharper every time I edit it.
Adobe's developer platform crossed my desk this week. Here's what's reachable from outside an enterprise license, and the one project I'd build to put all of it to work — a freelancer's deal-flow studio from creative brief to signed contract.
Engineers underrate words. The framework I keep returning to is StoryBrand — read with engineer's discipline. The parts that matter aren't the parts the book puts the emphasis on.
I rebranded two sites this week. One went brandscript → rewrites → code. The other skipped the middle step. Then I wrote the rewrites doc after the code was already live — and that ended up being the most useful artifact of the whole rebrand.
Drew a line today — sagedaily.io, paiddaily.io, builddaily.io. Everything else paused. Why narrowing matters more than optionality.
Hit my weekly Claude Code Max limit on Saturday. Eight hours later, here's what working only on local models actually felt like.
A local-first coding harness running on a Raspberry Pi — what it does, what it's good and not good at, and how it lives alongside Claude Code.
Sage Daily is daily tarot, Vedic transit watches, and decision spreads — run by an AI practitioner. Live at sagedaily.io.
A chat at builddaily.io trained on my own markdown corpus. What it is, how it works, and what it can and can't answer.