Sakul Learning

Stop handing agents a junk drawer: MCP and CLI tool design

A short guide to designing tools that agents can choose, call, recover from, and trust—whether the interface is MCP or a command line.

The outer loop is an accountability system

Loop engineering can automate investigation, implementation, and verification. It cannot automate ownership. Addy Osmani's outer-loop vocabulary—quality, verdict, answerability, and back pressure—connects agent loops to Agile feedback, small batches, and durable process state.

Designing identity and authorization for the outer loop

A production agent needs more than a workload identity. The outer loop must keep the trigger, agent, delegation, execution credential, verdict authority, and accountable owner distinct—and turn approval into a narrow, short-lived authority envelope.

The specification is not the batch

Spec-driven development, Agile, trunk-based development, and loop engineering are not competing rituals. They govern different feedback cycles: intent, product learning, integration, and autonomous execution.

Claude Code's practical taxonomy for loops

Anthropic's Claude Code team gives a crisp definition of loop engineering: agents repeat cycles of work until a stop condition is met. Their four loop types clarify what the human hands off to the harness: the check, the stop condition, the trigger, or the work stream.

Loop engineering is harness engineering plus time

Agent loops are not just longer prompts or a while loop around an LLM. The useful engineering work is the system around repeated model action: context, memory, verification, durable execution, budgets, observability, and human judgment boundaries.

Rent the GPU before you buy the GPU

A follow-up to the local Hermes migration and LAN coding-agent team posts: AI on Demand Cluster turns rented GPU marketplaces into a practical dress rehearsal for local LLM hardware. Before spending serious capex on cards, power, cooling, and noise, rent the shape you think you need, run your real Claude Code workload, and measure whether the model is fast, cheap, and capable enough to justify owning it.

compliance.tf is what happens when Terraform modules become the platform

Why we review: code review as a trust system in the agentic age

AI can find many of the things humans used to find in pull requests. That does not mean the review process is obsolete. In good teams, review is also how knowledge spreads, judgment develops, and the SDLC earns trust.

/visual-plan: turning agent plans into reviewable artifacts, not chat essays

Steve Sewell's new skill for Claude Code and Codex converts text-heavy planning output into interactive MDX review documents — wireframes, prototypes, diagrams, and comment threads — because a wall of Markdown in your terminal is a terrible way to make architectural decisions.

Strands Shell: the agent sandbox that isn't one

A deep look at the new open-source agent shell from the Strands team — its in-memory VFS, credential mediation, SSRF guard, and where it fits in an ecosystem that already has Code Interpreter, E2B, Modal, and Claude Code.

Eve, Mastra, AgentCore — three answers to durable agent workflows

Vercel just dropped Eve, an agent framework with durable execution built in. Mastra has been doing durable workflows for 18 months. AWS has been quietly building the same capabilities into Bedrock AgentCore. A side-by-side comparison of architectures, tradeoffs, and which problem each one is actually solving.

Building a LAN coding-agent team before the API door closes

A practical design for running a small team of coding agents on local hardware, using the Fable/Mythos export-control shock as the warning shot.

Kato: deterministic Kubernetes runbooks with AI at the end

A look at Kato, a small Kubernetes operator that turns troubleshooting workflows into CRDs and gives the LLM less freedom on purpose.

Friction Is the Roadmap

Lessons from turning a small deterministic Hermes cron job into a native Discord-thread PR review system, one observed failure at a time.

From a Rented Cloud Box to a GPU Under the Desk

A practical timeline of moving a self-hosted Hermes Agent from a small AWS EC2 trial to a desktop-hosted VM with local memory infrastructure: what worked, what broke, and why the final answer is hybrid rather than fully local.

Terraform Plugin Framework vs. formae's Plugin SDK

A deep comparison of Terraform's protocol-first provider framework and formae's actor-driven plugin SDK, focusing on boundaries, schemas, lifecycle, and developer experience.

Migrating Out of ChatGPT: Memory You Own, on an Agent That Runs Your Code

Why and how to move off subscription memory toward something you own and run yourself. First what to migrate into — the substrate choices (Obsidian, Honcho, local files, owned Postgres), how Hermes memory actually works, and the pitfalls we hit (including the auxiliary-LLM layer) — then, as an appendix, the validated pipeline for migrating your ChatGPT memories in.

Evolving Spec-Driven Development

Spec-driven development is moving from static documents toward shared ledgers of intent: collaborative, traceable workflows where humans steer and AI agents execute against versioned specifications.

Building a Source-Grounded Blogging Workflow for AI Agents

A draft about using source folders, unpublished drafts, and deliberate publication gates for AI-written summary articles.

Infrastructure as Code Needs Software Engineering, Not More Config Tooling

A critique of Terragrunt-style IaC repo fixes and a case for treating cloud infrastructure as real software, with reusable libraries, tests, package managers, and architecture patterns.

Spec-Driven Development and Specifications

Specifications turn research into development by making the definition of good explicit, inspectable, and testable before code is written.

AI-Driven Development Lifecycle for Financial Services

AI-DLC shows how AI agents can coordinate more of the software lifecycle while humans keep governance, judgment, and accountability.