Llm | Roy Gabriel

Agent Swarms: The New Workforce Architects and Engineers Must Lead

Thu, 26 Feb 2026 13:00:00 -0500

As-of note: This is a production engineering perspective based on building and running agent swarms in production in early 2026. The workflows, numbers, and fine-tuning example come from real runs on my hardware and standards.

Why this shift keeps showing up

If you build production systems long enough, you see the same pattern:

The “tool choice” is not what breaks velocity.
The operational model and who does the work usually are.

When architects and engineers compare traditional coding to agent swarms, they are really asking:

“What will it cost to ship features at scale in the next 12 to 36 months, and who will actually build them?”

Single agents autocomplete code. Agent swarms plan features, assign tasks, review security, run tests, and deploy. The output is cleaner and more consistent than what most senior engineers produce alone.

Anthropic’s 2026 Agentic Coding Trends Report shows single agents evolving into coordinated teams that handle long-running tasks across the full development lifecycle. Multi-agent orchestration is the breakthrough.

Forbes reported in December 2025 that Gartner expects 40 percent of enterprise applications to embed task-specific agents by the end of 2026. Orchestrated swarms already deliver 30 to 50 percent faster feature delivery in early adopters.

O’Reilly’s Signals for 2026 confirms the pattern: engineers move from writing code to orchestrating agents. Fundamentals stay essential. The difference is scale.

TL;DR

Agent swarms already build production code at higher quality and speed than the top 1 percent of FAANG engineers.
The new job is writing precise specs, designing the agent workforce, and verifying outcomes.
I built Cruvero exactly for this model. It is the production control plane that manages swarms in production.
In one run I used Cruvero to prep my entire personal knowledge base and fine-tune Qwen2.5-Coder-72B on two RTX 5090 GPUs. The resulting model now writes code exactly to my standards.
Cruvero will be released as open source in the next two weeks so anyone can run the same production-grade agent swarm control plane.
Start today or watch the gap widen.

What Agent Swarms Do Today
Cruvero as the Working Example
The New Role for Architects and Engineers
Why You Must Start Today
References

What Agent Swarms Do Today

A single agent writes a function. A swarm plans an entire feature, breaks it into tasks, assigns roles, iterates on failures, runs tests, and deploys. The output is cleaner, more consistent, and more reliable than what most senior engineers produce alone.

Multi-agent orchestration lets one agent plan, another implement, a third review for security, and a fourth measure performance. They collaborate without human prompts for hours or days.

Cruvero as the Working Example

Over the last 2 months on weekends and nights, I built Cruvero as a full workflow builder and the complete DevOps/SRE agent swarm platform. It is 350k lines of clean Go and React running as a production control plane, with a clean UI and API layer for knowledge bases, multi-agent runs, agent registration, cost tracking, flows, and MCP bindings in Kubernetes. In early 2026, I have not seen another platform that ships this full stack in one place.

Core capabilities include:

Knowledge bases that store versioned domain context so agents never repeat mistakes
Runs page for launching, monitoring, and intervening in complex multi-agent workflows with patterns like Delegate
Agents page that lets you register, trust-score, deploy, and bind agents directly from the UI
Incident triage that runs faster than human response, then posts root-cause analysis and recommended fixes directly into Slack or Microsoft Teams
Pre-run previews, compliance checks, per-agent overrides, full audit trails, and cost tracking

This turns raw agent swarms into a manageable, auditable workforce. This week the platform reached the point where its own agent swarms are building new features inside Cruvero itself.

In one recent run, a swarm of 12 agents took a high-level spec for a new MCP gateway, generated the Go handlers, added observability, wrote tests, and produced a Helm chart ready for deployment. The entire process took 47 minutes. I reviewed the plan, approved two overrides, and signed off. The code passed every gate I set.

Here is a concrete example of how deeply I integrated my own standards. This week I used Cruvero to create a domain-specific fine-tuned model. I pointed the swarm at my private knowledge base: every personal(not employer code) code example I have written in the last five years, my strict documentation standards (every public function must include invariants, performance notes, and failure modes in a precise JSDoc format), my architecture standards (hexagonal with CQRS and explicit boundaries), and my full infrastructure layout (multi-region Kubernetes with Cilium CNI, ArgoCD GitOps, external secrets, and cross-cluster service mesh using Istio).

The swarm prepped the entire dataset in 18 minutes. It extracted, cleaned, deduplicated, and converted everything into instruction-response pairs that perfectly match the way I write and review code. Then it launched a QLoRA fine-tune of Qwen2.5-Coder-72B across my two RTX 5090 GPUs. The training completed overnight. The resulting model, now called Cruvero -Gabriel-72B, is registered directly inside the agent swarm as a first-class capability.

When I give the swarm a new spec today, it calls my fine-tuned model for every code generation step. The output follows my exact coding style, documentation format, architecture patterns, and infrastructure conventions without any manual correction. The swarm literally thinks and builds like I do, at 100 times the speed.

Cruvero will be released as open source in the next two weeks so any engineer or team can self-host the same production-grade agent swarm control plane I use daily.

The New Role for Architects and Engineers

You will spend your time on three things:

Write precise specification documents. Define goals, constraints, acceptance criteria, security boundaries, and stop rules. These become the source of truth the swarm follows.
Design the agent workforce. Choose which agents handle planning, implementation, review, and verification. Set trust scores, capabilities, and escalation paths.
Verify and steer. Run preflight checks, inspect outputs against intent, and adjust the swarm in real time. Your judgment determines whether the final system meets business needs.

This is harder than writing code. It requires deep systems thinking, clear communication, and production discipline. The best architects already excel at it. The rest must learn fast.

Pragmatic Engineer noted in January 2026 that teams where AI writes 90 percent of the code still need senior engineers for architecture decisions and coherence. Karpathy has said the same: technical expertise becomes more valuable because skilled people extract far more from agents.

Why You Must Start Today

The gap between those who manage agent swarms and those who do not will widen quickly. In 12 months, the best teams will ship features that used to take quarters. In 36 months, organizations without swarm capability will struggle to compete on velocity and quality.

Start small. Take one workflow you own. Break it into phases. Build a prompt library. Run a swarm on a non-critical task. Measure the output against your own work. Iterate.

The tools exist now: Claude Code, Codex, open MCP gateways, and platforms like Cruvero . The question is whether you will lead the workforce or watch someone else do it.

The next generation of software systems will be built by agent swarms under human direction. Architects and engineers who master this model will define the future. Those who wait will find their skills replaced.

The shift is here. Lead it.

References

Anthropic. 2026 Agentic Coding Trends Report. January 2026.
Minevich, Mark. “Agentic AI Takes Over — 11 Shocking 2026 Predictions.” Forbes. December 31, 2025.
O’Reilly Media. “Signals for 2026.” January 9, 2026.
Various sources on Karpathy statements compiled in Pragmatic Engineer and The New Stack, 2025–2026.

LLM Development Guide

Mon, 16 Feb 2026 12:00:00 -0500

This series turns LLM assistance into something you can run repeatedly without losing context.

You will be able to:

Turn vague work into explicit plans with verification and stop rules.
Write prompt documents that survive across sessions and handoffs.
Run large projects with phase documents and phase implementation prompt sets.
Preserve state with work notes so you can resume deterministically.
Execute in small units with review discipline and commit discipline.

Last updated: 2026-02-16

Questions? Contact me via my site contact form.

Found an issue? Open a GitHub issue.

Chapter 16: Worked Example: Converting an Ansible Playbook to a Go Temporal Workflow

Fri, 13 Feb 2026 09:00:00 -0500

Series: LLM Development Guide

Chapter 16 of 16

Previous: Chapter 15: Worked Example: Creating a Helm Chart From a Reference Chart

What you’ll be able to do

You’ll be able to migrate a procedural automation (for example, an Ansible playbook) into a durable Temporal workflow:

Extract discrete steps from the playbook.
Map steps to activities.
Implement a workflow that follows your team’s existing Temporal patterns.
Add verification and tests so the migration is not faith-based.

TL;DR

Start from a working reference workflow in your repo.
Paste both the playbook and the reference into the planning prompt.
Define activities first, then the workflow.
Verify with Temporal workflow tests and any integration checks you can run safely.

Scenario
Reference inputs
Plan and phase structure
Implementation skeleton (Go)
Verification
Gotchas

Scenario

Example: convert a playbook that creates a Kubernetes namespace and resource quota into a Temporal workflow.

Why this is a good fit:

Work is step-based.
You want retries and observability.
You want an execution history.

Reference inputs

Paste these into your planning prompt:

The playbook file (or the relevant section): playbooks/create-namespace.yml.
A reference workflow file that represents your team’s patterns.
A reference activity implementation file (if you have one).

Suggested commands:

sed -n '1,200p' playbooks/create-namespace.yml

sed -n '1,200p' internal/workflows/provision_cluster.go

ls -la internal/activities || true

Plan and phase structure

A reasonable phase split:

Phase 1: define activity I/O and implement activities.
Phase 2: implement workflow with retries and timeouts.
Phase 3: add tests.
Phase 4: register and deploy.

The plan should include verification per phase.

Implementation skeleton (Go)

This is a minimal skeleton to illustrate structure. It is intentionally not a full program.

package workflows

import (
 "time"

 "go.temporal.io/sdk/temporal"
 "go.temporal.io/sdk/workflow"
)

type CreateNamespaceInput struct {
 Namespace string
 CPULimit string
 MemLimit string
}

type CreateNamespaceOutput struct {
 Namespace string
}

// CreateNamespaceWorkflow orchestrates namespace creation.
// It assumes there are activities registered for create + quota + verify.
func CreateNamespaceWorkflow(ctx workflow.Context, input CreateNamespaceInput) (*CreateNamespaceOutput, error) {
 logger := workflow.GetLogger(ctx)
 logger.Info("starting namespace workflow", "namespace", input.Namespace)

 ctx = workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
 StartToCloseTimeout: 10 * time.Minute,
 RetryPolicy: &temporal.RetryPolicy{
 MaximumAttempts: 3,
 },
 })

 // Pseudocode: adapt to your activity names and input/output types.
 // var nsResult activities.CreateNamespaceOutput
 // err := workflow.ExecuteActivity(ctx, activities.CreateNamespace, activities.CreateNamespaceInput{...}).Get(ctx, &nsResult)
 // if err != nil { return nil, err }

 // var quotaResult activities.CreateResourceQuotaOutput
 // err = workflow.ExecuteActivity(ctx, activities.CreateResourceQuota, activities.CreateResourceQuotaInput{...}).Get(ctx, &quotaResult)
 // if err != nil { return nil, err }

 // var verifyResult activities.VerifyNamespaceOutput
 // err = workflow.ExecuteActivity(ctx, activities.VerifyNamespace, activities.VerifyNamespaceInput{...}).Get(ctx, &verifyResult)
 // if err != nil { return nil, err }

 return &CreateNamespaceOutput{Namespace: input.Namespace}, nil
}

Notes:

The workflow.ExecuteActivity calls are left as pseudocode because activity package names and types are repo-specific.
Keep the skeleton syntactically correct.
Use your reference workflow as the style guide.

Verification

Your verification should include at least one of these:

Temporal workflow unit tests (Temporal test framework).
Activity unit tests (mock external systems).
A safe integration test against a non-production environment.

Example commands (adapt to your repo):

# Run unit tests.
go test ./...

# If you have a focused workflow test package.
go test ./internal/workflows -run TestCreateNamespaceWorkflow

Expected results:

Tests exit with code 0.
Failures are actionable (not timeouts with no logs).

Gotchas

If you skip the reference workflow, your new workflow will not match team patterns.
If you skip tests, you will not know whether retries and timeouts behave correctly.
LLMs will happily invent Temporal APIs. Verify imports and method names exist in your actual SDK version.

Cruvero - AI Agent Ecosystem Platform

Thu, 12 Feb 2026 19:25:00 -0500

Summary

Cruvero is a production-grade AI agent orchestration platform I designed and built from the ground up in Go. It treats durability, observability, and operational control as infrastructure guarantees, not library afterthoughts.

Where frameworks like LangGraph bolt checkpointing onto a graph abstraction, Cruvero inverts the model: Temporal’s battle-tested workflow engine is the foundation, and the agent abstraction compiles down to it. The result is a platform where retry logic, failure recovery, human-in-the-loop approval, and multi-agent coordination aren’t library features; they’re infrastructure guarantees backed by the same technology that runs Uber’s and Stripe’s most critical workflows.

The system currently spans 90,000+ lines of Go and TypeScript, with a comprehensive React UI, Kubernetes deployment via Helm and ArgoCD, and an enterprise MCP gateway architecture designed to support 1,000+ concurrent agents across 150+ integrations.

The Problem

Every major agent framework optimizes for the same thing: time-to-demo. Spin up a LangGraph chain, wire a few tools, get a result in 30 seconds. Impressive on a slide. Catastrophic in production.

The failure modes are predictable. An agent workflow running for 40 minutes crashes mid-execution; state is gone. A tool call to an external API times out; the entire run fails with no recovery. A billing-sensitive agent hallucinates a $50,000 API call; no cost guardrails existed to stop it. An agent enters a reasoning loop, calling the same tool 15 times with near-identical arguments; nothing detects the degeneration.

These aren’t edge cases. They’re the baseline reality of running AI agents at enterprise scale. Cruvero was built to make them structurally impossible.

Architecture

Cruvero’s architecture is layered around a single principle: every agent action is a Temporal activity, and every workflow survives infrastructure failure by default.

Core Runtime: The agent loop follows a deterministic decide → act → observe → repeat state machine. Each cycle produces an immutable DecisionRecord with content-addressed hashes of the prompt, state, tool schemas, and model config. This gives you complete forensic capability: for any decision an agent made, you can see the exact inputs, replay the decision with a different model, or run counterfactual analysis (“what if it had chosen differently at step 4?”).

Durable Execution: Temporal manages all workflow state. Agent runs survive process crashes, worker restarts, and infrastructure failures transparently. Long-running workflows (minutes to hours) use continue-as-new with automatic state compaction. There is zero data loss on agent failure, guaranteed by Temporal’s event sourcing, not by application-level retry logic.

Multi-Agent Coordination: A first-class supervisor pattern supports seven coordination strategies: delegate, broadcast, debate, pipeline, map-reduce, voting, and saga with compensation. Agents communicate through signals, shared blackboard state, and pub/sub events. A supervisor can launch child agents, aggregate their results, and handle partial failures; all as durable Temporal workflows with full replay capability.

Graph DSL & Workflow Engine: A custom graph DSL compiles structured execution plans (steps, conditional routes, parallel branches, join semantics, subgraphs) into Temporal workflows. Join modes include all, any, N-of-M, and voting. The visual workflow builder (React Flow) provides bidirectional serialization between the visual canvas and the underlying graph definition.

Neuro-Inspired Intelligence

This is the feature set that no other agent framework implements. Drawing from neuroscience and cognitive architecture research, this layer introduces eight subsystems that fundamentally change how agents reason, learn, and self-correct.

Metacognitive Monitoring: Modeled on prefrontal cortex performance monitoring. The system tracks tool call hashes, observation hashes, progress deltas, confidence entropy, and goal-drift scores (via embedding cosine similarity against the original prompt). When it detects degradation, such as repetition loops, stalled progress, drifting goals, or collapsing confidence, it triggers graduated backpressure: forced reflection, model escalation (swap to a more capable model mid-run), context reset, mandatory strategy pivots, or human escalation. No more agents spinning their wheels for 200 steps.

Attention-Weighted Context Windows: Inspired by hippocampal memory replay. Instead of dumping context linearly into the prompt, a multi-factor salience scorer (relevance, recency, confidence, usage frequency) re-ranks all memory before assembly. A dynamic token budget allocator shifts allocation by task phase. Planning phases boost semantic/procedural memory, execution phases boost tool schemas, and review phases boost episodic memory. An interference detector flags contradictory facts explicitly in the prompt rather than letting the LLM silently pick one.

Temporal Reasoning: Deadline-aware execution with soft and hard deadlines, graduated pressure levels (relaxed through critical), automatic model switching under time pressure, and structured time context injection into every prompt.

Agent Immune System: Anomaly signature tracking with automatic tool quarantine. When a tool’s behavior degrades or produces anomalous outputs, the immune system hashes the failure pattern, tracks hit counts, and quarantines the tool after a configurable threshold. A vaccination CLI injects procedural memory to teach agents how to work around quarantined capabilities.

Compositional Tool Synthesis: Meta-tools that chain multiple tool calls into atomic pipelines with pre/postcondition contracts, typed argument mapping, and enforcement of non-retryable errors on contract violations.

Federated Trust & Delegation: Trust scoring for multi-agent delegation. Agents build trust through successful task completion; supervisors automatically select agents based on capability manifests and accumulated trust scores. Delegation chains provide full accountability tracking for post-mortem analysis.

Execution Provenance Graph: A tamper-evident DAG tracking every action, decision, and data dependency in an agent run. Supports ancestor/descendant queries, subgraph extraction, and run diffing to compare two executions and identify the exact point of divergence.

Enterprise Governance

Cruvero’s enterprise hardening philosophy is “tenant isolation is a property of the architecture, not a feature.” Every boundary is enforced at the infrastructure layer.

Multi-Tenancy & Namespace Isolation: Temporal namespaces, Postgres row-level security, and network policies enforce tenant boundaries. Per-tenant model selection, tool access control, and resource quotas are infrastructure-level guarantees that cannot be bypassed by application code.

Rate Limiting, Quotas & Cost Guardrails: Per-decision cost tracking (estimated and actual) with configurable policies: max cost per run, max cost per step, prefer-cheaper-model flags. Budget enforcement halts runs before they exceed limits. A model catalog with pricing metadata enables real-time cost optimization across providers.

Audit Logging & Compliance: Every tool call, LLM invocation, and state mutation is authenticated, authorized, and recorded in a tamper-evident audit trail. SOC 2-ready export formats. PII detection across five enforcement boundaries (audit, output, tool I/O, memory, events) with 12 PII types, unified secret detection, Shannon entropy analysis, HMAC-based stable tokenization, and a risk scoring engine.

Security Hardening: OWASP Top 10 mitigations, RBAC with four role levels (Viewer, Editor, Admin, Super Admin), OIDC authentication, CSRF protection, input sanitization, and CSP headers.

Tool Ecosystem & MCP Integration

Semantic Tool Discovery: A three-stage pipeline (keyword search → embedding similarity → quality-weighted reranking) selects tools dynamically rather than dumping all tool schemas into every prompt. Tool quality tracking quarantines degraded tools automatically.

MCP Protocol: 150+ Model Context Protocol integrations (Notion, GitHub, AWS, Azure, O365, ServiceNow, Slack, and more) with standardized tool interfaces. The current architecture uses stdio subprocesses; the enterprise target architecture introduces a gateway-mediated Streamable HTTP model with per-integration scaling, Dragonfly response caching, circuit breakers, Vault-backed credential isolation, and KEDA autoscaling, designed for 1,000+ concurrent agents.

Event-Driven Architecture: NATS provides async event fan-out alongside Temporal’s durable execution. MCP server lifecycle management, embedding pipeline intake, audit/telemetry buffering, and external consumer subscriptions (Teams/Telegram bots, dashboards, webhook relays) all flow through NATS, without ever entering the workflow deterministic path.

Observability & Operations

Distributed Tracing: OpenTelemetry spans per decision cycle, tool call, memory operation, and MCP invocation. Full correlation IDs from workflow entry through every activity.

Structured Logging: Zap-based structured logging with per-tenant, per-run, and per-step context propagation.

Production API: RESTful API with automatic OpenAPI 3.1 documentation, SSE streaming for live run updates, and comprehensive endpoints for run management, approval workflows, replay, tracing, cost queries, and tool management.

React Operational UI: A full-featured React 18 / TypeScript interface replacing the original htmx console. Surfaces every runtime capability: run management with live SSE streaming, approval queues, replay console with counterfactual analysis, causal trace explorer, tool registry browser, memory explorer with salience scores, cost dashboards (ECharts), supervisor multi-agent visualization, visual workflow builder (React Flow), live workflow inspection, speculative execution, and differential model testing.

Kubernetes Deployment: Helm chart with environment-aware value overlays, ArgoCD ApplicationSet for GitOps promotion (dev/staging/prod), ServiceMonitor templates, and ingress configuration.

Key Decisions

Go over Python: Single-binary deploys, predictable latency, deterministic resource usage, and a strong concurrency model for managing hundreds of concurrent agent sessions. No GIL, no dependency hell, no runtime surprises.

Temporal over custom durability: Rather than implementing checkpointing, retry logic, and state recovery as library features, Cruvero delegates all of it to Temporal’s battle-tested workflow engine. This is the same infrastructure that runs mission-critical systems at companies processing millions of transactions per day.

Neuroscience-grounded intelligence: The cognitive architecture isn’t marketing. Each subsystem maps to a specific neuroscience principle (prefrontal monitoring, hippocampal salience, temporal reasoning, immune response). The result is agents that self-correct, learn from failures, and degrade gracefully, capabilities no other framework offers.

Context management as a competitive advantage: Most frameworks dump everything into the context window and pray. Cruvero’s context pipeline includes phase-aware budget allocation, five-component salience scoring, semantic tool search, interference detection, observation masking, and proactive compression triggers. The competitive analysis shows clear advantages over LangChain/LangGraph across every dimension.

Outcome

Cruvero runs production agent workloads with infrastructure-grade reliability guarantees. The platform handles long-running workflows (minutes to hours), survives arbitrary infrastructure failures without data loss, enforces per-tenant cost and security policies, and provides complete observability from workflow entry through every LLM decision and tool call.

The codebase represents 90,000+ lines of production code, 80%+ test coverage, comprehensive documentation published via Hugo, and a development methodology designed for systematic LLM-assisted engineering at scale.

Stack

Go · Temporal · PostgreSQL · NATS · React 18 · TypeScript · Vite · React Flow · ECharts · Tailwind CSS · Kubernetes · Helm · ArgoCD · Qdrant · Dragonfly · Ollama · OpenTelemetry · Zap · Keycloak · Docker

Chapter 15: Worked Example: Creating a Helm Chart From a Reference Chart

Wed, 11 Feb 2026 07:00:00 -0500

Series: LLM Development Guide

Chapter 15 of 16

Previous: Chapter 14: Building a Prompt Library: Governance + Quality Bar

Next: Chapter 16: Worked Example: Converting an Ansible Playbook to a Go Temporal Workflow

What you’ll be able to do

You’ll be able to create a production-quality Helm chart by following an existing chart in your repo as the reference:

Gather high-signal reference inputs.
Produce a phased plan and prompt docs.
Execute in reviewable commits.
Verify the chart renders and lints cleanly.

TL;DR

The reference chart is the source of truth for structure and conventions.
Paste the reference inputs into your planning prompt.
Execute one file at a time, with helm lint and helm template as gates.
If you do not have a real reference chart, pick a different worked example.

Scenario
Reference inputs
Phase 1: Plan
Phase 2: Prompt docs
Phase 3: Execute in logical units
Verification
Gotchas

Scenario

Goal: create a new chart (example: metrics-gateway) based on a known-good reference chart (example: event-processor).

This is a workflow example. You will need to substitute your real chart names and paths.

Reference inputs

Run these commands in your repo and paste the output into the planning prompt.

# Chart structure and key files.
tree charts/event-processor/

sed -n '1,200p' charts/event-processor/Chart.yaml

sed -n '1,200p' charts/event-processor/values.yaml

sed -n '1,200p' charts/event-processor/templates/_helpers.tpl

# If your reference chart uses these, include them too.
ls -la charts/event-processor | rg -n "values-" || true

Why this matters:

Structure: avoids “generic Helm” output.
Naming and labels: keeps your charts consistent.
Values shape: keeps operator UX consistent.

Phase 1: Plan

Create a plan that is mostly:

What files will exist.
What differences are specific to metrics-gateway (ports, probes, resources).
How you will verify each phase.

Example plan skeleton:

# metrics-gateway Helm Chart Plan

## Goals
- Create charts/metrics-gateway matching reference structure.
- Render successfully with helm template.
- Lint cleanly.

## References
- charts/event-processor/

## Phase 1: Analysis
- [ ] Document naming conventions from reference.

Verification:
- tree charts/event-processor

## Phase 2: Scaffold
- [ ] Create Chart.yaml
- [ ] Create values.yaml
- [ ] Create templates/_helpers.tpl

Verification:
- helm lint charts/metrics-gateway

## Phase 3: Core templates
- [ ] deployment
- [ ] service
- [ ] configmap

Verification:
- helm template charts/metrics-gateway > /tmp/rendered.yaml

## Definition of done
- [ ] helm lint exits 0
- [ ] helm template exits 0

Phase 2: Prompt docs

Generate one prompt file per phase. Include:

The plan path.
The work-notes path.
Reference chart file paths.
Deliverables (exact files).
Constraints (MUST and MUST NOT).
Verification commands.

A good constraint to include:

“Match reference structure exactly.” (and name what that means)

Phase 3: Execute in logical units

You have two implementation strategies.

Strategy A (recommended): copy the reference chart, then adapt

This is often the fastest way to guarantee structure consistency.

cp -R charts/event-processor charts/metrics-gateway

# Then rename strings and values in a controlled way.
# Review each replacement before committing.
rg -n "event-processor" charts/metrics-gateway

Now execute in logical units:

Update Chart.yaml.
Update values.yaml.
Update _helpers.tpl.
Update one template file at a time.

For each logical unit:

Update work notes.
Run helm lint.
Propose a commit.

Strategy B: scaffold from scratch, guided by the reference

Use this when copying would bring too much baggage.

You still paste the reference files, but ask the model to reproduce the structure explicitly.

Verification

Run both linting and rendering.

helm lint charts/metrics-gateway

helm template charts/metrics-gateway > /tmp/metrics-gateway.rendered.yaml

test -s /tmp/metrics-gateway.rendered.yaml

Expected results:

All commands exit with code 0.
The rendered YAML is non-empty.

Optional: diff against the reference chart structure:

# Compare structure only.
(cd charts/event-processor && find . -type f | sort) > /tmp/ref-files.txt
(cd charts/metrics-gateway && find . -type f | sort) > /tmp/new-files.txt

diff -u /tmp/ref-files.txt /tmp/new-files.txt || true

Expected result:

The file lists are close, with only intentional differences.

Gotchas

If you do not paste the reference files, you will get generic charts.
Be explicit about service ports, probe paths, and resource defaults.
Add negative constraints (“do not add ingress yet”) so scope doesn’t expand.

Continue -> Chapter 16: Worked Example: Converting an Ansible Playbook to a Go Temporal Workflow

Chapter 14: Building a Prompt Library: Governance + Quality Bar

Mon, 09 Feb 2026 06:00:00 -0500

Series: LLM Development Guide

Chapter 14 of 16

Previous: Chapter 13: Templates + Checklists: The Copy/Paste Kit

Next: Chapter 15: Worked Example: Creating a Helm Chart From a Reference Chart

What you’ll be able to do

You’ll be able to build a prompt library that doesn’t turn into a junk drawer:

Organize prompts by task type.
Define a consistent prompt entry format.
Set a contribution and maintenance policy.

TL;DR

A prompt library is a shared collection of prompts proven in real usage.
Require prereqs, recommended model tier, expected output, and common failure fixes.
Assign maintainers.
Version prompts with a changelog.

Library structure
Prompt entry template
Contribution guidelines
Governance
Verification

Library structure

A simple layout that scales:

prompt-library/
 README.md
 CONTRIBUTING.md
 planning/
 implementation/
 testing/
 review/
 debugging/

Keep it boring. Avoid inventing new categories every week.

Prompt entry template

Require a consistent format so prompts are reusable:

# <Task Name>

## When to use

## Prerequisites
-

## Recommended model tier

## The prompt

## Customization points

## Expected output

## Common issues and fixes

## Examples

## Changelog
- YYYY-MM-DD: <what changed>

Contribution guidelines

Set a quality bar:

A prompt must have been used successfully multiple times.
It must specify required reference files.
It must include verification.
It must include common failure modes and fixes.

A contribution checklist:

Used successfully 3+ times.
Another person can run it with the listed prereqs.
Changelog updated.

Governance

If nobody owns it, it rots.

Assign 1 to 2 maintainers to:

Review new prompts.
De-duplicate similar prompts.
Archive prompts that no longer work.
Run a quarterly cleanup.

Verification

Bootstrap the skeleton:

mkdir -p prompt-library/{planning,implementation,testing,review,debugging}

touch prompt-library/README.md

touch prompt-library/CONTRIBUTING.md

cat > prompt-library/planning/new-task.md <<'MD'
# New Task Planning

## When to use

## Prerequisites

## Recommended model tier

## The prompt

## Verification
MD

Expected result:

You have a real place to put prompts that worked, with enough structure to keep it maintainable.

Continue -> Chapter 15: Worked Example: Creating a Helm Chart From a Reference Chart

Chapter 13: Templates + Checklists: The Copy/Paste Kit

Sat, 07 Feb 2026 04:00:00 -0500

Series: LLM Development Guide

Chapter 13 of 16

Previous: Chapter 12: Team Collaboration: Handoffs, Shared Prompts, and Review

Next: Chapter 14: Building a Prompt Library: Governance + Quality Bar

What you’ll be able to do

You’ll be able to bootstrap the workflow in minutes:

Create plan/, prompts/, and work-notes/ with consistent templates.
Add a phase spec template for large, multi-phase projects.
Add a phase implementation prompt template for prompt-by-prompt execution.
Use session start and end checklists.
Generate PR descriptions that explain intent and verification.

TL;DR

Templates reduce prompt drift.
Keep them short and consistent.
Add verification to every phase.
For large projects, pair phase specs with implementation prompt docs.

Plan template
Prompt template
Phase spec template (large projects)
Phase implementation prompt template (large projects)
Work notes template
Session checklists
PR description template
Verification

Plan template

# <Project> Plan

## Overview

## Goals
-

## Context
- Reference implementation:
- Environment:

## Phases

## Definition of done
- [ ]

## Out of scope
-

## Risks / open questions
-

Prompt template

# Phase <X> - <Name>

## Role

## Context
- Plan:
- Work notes:
- References:

## Task

## Deliverables
1.

## Constraints
- MUST
- MUST NOT

## Session management
Update work notes with decisions, assumptions, open questions, and a session log entry.

## Verification
- Command:
- Expected:

## Commit discipline
Propose a commit message and wait for approval.

Phase spec template (large projects)

# Phase <N><Letter> - <Phase Name>

## Status
Planned

## Depends on
- <Phase dependency>

## Feature flag
- <flag name or n/a>

## Migration
- <none or required steps>

## Design rationale
<Why this phase exists and what risk it reduces>

## Tasks
### Prompt 1
- <task>

### Prompt 2
- <task>

## Files
### New
- <path>

### Modified
- <path>

### Referenced (read-only)
- <path>

## Exit criteria
- [ ] <build command> exits 0
- [ ] <vet/lint command> exits 0
- [ ] <test command> exits 0
- [ ] No ignored returned errors

## Progress notes

Phase implementation prompt template (large projects)

# Phase <N><Letter> - Implementation Prompts

Complete prompts sequentially. Do not continue when verification fails.

## Prompt 1 of <Total>: <Prompt Name>

Context files to load:
- <4 to 6 explicit paths>

Task:
- <exact implementation task>

Constraints:
- Stay within this prompt's scope.
- Handle all returned errors.
- Keep code small and reviewable.
- Do not proceed to the next prompt until verification passes.

Verification:
- <build command>
- <vet/lint command>
- <test command>

Commit discipline:
- Summarize what changed.
- Propose commit message.
- Wait for approval before moving on.

Work notes template

# Phase <X> - <Name>

## Status
- [ ] Not started
- [ ] In progress
- [ ] Blocked
- [ ] Complete

## Decisions

## Assumptions

## Open questions

## Session log

## Commits

Session checklists

Session start:

Identify the phase.
Load the phase prompt.
Load the current work notes.
Re-state the smallest goal for this session.

Session end:

Work notes updated.
Decisions logged with rationale.
Verification run.
Commits made (or clearly blocked).
Next step written down.

PR description template

## Summary

## Changes
-

## Out of scope
-

## Verification
-

## Review guide

## Follow-up
- [ ]

## References
- Work notes:
- Plan:

Verification

Create a local templates/ folder and seed the files:

mkdir -p templates

cat > templates/PLAN-template.md <<'MD'
# Project Plan

## Overview

## Goals

## Phases

## Definition of done
MD

cat > templates/PROMPT-template.md <<'MD'
# Phase - Prompt

## Role

## Context

## Task

## Constraints

## Verification

## Commit discipline
MD

cat > templates/WORK-NOTES-template.md <<'MD'
# Phase - Work Notes

## Status

## Decisions

## Session log
MD

Expected result:

You can start a new project by copying these templates and editing the placeholders.

Continue -> Chapter 14: Building a Prompt Library: Governance + Quality Bar

Chapter 12: Team Collaboration: Handoffs, Shared Prompts, and Review

Thu, 05 Feb 2026 02:00:00 -0500

Series: LLM Development Guide

Chapter 12 of 16

Previous: Chapter 11: Measuring Success: Solo + Team Metrics Without Fake Precision

Next: Chapter 13: Templates + Checklists: The Copy/Paste Kit

What you’ll be able to do

You’ll be able to run this workflow on a team without turning it into process theater:

Hand off work mid-phase without a meeting.
Share prompts that actually work.
Review LLM-assisted code with the same rigor as human code.

TL;DR

Teams fail at LLM work because chat context is not shareable.
Plans, prompt docs, and work notes make context portable.
Keep review focused on code and verification, not on how the code was produced.
Maintain a small set of “golden” reference implementations.

Handoff patterns
Shared prompt libraries
Review checklist
Verification

Handoff patterns

Mid-phase handoff

If you hand off in the middle of a phase, provide:

Updated work notes with status, decisions, open questions, and exact next step.
The phase prompt doc.
The reference implementation paths used.
Any verification output (test results, lint output).

Handoff template:

## Handoff: <Phase>

### Status
<What's done, what's in progress, what's blocked>

### Files to review
- <file 1>
- <file 2>

### Key decisions
- <Decision>: <Rationale>

### Open questions
- [ ] <Question>

### Immediate next step
<Exact command or file edit to do next>

### How to resume
1. Load prompts/<phase>.md
2. Load work-notes/<phase>.md
3. Continue from the last session log entry

Phase boundary handoff

Phase boundary handoffs are easier:

Work notes are marked complete.
The next phase starts cleanly.

Shared prompt libraries

A shared library reduces rework and increases consistency.

A reasonable structure:

prompt-library/
 planning/
 implementation/
 testing/
 review/

Quality bar:

Prompts are specific enough to be useful.
Prompts are general enough to be reused.
Prompts record “when to use” and “prereqs”.
Prompts have been used successfully multiple times.

Review checklist

LLM-assisted work should be reviewed like any other work.

High-signal checks:

Imports and APIs exist (no hallucinations).
Error handling is complete.
Output matches reference patterns.
Verification was actually run.
Commits are atomic and explain intent.
Tests test behavior, not just existence.

Verification

Create a shared template file so handoffs are consistent:

mkdir -p docs

cat > docs/llm-handoff-template.md <<'MD'
# LLM Work Handoff Template

## Phase

## Status

## Files to review

## Key decisions

## Open questions

## Verification run
- <command>
- Expected: <...>

## Next step

## How to resume
- Prompt:
- Work notes:
- References:
MD

Expected result:

Anyone can hand off work in under five minutes.

Continue -> Chapter 13: Templates + Checklists: The Copy/Paste Kit

Chapter 11: Measuring Success: Solo + Team Metrics Without Fake Precision

Tue, 03 Feb 2026 00:00:00 -0500

Series: LLM Development Guide

Chapter 11 of 16

Previous: Chapter 10: Stop Rules + Pitfalls: When to Upgrade, Bail, or Go Manual

Next: Chapter 12: Team Collaboration: Handoffs, Shared Prompts, and Review

What you’ll be able to do

You’ll be able to tell, with reasonable honesty, whether the workflow is helping:

Pick a small set of metrics you can actually measure.
Separate leading indicators (process) from lagging indicators (outcomes).
Avoid fake precision and vanity metrics.

TL;DR

If you can’t measure reliably, don’t invent numbers.
Track a baseline (a few representative tasks) before you claim improvement.
Favor cheap metrics: time to first commit, PR revision rounds, post-merge bugs.
Use leading indicators daily; use lagging indicators in retros.

What to measure
Solo baseline
Leading vs lagging indicators
Lightweight reporting template
Verification

What to measure

Pick a small set that maps to real outcomes.

Velocity indicators:

Time to first commit.
Phase completion time.
PR cycle time.

Quality indicators:

PR revision rounds.
Bugs caught in review.
Post-merge bugs.

Efficiency indicators:

Rework rate (time fixing output vs total time).
Session count per task.
Handoff success (can someone else continue without re-explaining).

Solo baseline

If you’re working solo, you can still create a baseline.

Track per task:

Start time.
First commit time.
Total time to done.
Number of “LLM retries” (how many prompt iterations for the same logical unit).
Bugs you found after “done”.

The point is not perfect measurement. The point is noticing patterns.

Leading vs lagging indicators

Leading indicators predict success:

Work notes are updated.
Prompts contain verification.
Commits are atomic.
References are provided.

Lagging indicators confirm success:

PR merged with low rework.
Low post-merge bug rate.
Handoffs succeed.

Lightweight reporting template

## LLM-Assisted Development Summary (Month)

### Adoption
- Tasks completed with workflow: <N>

### Velocity
- Median time to first commit: <X>
- Median PR cycle time: <Y>

### Quality
- Median PR revision rounds: <Z>
- Post-merge bugs: <N>

### Costs
- LLM cost estimate: <X>

### Notes
- What worked:
- What failed:
- Changes for next month:

Verification

Keep a simple CSV so you can graph later if you want.

mkdir -p work-notes

cat > work-notes/metrics.csv <<'CSV'
date,task,time_to_first_commit_minutes,total_time_minutes,llm_retries,pr_revision_rounds,post_merge_bugs,notes
CSV

Expected result:

You can append one row per task in under a minute.

Continue -> Chapter 12: Team Collaboration: Handoffs, Shared Prompts, and Review

Chapter 10: Stop Rules + Pitfalls: When to Upgrade, Bail, or Go Manual

Sat, 31 Jan 2026 23:00:00 -0500

Series: LLM Development Guide

Chapter 10 of 16

Previous: Chapter 9: Security & Sensitive Data: Sanitize, Don’t Paste Secrets

Next: Chapter 11: Measuring Success: Solo + Team Metrics Without Fake Precision

What you’ll be able to do

You’ll be able to avoid the two common failure outcomes:

Spending hours fighting the model.
Shipping output you can’t review.

You’ll do it with explicit stop rules, upgrade triggers, and a short recovery checklist.

TL;DR

If the change is under a minute manually, do it manually.
If you can’t review the output competently, don’t ship it.
If you’re on your third attempt for the same logical unit, upgrade or re-scope.
Add verification steps to plans and prompts so “done” is testable.

Stop rules
Top pitfalls
Recovery checklist
Verification

Stop rules

These are pragmatic defaults. Tune them to your environment.

Stop rule 1: tiny changes

If it is a tiny change (one line, one rename, one version bump), do it manually.

LLM overhead is real:

You still have to explain.
You still have to review.
You still have to verify.

Stop rule 2: you can’t review it

Never commit code you could not explain in a review.

If you don’t understand the domain:

break the work into smaller pieces you can understand, or
involve a reviewer who does.

Stop rule 3: you’re fighting output quality

The 10-minute rule:

If you’ve spent about 10 minutes fighting the output, stop.
Upgrade the model tier, or shrink the scope to a smaller logical unit.

Stop rule 4: high-risk code needs extra caution

Be cautious with:

Authentication and authorization.
Cryptography.
Payment flows.
Input validation.

You can still use LLMs, but the bar for review and verification is higher.

Top pitfalls

These show up repeatedly.

Trusting output without review.
Skipping planning.
Not providing reference implementations.
Letting sessions run too long.
Scope creep mid-session.
Vague prompts.
Not capturing decisions.
No verification step.

A simple rule:

If you wouldn’t merge a junior developer’s PR without review, don’t merge LLM output without review.

Recovery checklist

When things go wrong:

Stop iterating on bad output.
Decide what kind of problem it is:
- prompt problem,
- model capability problem,
- task is a poor fit.
Simplify:
- smaller logical unit,
- more references,
- clearer constraints.
Fresh session if context has drifted.
Manual fallback is a valid outcome.

Verification

Create a one-page stop-rules file so you can apply this consistently across tasks:

mkdir -p work-notes

cat > work-notes/stop-rules.md <<'MD'
# Stop Rules (Personal Defaults)

## Manual first
- If change is <= 1 minute manually, do it manually.

## Upgrade triggers
- Third attempt on same logical unit.
- Repeated misunderstandings.
- Output ignores constraints.

## Bail triggers
- I cannot review this competently.
- Task requires live debugging with runtime state.
- Sensitive data would be required to reproduce.

## Required gates
- Verification commands exist in plan.
- Verification commands exist in prompt.
- Work notes updated before continuing.
MD

Expected result:

You have a written policy you can apply without debating every time.

Continue -> Chapter 11: Measuring Success: Solo + Team Metrics Without Fake Precision

MCP Servers in Production: Hardening, Backpressure, and Observability (Go)

Sat, 31 Jan 2026 09:00:00 -0500

As-of note: MCP is evolving. This article references the MCP specification versioned 2025-11-25 and related docs; verify details against the current spec before shipping changes. [1][2][4]

Why this matters

Most “agent demos” fail in production for boring reasons: missing timeouts, unbounded concurrency, ambiguous tool interfaces, and logging that accidentally turns into data exfiltration.

An MCP server isn’t “just an integration.” It’s a capability boundary between an LLM host (IDE, desktop app, agent runner) and the real world: files, APIs, databases, tickets, home automation, and anything else you wire up. MCP uses JSON-RPC 2.0 messages over transports like stdio (local) and Streamable HTTP (remote). [1][2][5]

That means an MCP server is:

an API gateway for tools
a policy enforcement point (whether you intended it or not)
a reliability hotspot (tool calls are where latency and failure concentrate)
a security hotspot (tools are where “read” becomes “exfil” and “write” becomes “impact”)

This post is a pragmatic checklist + a set of Go patterns to harden an MCP server so it keeps working when it’s under real load, and remains safe when the model gets “creative.”

TL;DR

Treat tool inputs as untrusted. Validate and constrain everything.
Put budgets everywhere: timeouts, concurrency limits, rate limits, and payload caps.
Build for partial failure: retries, idempotency keys, circuit breaking, fallbacks.
Log like a security engineer: structured, redacted, auditable, and useful. [11]
Instrument with traces/metrics early; “we’ll add telemetry later” is a trap. [13]
Prefer Go for MCP servers because deployment and operational behavior are predictable: single binary, fast startup, structured concurrency via context, and a strong standard library.

A production mental model for MCP servers
Threat model: what actually goes wrong
Hardening layer 1: identity and authorization
Hardening layer 2: tool contracts that resist ambiguity
Hardening layer 3: budgets and backpressure
Hardening layer 4: safe networking and SSRF containment
Hardening layer 5: observability without leaking secrets
Hardening layer 6: versioning and rollout discipline
A production checklist
References

A production mental model for MCP servers

MCP’s docs describe a host (the AI application), a client (connector inside the host), and servers (capabilities/providers). Servers can be “local” (stdio) or “remote” (Streamable HTTP). [2][3]

Here’s the production mental model that matters:

Your MCP server is a tool gateway.
Every tool is effectively an RPC method exposed to an agent. MCP uses JSON-RPC 2.0 semantics for requests/responses/notifications. [1][5]
LLM tool arguments are not trustworthy.
Even if the LLM is “helpful,” arguments can be malformed, overbroad, or dangerous, especially under prompt injection or user-provided hostile input.
The host UI is not a security boundary.
The spec emphasizes user consent and tool safety, but the protocol can’t enforce your policy for you. You still need server-side controls. [1]
Transport changes your blast radius, not your responsibilities.
Stdio reduces network exposure, but doesn’t remove safety requirements. Streamable HTTP adds multi-client/multi-tenant concerns and requires real auth. [2][3]

If you remember nothing else: treat the MCP server like a production API you’d be willing to put on call for.

Threat model: what actually goes wrong

When MCP servers cause incidents, it’s usually one of these:

1) Input ambiguity → destructive actions

A “delete” tool with optional filters
A “run command” tool with free-form strings
A “sync” tool that can touch thousands of objects

Mitigation: schema + semantic validation, safe defaults, two-phase commit patterns (preview then apply), and explicit “danger gates.”

2) Prompt injection → tool misuse

The model can be tricked into calling tools with attacker-provided arguments. If your tool can read internal data or call internal APIs, you’ve created an exfil path.

Mitigation: least privilege, allowlists, strong auth, egress controls, and redaction.

3) SSRF / network pivoting

Any tool that fetches URLs, loads webhooks, or calls dynamic endpoints can be abused to hit internal networks or metadata endpoints. OWASP treats SSRF as a major category for a reason. [10]

Mitigation: deny-by-default networking (CIDR blocks, DNS/IP resolution checks, allowlisted destinations).

4) Unbounded concurrency → resource collapse

Agents can fire tools in parallel. Without limits you’ll blow up:

API quotas
DB connections
CPU/memory
downstream latency

Mitigation: per-tenant rate limiting, concurrency caps, queues, and backpressure.

5) “Helpful logs” → data leak

Tool arguments and tool responses often contain secrets, tokens, or private data. If you log everything, you’ve built an involuntary data lake.

Mitigation: structured + redacted logging, security logging guidelines, and minimal retention. [11][12]

Hardening layer 1: identity and authorization

If you run Streamable HTTP, assume:

multiple clients
untrusted networks
tokens will leak eventually

MCP’s architecture guidance recommends standard HTTP authentication methods and mentions OAuth as a recommended way to obtain tokens for remote servers. [2][3]

Practical rules

Authenticate every request.
Use bearer tokens or mTLS depending on environment.
Authorize per tool.
“Authenticated” ≠ “allowed to run delete_everything”.
Prefer short-lived tokens and rotate them. [12]
Multi-tenant? Put the tenant identity into:
- auth token claims, or
- an explicit, validated tenant header (signed), then
- enforce it everywhere.

Go pattern: a minimal auth middleware skeleton (HTTP transport)

This is not a full MCP implementation, just the hardening pattern you’ll wrap around your MCP handler.

// Pseudocode-ish middleware skeleton. Replace verifyToken with your auth logic.
func authMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
 if token == "" {
 http.Error(w, "missing auth", http.StatusUnauthorized)
 return
 }

 ident, err := verifyToken(r.Context(), token) // includes tenant + scopes
 if err != nil {
 http.Error(w, "invalid auth", http.StatusUnauthorized)
 return
 }

 ctx := context.WithValue(r.Context(), ctxKeyIdentity{}, ident)
 next.ServeHTTP(w, r.WithContext(ctx))
 })
}

Key point: authorization should happen after you parse the requested tool name, but before you execute anything.

Hardening layer 2: tool contracts that resist ambiguity

Most MCP tool failures are self-inflicted: tool interfaces are too vague.

Design tools like production APIs

Bad tool signature:

run(command: string)

Better:

run_command(program: enum, args: string[], cwd: string, timeout_ms: int, dry_run: bool)

Why it’s better:

forces structure
allows you to enforce allowlists
gives you timeouts and safe defaults

Add a “preview → apply” flow for risky tools

For any tool that writes data or triggers side effects, do a two-step approach:

plan_* returns a machine-readable plan + a plan_id
apply_* requires plan_id and optional user confirmation token

This mirrors how we run infra changes (plan/apply) and dramatically reduces accidental blast radius.

Hardening layer 3: budgets and backpressure

Production systems are budget systems.

If you don’t set explicit budgets, your MCP server will eventually allocate them for you via outages.

Budget checklist

Server timeouts (header read, request read, write, idle)
Request body caps
Outbound timeouts to dependencies
Concurrency caps per tool and per tenant
Rate limits per tenant and per identity
Queue limits (bounded channels) to avoid memory blowups
Circuit breaking for flaky downstream dependencies

Go: server timeouts are not optional

Go’s net/http provides explicit server timeouts; leaving them at zero is a common footgun. [6][7]

srv := &http.Server{
 Addr: ":8080",
 Handler: handler, // your MCP handler + middleware
 ReadHeaderTimeout: 5 * time.Second,
 ReadTimeout: 30 * time.Second,
 WriteTimeout: 30 * time.Second,
 IdleTimeout: 60 * time.Second,
}
log.Fatal(srv.ListenAndServe())

Go: propagate cancellation everywhere with `context`

context.Context is the backbone of “structured concurrency” in Go: deadlines and cancellation signals flow through your call stack. [8][9]

Rule: every tool execution must accept a context.Context, and every outbound call must honor it.

func (s *Server) toolCall(ctx context.Context, req ToolRequest) (ToolResponse, error) {
 ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
 defer cancel()

 // ... outbound calls use ctx
 return s.integration.Do(ctx, req)
}

Go: per-tenant rate limiting with `x/time/rate`

golang.org/x/time/rate implements a token bucket limiter. [9]

type limiters struct {
 mu sync.Mutex
 m map[string]*rate.Limiter
}

func (l *limiters) get(key string) *rate.Limiter {
 l.mu.Lock()
 defer l.mu.Unlock()
 if l.m == nil { l.m = map[string]*rate.Limiter{} }
 if lim, ok := l.m[key]; ok { return lim }

 // Example: 5 req/sec with bursts up to 10
 lim := rate.NewLimiter(5, 10)
 l.m[key] = lim
 return lim
}

func rateLimitMiddleware(lims *limiters, next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 ident := mustIdentity(r.Context())
 if !lims.get(ident.TenantID).Allow() {
 http.Error(w, "rate limited", http.StatusTooManyRequests)
 return
 }
 next.ServeHTTP(w, r)
 })
}

Backpressure: choose a policy

When you’re overloaded, you need a policy. Pick one explicitly:

Fail fast with 429 / “busy” (simplest, safest)
Queue with bounded depth (more complex; must cap memory)
Degrade by disabling expensive tools first

The “fail fast” approach is often correct for tool gateways.

Hardening layer 4: safe networking and SSRF containment

If any tool can fetch a user-provided URL or call a user-influenced endpoint, SSRF is on the table. [10]

SSRF containment strategies that actually work

OWASP’s SSRF guidance boils down to a few themes: don’t trust user-controlled URLs, use allowlists, and enforce network controls. [10]

In practice, for MCP servers:

Prefer allowlists over blocklists.
“Only these domains” beats “block internal IPs.” Attackers are creative.
Resolve and validate IPs before dialing.
DNS can be weaponized. Validate the final destination IP (and re-validate on redirects).
Disable redirects or re-validate each hop.
Redirect chains are SSRF’s favorite tool.
Enforce egress policy at the network layer too.
Kubernetes NetworkPolicies / firewall rules are your last line of defense.

Go pattern: an outbound HTTP client with strict timeouts

client := &http.Client{
 Timeout: 10 * time.Second, // whole request budget
 Transport: &http.Transport{
 Proxy: http.ProxyFromEnvironment,
 DialContext: (&net.Dialer{
 Timeout: 5 * time.Second,
 KeepAlive: 30 * time.Second,
 }).DialContext,
 TLSHandshakeTimeout: 5 * time.Second,
 ResponseHeaderTimeout: 5 * time.Second,
 ExpectContinueTimeout: 1 * time.Second,
 MaxIdleConns: 100,
 IdleConnTimeout: 90 * time.Second,
 },
}

Then wrap URL validation around any request creation. Keep it boring and strict.

Hardening layer 5: observability without leaking secrets

Telemetry is how you prove:

you’re within budgets
tools behave as expected
failures are localized
incidents can be diagnosed without “ssh and guess”

But logging is also where teams accidentally leak sensitive data.

OWASP’s logging guidance emphasizes logging that supports detection/response while avoiding sensitive data exposure. [11] Pair that with secrets management discipline. [12]

What to measure (minimum viable MCP telemetry)

Counters

tool_calls_total{tool, tenant, status}
auth_failures_total{reason}
rate_limited_total{tenant}

Histograms

tool_latency_seconds{tool}
outbound_latency_seconds{dependency}

Gauges

in_flight_tool_calls{tool}
queue_depth{tool}

Trace boundaries

Instrument:

request → tool routing
tool execution span
downstream calls span

OpenTelemetry’s Go docs show how to add instrumentation and emit traces/metrics. [13]

Logging rules that save you later

Use structured logging (JSON).
Add correlation IDs (trace IDs) to logs.
Redact:
- Authorization headers
- tokens
- cookies
- tool payload fields known to contain secrets
Log events, not raw payloads:
- “tool X called”
- “resource Y read”
- “write operation requested (dry_run=true)”

Audit logs

For high-impact tools, write an append-only audit record:
- who (identity)
- what (tool + parameters summary)
- when
- result (success/failure)
- plan_id / idempotency_key

Audit logs should be treated as security data.

Hardening layer 6: versioning and rollout discipline

MCP uses string-based version identifiers like YYYY-MM-DD to represent the last date of backwards-incompatible changes. [4]

That’s helpful, but it doesn’t solve the operational problem:

clients upgrade at different times
schema changes drift
hosts differ in which capabilities they support

Practical compatibility rules

Pin your server’s supported protocol version and expose it in health or diagnostics.
Add contract tests that run against:
- one “current” client
- one “previous” client version
Support additive changes first:
- new tools
- new optional fields
Use feature flags for risky tools.

Rollout like a platform team

Canaries for remote servers
“Shadow mode” for new tools (log what would happen)
Slow ramp with budget monitoring

A production checklist

If you’re building (or inheriting) an MCP server, run this checklist:

Safety

Tool contracts are structured (no free-form “do anything” strings).
Every tool has a safe default (dry_run=true, limit required, etc.).
Destructive tools require a plan/apply step (or explicit confirmation gates).
Tool inputs are validated and bounded (length, ranges, enums).

Identity & access

Remote transport requires authentication and per-tool authorization.
Tokens are short-lived and rotated; secrets are not in source control. [12]
Tenant identity is enforced at every access point (not “best effort”).

Budgets & resilience

HTTP server timeouts are configured. [6][7]
Outbound clients have timeouts and connection limits.
Rate limiting exists per tenant/identity. [9]
Concurrency caps exist per tool; overload behavior is explicit (fail fast / queue).
Retries are bounded and idempotent where side effects exist.

Networking

URL fetch tools have allowlists and SSRF protections. [10]
Redirect policies are explicit (disabled or re-validated).
Egress is constrained at the network layer (not only in code).

Observability

Metrics cover tool calls, latency, errors, and rate limiting.
Tracing exists across tool execution and downstream calls. [13]
Logs are structured, correlated, and redacted. [11]
Audit logging exists for high-impact tools.

Operations

Health checks and readiness checks exist.
Configuration is explicit and validated on startup.
Versioning strategy is documented and tested. [4]

References

Model Context Protocol (MCP) Specification (version 2025-11-25): https://modelcontextprotocol.io/specification/2025-11-25
MCP Architecture Overview (participants, transports, concepts): https://modelcontextprotocol.io/docs/learn/architecture
MCP Transport details (Streamable HTTP transport overview): https://modelcontextprotocol.io/specification/2025-03-26/basic/transports
MCP Versioning: https://modelcontextprotocol.io/specification/versioning
JSON-RPC 2.0 Specification: https://www.jsonrpc.org/specification
Go net/http package documentation: https://pkg.go.dev/net/http
Cloudflare: “The complete guide to Go net/http timeouts”: https://blog.cloudflare.com/the-complete-guide-to-golang-net-http-timeouts/
Go context package documentation: https://pkg.go.dev/context
Go x/time/rate documentation: https://pkg.go.dev/golang.org/x/time/rate
OWASP SSRF Prevention Cheat Sheet / SSRF category references:

OWASP Logging Cheat Sheet (security-focused logging guidance): https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html
Secrets management guidance:

OWASP Secrets Management Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html
Kubernetes “Good practices for Kubernetes Secrets”: https://kubernetes.io/docs/concepts/security/secrets-good-practices/

OpenTelemetry Go instrumentation docs: https://opentelemetry.io/docs/languages/go/instrumentation/

Chapter 9: Security & Sensitive Data: Sanitize, Don't Paste Secrets

Thu, 29 Jan 2026 21:00:00 -0500

Series: LLM Development Guide

Chapter 9 of 16

Previous: Chapter 8: Choosing the Right Model: Capability Tiers, Not Hype

Next: Chapter 10: Stop Rules + Pitfalls: When to Upgrade, Bail, or Go Manual

What you’ll be able to do

You’ll be able to use LLMs without doing something reckless:

Apply a concrete “never paste” list.
Sanitize code, config, and logs into safe examples.
Add a verification step so you don’t ship secrets.

TL;DR

Assume anything you paste could be logged or retained.
If you wouldn’t publish it publicly, don’t paste it.
Replace real values with placeholders.
Sanitize logs aggressively.
Verify your workspace for leaked secrets before you commit.

The core principle
Never paste list
Sanitization patterns
Verification
Failure modes

The core principle

Assume anything you send to an LLM could be stored.

Even with enterprise offerings, policies change. Check vendor policy as of 2026-02-14 (and your organization’s approved tools list) before using any tool with internal data.

Never paste list

Do not paste:

Credentials: API keys, tokens, passwords, private keys.
PII: customer names, emails, addresses, health data.
Production data: real records, full dumps, support tickets.
Security configs: firewall rules, IAM policies, internal IPs.
Proprietary secrets: unreleased product details, trade secrets.

Use the “Would I post this publicly?” test.

Sanitization patterns

Replace sensitive values with descriptive placeholders.

Go example:

// Before (do not paste)
// db, err := sql.Open("postgres", "host=prod-db.internal user=admin password=SuperSecret123 dbname=customers")

// After (safe to paste)
db, err := sql.Open("postgres", "host=DATABASE_HOST user=DATABASE_USER password=DATABASE_PASSWORD dbname=DATABASE_NAME")
if err != nil {
 return err
}

YAML example:

# Before (do not paste)
# data:
# api-key: YWN0dWFsLWFwaS1rZXktaGVyZQ==

# After (safe to paste)
data:
 api-key: <BASE64_ENCODED_API_KEY>
 webhook-secret: <BASE64_ENCODED_WEBHOOK_SECRET>

Logs:

Remove emails.
Replace internal hostnames.
Replace IPs with documentation ranges (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24).

Verification

Before you paste or commit, search your workspace for obvious secret patterns.

These commands are noisy, but useful:

# High-signal patterns.
rg -n "(AKIA[0-9A-Z]{16}|BEGIN (RSA|OPENSSH) PRIVATE KEY|xox[baprs]-|ghp_[A-Za-z0-9]{36})" . || true

# Common key/value names.
rg -n "(?i)(api[_-]?key|secret|token|password)\s*[:=]" . || true

# Emails (often indicates logs or real data got copied).
rg -n "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}" . || true

# Check staged changes specifically.
git diff --cached

Expected results:

No obvious credentials or private keys appear in diffs.
If matches exist, sanitize and regenerate the example.

Failure modes

Sharing real logs that contain tokens in URLs.
Copying a Kubernetes Secret verbatim.
Letting an IDE plugin send your whole file without noticing.
Assuming “enterprise” means “no risk” without verifying current policy.

Continue -> Chapter 10: Stop Rules + Pitfalls: When to Upgrade, Bail, or Go Manual

Chapter 8: Choosing the Right Model: Capability Tiers, Not Hype

Tue, 27 Jan 2026 19:00:00 -0500

Series: LLM Development Guide

Chapter 8 of 16

Previous: Chapter 7: Large Projects with Phase Documents + Implementation Prompts

Next: Chapter 9: Security & Sensitive Data: Sanitize, Don’t Paste Secrets

What you’ll be able to do

You’ll be able to pick a model and interface deliberately:

Use capability tiers instead of memorizing brand names.
Upgrade quickly when quality is the bottleneck.
Avoid wasting flagship models on structured boilerplate.

TL;DR

Treat model choice as a cost-of-mistakes problem.
Use flagship models for planning, debugging, and high-stakes decisions.
Use mid-tier models for implementation with strong references.
Use fast/cheap models for boilerplate and simple transformations.
If you’ve spent ~10 minutes fighting output quality, upgrade or shrink scope.

As-of note

As of 2026-02-14, model names, pricing, and product policies change frequently. Prefer tier-based guidance, and verify vendor policies directly before using tools with sensitive data.

The capability tiers
Task-to-tier mapping
Red flags: upgrade now
A selection checklist
Verification

The capability tiers

Think in tiers:

Flagship: best reasoning and instruction-following for novel work.
Mid-tier: strong general performance for structured work with references.
Fast/cheap: good for simple tasks, higher error rate on complex reasoning.

This framing stays useful even when names change.

Task-to-tier mapping

Use flagship for:

Planning and architecture.
Debugging complex failures.
Security-sensitive review.
Anything where mistakes are expensive.

Use mid-tier for:

Implementation that follows existing patterns.
Refactors with clear examples.
Writing tests when the behavior is already defined.

Use fast/cheap for:

Syntax lookups.
Boilerplate you will review.
Mechanical transformations.

Red flags: upgrade now

Upgrade when you see:

The model repeats the same misunderstanding.
Output ignores constraints.
“Looks right” code fails in tests.
You are on the third prompt iteration for the same unit.

The cheapest model is the one that gets you to a correct verified change with the least total time.

A selection checklist

Before you start, answer:

Is this novel or pattern-following?
Do I have reference implementations?
What is the cost of mistakes?
Is this structured or ambiguous?
Am I debugging or implementing?

If uncertain:

Start with flagship for planning.
Drop to mid-tier once you have a stable pattern and good references.

Verification

A practical way to keep this from being hand-wavy is to force a written decision per phase.

Create a small note file per task:

mkdir -p work-notes

cat > work-notes/model-selection.md <<'MD'
# Model Selection (Per Task)

## Task
<What are we doing?>

## Risk
- Cost of mistakes:
- Can I review the output competently?

## References
- <Paths to reference implementations>

## Model decision
- Tier: <flagship|mid-tier|fast>
- Why:
- When to upgrade:

## Outcome
- Did we upgrade?
- What broke / what worked:
MD

Expected result:

You can justify the model choice in one minute.
You have a trigger for upgrading when output quality is the bottleneck.

Continue -> Chapter 9: Security & Sensitive Data: Sanitize, Don’t Paste Secrets

Chapter 7: Large Projects with Phase Documents + Implementation Prompts

Mon, 26 Jan 2026 20:00:00 -0500

Series: LLM Development Guide

Chapter 7 of 16

Previous: Chapter 6: Scaling the Workflow: Phases, Parallelism, Hygiene

Next: Chapter 8: Choosing the Right Model: Capability Tiers, Not Hype

What you’ll be able to do

You’ll be able to run large, multi-phase delivery with less drift by introducing two explicit artifacts:

A phase specification document that defines scope, dependencies, files, and exit criteria.
A phase implementation prompt document that defines the prompt-by-prompt execution contract.
A repeatable operating cadence for execution, verification, and commits.

TL;DR

Large projects fail when a single prompt tries to carry the whole implementation plan.
Use one phase spec and one implementation-prompt file per sub-phase.
Execute prompts sequentially; do not continue if build/vet/test gates fail.
Keep context loading explicit for each prompt.
For copy/paste templates, use Chapter 13: Templates + Checklists: The Copy/Paste Kit .

Why this pattern exists
The two-document system
Worked example: a multi-phase engineering initiative
Execution protocol for prompt files
Verification
Failure modes

Why this pattern exists

For a one-day task, a plan plus one execution prompt is usually enough.

For multi-week work, that breaks down:

Context gets too large and detail gets dropped.
Sessions diverge when constraints are implied instead of written.
Verification becomes optional instead of required.
Commits become large and hard to review.

The fix is to treat phase docs and implementation prompt docs as first-class project artifacts.

The two-document system

For each sub-phase, create two files.

1) Phase spec document

Purpose: define what this sub-phase must accomplish and how completion is validated.

Typical sections:

Status, dependency, and migration notes.
Design rationale (why this slice exists now).
Tasks grouped by prompt number.
Files: new, modified, and referenced-only.
Exit criteria with concrete commands and expected results.
Progress notes placeholder.

2) Phase implementation prompt document

Purpose: define exactly how execution happens, prompt by prompt.

Each prompt should include:

Context files to load (small, explicit list).
Task details: signatures, interfaces, constraints.
Quality gates and required verification commands.
Stop condition: do not proceed until the current prompt passes.

A useful pattern is to couple one prompt to one logical implementation unit.

Worked example: a multi-phase engineering initiative

Assume you are delivering a new runtime capability over six weeks.

You split work into:

Phase A: contracts and types.
Phase B: core implementation.
Phase C: API and integration points.
Phase D: tests and validation.
Phase E: observability and rollout safety.

For Phase B, your phase spec might look like this:

# Phase B - Core Implementation

## Status
Planned

## Depends on
Phase A

## Design rationale
Phase B isolates core behavior behind the contracts from Phase A.
This prevents API and infrastructure concerns from polluting the core logic.

## Tasks
### Prompt 1
- Implement core orchestration types and constructor.

### Prompt 2
- Implement main execution method with deterministic error paths.

### Prompt 3
- Add unit tests for success and failure branches.

## Files
### New
- internal/core/runtime.go
- internal/core/runtime_test.go

### Modified
- internal/core/types.go

### Referenced (read-only)
- internal/contracts/interfaces.go

## Exit criteria
- [ ] `go build ./internal/core/...` exits 0
- [ ] `go vet ./internal/core/...` exits 0
- [ ] `go test ./internal/core/...` exits 0
- [ ] No unchecked returned errors

## Progress notes

Now pair it with a Phase B implementation prompt file:

# Phase B - Implementation Prompts

## Prompt 1 of 3: Runtime skeleton

Context files to load:
- docs/phases/PHASEB.md
- internal/contracts/interfaces.go
- internal/core/types.go
- README.md

Task:
- Create `internal/core/runtime.go` with constructor and public methods.

Constraints:
- Do not change files outside listed scope.
- Handle all returned errors explicitly.
- Keep methods short enough to remain reviewable.

Verification:
- `go build ./internal/core/...`
- `go vet ./internal/core/...`

Stop rule:
- Do not proceed to Prompt 2 until both commands pass.

This is intentionally boring. Boring is what scales.

Execution protocol for prompt files

Use the same cadence for every prompt in a sub-phase:

Load only listed context files.
Execute exactly one prompt.
Update work notes (decisions, assumptions, blockers, next step).
Run required verification gates.
Commit one logical unit.
Move to the next prompt.

Suggested commit discipline:

One commit per prompt when prompts are independent.
One commit per tightly coupled prompt pair when separation creates broken intermediate states.
Message format should state scope and intent clearly.

When prompt counts are high, add a completion table in work notes:

## Prompt progress
- [x] Prompt 1
- [x] Prompt 2
- [ ] Prompt 3
- [ ] Prompt 4

Verification

You can verify this system is functioning with mechanical checks.

# All phase specs have exit criteria.
rg -n "^## Exit criteria" docs/phases/PHASE*.md

# All prompt docs define context loading and verification.
rg -n "^Context files to load:|^Verification:" docs/phases/*-PROMPT.md

# Work notes track progression.
rg -n "^## Prompt progress|^## Session log" work-notes || true

Expected results:

Every phase spec has explicit exit criteria.
Every prompt file defines context and verification.
Session state is recoverable without re-explaining the whole project.

Failure modes

Phase docs describe architecture but skip executable gates.
Prompt docs are too broad (“implement phase”) and lose determinism.
Prompts proceed despite failing verification.
Context file lists are bloated and include unrelated material.

If this starts happening, shrink prompt scope and tighten exit criteria before continuing.

Continue -> Chapter 8: Choosing the Right Model: Capability Tiers, Not Hype

Chapter 6: Scaling the Workflow: Phases, Parallelism, Hygiene

Sun, 25 Jan 2026 18:00:00 -0500

Series: LLM Development Guide

Chapter 6 of 16

Previous: Chapter 5: The Execution Loop: Review Discipline + Commit Discipline

Next: Chapter 7: Large Projects with Phase Documents + Implementation Prompts

What you’ll be able to do

You’ll be able to take the same workflow and scale it up without chaos:

Split work into phases that do not overlap on files.
Run parallel sessions or agents safely.
Decide when artifacts stay local vs. get committed.

TL;DR

Scale by splitting phases, not by writing bigger prompts.
Keep phase files small (rule of thumb: under ~200 lines).
Parallel work requires clean boundaries and explicit interfaces.
Decide up front whether plan/, prompts/, work-notes/ live in git.

When to sub-phase
Parallel execution requirements
Repository hygiene
Verification
Gotchas

When to sub-phase

Sub-phase when:

A phase touches too many files.
The phase cannot be verified independently.
The phase depends on decisions that are not written down.

Example layout:

plan/
 phase-1a-analysis.md
 phase-1b-design.md
 phase-2a-scaffold.md
 phase-2b-core-impl.md
 phase-3-validation.md

Keep each phase “one session friendly”: small enough to complete (or at least checkpoint) in 1 to 2 sessions.

At this point, many teams benefit from formalizing each sub-phase with two files: a phase spec and a phase implementation prompt file. The next chapter walks through that pattern in detail.

Parallel execution requirements

Parallel work is possible, but only if you make boundaries explicit.

Requirements:

No overlapping files between parallel phases.
Explicit interfaces (types, APIs, data shapes) written down.
A merge plan (who rebases, who resolves conflicts, how often you sync).

A simple pattern:

Phase A defines interfaces and contracts.
Phase B implements with those interfaces.
Phase C adds tests and validation.

Repository hygiene

Decide whether artifacts are local scaffolding or part of the repo.

Common default:

Keep plan/, prompts/, work-notes/ local (gitignored).

Commit them deliberately when they become:

Long-lived docs.
Reusable templates.
Onboarding material.

If you commit them, consider moving to docs/ and editing for humans.

Verification

These checks help you catch “phases are too big” early:

# Find phase files that are getting too large.
# (This uses line count as a blunt proxy.)
find plan -type f -name '*.md' -maxdepth 2 -print0 | xargs -0 wc -l | sort -n

# Find prompts that do not reference work notes.
rg -n "work-notes/" prompts || true

# Find phases that might overlap on files (manual review).
# Start by listing deliverables per phase in each prompt doc.
rg -n "^## Deliverables" -n prompts

Gotchas

Parallelization without clean boundaries just creates merge conflicts faster.
If you don’t define interfaces early, later phases stall.
If artifacts are committed, treat them like code: review, version, maintain.

Continue -> Chapter 7: Large Projects with Phase Documents + Implementation Prompts

Chapter 5: The Execution Loop: Review Discipline + Commit Discipline

Fri, 23 Jan 2026 16:00:00 -0500

Series: LLM Development Guide

Chapter 5 of 16

Previous: Chapter 4: Work Notes: External Memory + Running Log

Next: Chapter 6: Scaling the Workflow: Phases, Parallelism, Hygiene

What you’ll be able to do

You’ll be able to run an LLM through implementation work in a way that stays reviewable:

One logical unit at a time.
Verification before claiming “done”.
Atomic commits with clear intent.
Notes updated as part of the loop.

TL;DR

Never skip: update notes, verify, propose commit, review.
A “logical unit” is the smallest change that is independently reviewable.
Treat LLM output like junior output: it needs review.
Keep commits small to make rollback cheap.

The execution loop
What counts as a logical unit
Commit discipline
Verification
Failure modes

The execution loop

This loop is intentionally repetitive:

Load prompt + work-notes
-> implement one logical unit
-> update work-notes
-> verify
-> propose commit
-> you review
-> commit
-> repeat

If you skip the middle steps, your “agent” becomes a vibes-based code generator.

What counts as a logical unit

A logical unit is a change that:

Has a clear purpose.
Can be verified.
Can be reviewed in isolation.
Does not leave the repo in a half-broken state.

Examples:

Add one Kubernetes template file.
Add one Go type + its tests.
Add one API endpoint handler.

Non-examples:

“Implement everything for phase 2”.
“Half a refactor”.
“Quick fixes”.

Commit discipline

Use a consistent commit format so you can scan history later.

Example commit message:

feat(helm): add service template for metrics-gateway

- Exposes port 9090 as ClusterIP
- Follows event-processor naming and labels
- No ingress in this commit

Refs: work-notes/phase-2b-core-resources.md

In prompts, require the model to:

Summarize what changed.
Explain why.
Propose a message.
Wait for approval.

Verification

Verification is context-specific, but the shape is consistent:

Build.
Test.
Lint.
Render config.

Generic verification commands you can adapt:

# Make sure you know what is staged and what is not.
git status --porcelain

git diff

# Run the repo's verification gates.
# Replace these with your actual commands.
go test ./...

# After the commit, ensure you're clean.
git status --porcelain

Expected results:

Before committing, git diff matches the logical unit scope.
After committing, git status --porcelain is empty.
Tests and other gates exit 0.

Failure modes

The model keeps “just one more change”-ing.
- Fix: put explicit stop points in the prompt.
You don’t verify.
- Fix: add verification commands to plan and prompt docs.
Commits include unrelated changes.
- Fix: shrink the logical unit and split the work.
You approve output you can’t review.
- Fix: stop and do it manually or bring in a reviewer.

Continue -> Chapter 6: Scaling the Workflow: Phases, Parallelism, Hygiene

Chapter 4: Work Notes: External Memory + Running Log

Wed, 21 Jan 2026 14:00:00 -0500

Series: LLM Development Guide

Chapter 4 of 16

Previous: Chapter 3: Prompt Documents: Prompts That Survive Sessions

Next: Chapter 5: The Execution Loop: Review Discipline + Commit Discipline

What you’ll be able to do

You’ll be able to keep multi-session work consistent by maintaining work notes that:

Preserve the model’s working state outside the chat.
Capture decisions and rationale for later review.
Make handoffs possible.
Provide a deterministic “resume” prompt.

TL;DR

LLMs have no durable memory. If it’s not written down, it doesn’t exist next session.
Mirror work-notes/ files to your phases exactly.
Track: status, decisions, assumptions, open questions, session log, commits.
In your prompts, require the model to update notes before moving forward.

Directory alignment
A work-notes template you can paste
Session start and session end prompts
Verification
Gotchas

Directory alignment

Keep your three directories aligned so you can load one phase without dragging unrelated context into the session:

plan/phase-2a-scaffolding.md
prompts/phase-2a-scaffolding.md
work-notes/phase-2a-scaffolding.md

This makes sessions resumable and makes parallel work possible.

A work-notes template you can paste

# Phase <X> - <Phase Name>

## Status
- [ ] Not started
- [ ] In progress
- [ ] Blocked
- [ ] Complete

## Decisions
- <Decision>: <Rationale>

## Assumptions
- <Assumption>

## Open questions
- [ ] <Question>

## Session log

### <YYYY-MM-DD HH:MM>
- What changed:
- Why:
- Blockers:
- Next:

## Commits
- <hash> - <message>

You can keep it simple. The win is consistency.

Session start and session end prompts

Start a session

Paste your phase prompt and current work notes, and tell the model to continue from the last session.

I'm continuing work on Phase <X>.

Prompt:
<paste prompts/phase-X.md>

Current state:
<paste work-notes/phase-X.md>

Please:
1. Summarize where we are (3 to 4 sentences).
2. List blockers and open questions.
3. Confirm the next logical unit.
4. Proceed with the next logical unit.

End a session

Before we stop:
1. Update the session log with what we did and what is next.
2. Ensure decisions, assumptions, and open questions are current.
3. Propose a commit message for any completed logical unit.
4. Show the updated work-notes file.

Verification

You can verify your notes are doing their job by forcing a cold start:

Start a new chat.
Paste only the phase prompt and the work-notes file.
See if you can resume without re-explaining anything.

Mechanical checks:

# Work notes exist and are non-empty.
find work-notes -type f -name '*.md' -maxdepth 2 -print -exec test -s {} \;

# Work notes have at least the core sections.
rg -n "^## (Status|Decisions|Assumptions|Open questions|Session log|Commits)" work-notes

Gotchas

Notes without rationale are not useful later.
If you let the model continue without updating notes, the next session will drift.
Avoid dumping raw logs with sensitive data. Sanitize first.

Continue -> Chapter 5: The Execution Loop: Review Discipline + Commit Discipline

Chapter 3: Prompt Documents: Prompts That Survive Sessions

Mon, 19 Jan 2026 12:00:00 -0500

Series: LLM Development Guide

Chapter 3 of 16

Previous: Chapter 2: Planning: Plan Artifacts, Constraints, Definition of Done

Next: Chapter 4: Work Notes: External Memory + Running Log

What you’ll be able to do

You’ll be able to create prompt documents that:

Encode intent precisely so you don’t re-explain yourself.
Align to plan phases so scope stays tight.
Include verification steps and explicit stop points.
Tell the model how to update work notes and propose commits.

TL;DR

A prompt doc is an artifact, not a chat message.
Use one prompt file per phase.
Always include: role, context, task, constraints, deliverables, verification, session management.
Put negative constraints in writing (“MUST NOT”).
Keep prompts copy/pasteable and path-specific.

Why prompt docs matter
Anatomy of a good prompt
A template you can copy
Verification
Failure modes

Why prompt docs matter

If you’re doing anything bigger than a one-off snippet, the prompt itself becomes part of the system.

Prompt docs:

Reduce “prompt drift” across sessions.
Make handoffs possible.
Create an audit trail of what was asked.
Force you to pin down deliverables and done-ness.

Anatomy of a good prompt

At minimum, include these sections:

Role: what expertise you’re invoking.
Context: plan path, work-notes path, reference implementation paths.
Task: what to do now.
Constraints: what must and must not happen.
Deliverables: exact files and outputs expected.
Verification: commands and expected results.
Session management: how to update work notes.
Commit discipline: atomic commits, propose messages, wait for approval.

If your prompt is missing verification and stop rules, you’re inviting “looks right” output.

A template you can copy

# Phase <X> - <Phase Name>

## Role
You are a senior software engineer.

## Context
- Plan: plan/<phase>.md
- Work notes: work-notes/<phase>.md
- Reference implementations:
 - <path 1>
 - <path 2>

## Task
Implement the next logical unit for this phase.

## Constraints (follow exactly)
- MUST follow patterns in the reference implementations.
- MUST keep changes scoped to this phase.
- MUST include tests when applicable.
- MUST propose verification commands.
- MUST NOT add new dependencies unless explicitly approved.

## Deliverables
1. <file path> - <what it contains>
2. <file path> - <what it contains>

## Session management
As you work:
- Update work-notes/<phase>.md:
 - Decisions (with rationale)
 - Assumptions
 - Open questions
 - Session log entry
- After each logical unit, pause and show the updated notes section.

## Verification
After implementing the logical unit, run or propose:
- <command>
- Expected: <exit 0 / output contains X>

## Commit discipline
After verification:
1. Summarize what changed and why.
2. Propose a conventional commit message.
3. Wait for approval before continuing.

Refs: work-notes/<phase>.md

Notes:

Use real paths.
Put constraints in a dedicated section.
Repeat the most important constraints near the end.

Verification

You can verify prompt docs are usable by checking two things:

You can paste the entire file verbatim into a new session.
A new session produces the same behavior because paths and constraints are explicit.

Concrete checks:

# Prompts exist and are non-empty.
find prompts -type f -name '*.md' -maxdepth 2 -print -exec test -s {} \;

# Prompts mention work-notes paths.
rg -n "work-notes/" prompts

Expected results:

Each prompt file is non-empty.
Each prompt references a work-notes file.

Failure modes

Prompts that say “use the config file” without a path.
Constraints buried in prose instead of a dedicated section.
Prompts that do not mention verification.
Prompts that do not tell the model to stop after a logical unit.

Continue -> Chapter 4: Work Notes: External Memory + Running Log

Chapter 2: Planning: Plan Artifacts, Constraints, Definition of Done

Sat, 17 Jan 2026 11:00:00 -0500

Series: LLM Development Guide

Chapter 2 of 16

Previous: Chapter 1: A Practical Workflow for LLM-Assisted Development That Doesn’t Collapse After Day 2

Next: Chapter 3: Prompt Documents: Prompts That Survive Sessions

What you’ll be able to do

You’ll be able to write a plan artifact that:

Forces clarity on scope, constraints, and references.
Produces verification steps (not just a task list).
Is sized so an LLM can execute it phase-by-phase without drifting.

TL;DR

A plan is a shared source of truth between you and the model.
Keep plans at the “what” level; keep “how” in prompt docs.
Every phase needs verification and a definition of done.
If a plan file would exceed ~200 lines, split it.
Always point to reference implementations by path.

What belongs in a plan (and what doesn’t)
A plan template you can paste
Sizing rules
Verification and definition of done
Verification
Gotchas

What belongs in a plan (and what doesn’t)

Plans work when they are explicit and boring.

Include:

Goals and non-goals.
Constraints and invariants.
Reference implementations (by path).
Phases in dependency order.
Verification for each phase.

Avoid:

Full code blocks.
Deep implementation detail.
“Make it better” language.

If you want the LLM to do a thing consistently across sessions, you need the thing written down.

A plan template you can paste

Create one plan file per phase for larger work.

# <Project> Plan

## Overview
<1 to 2 sentences about what we are building>

## Goals
- <Goal 1>
- <Goal 2>

## Non-goals
- <Explicitly out of scope>

## Constraints
- <Must follow reference style X>
- <Must not add dependencies>
- <Must keep backward compatibility>

## References
- <Path to reference implementation 1>
- <Path to reference implementation 2>

## Phase 1: <Name>
- [ ] <Task 1>
- [ ] <Task 2>

Verification:
- <Command>
- Expected: <Exit 0 / output contains X>

## Phase 2: <Name>
- [ ] <Task 1>

Verification:
- <Command>
- Expected: <...>

## Definition of done
- [ ] <All phases verified>
- [ ] <Tests pass>
- [ ] <Docs updated as needed>
- [ ] <No TODOs left behind>

## Risks / open questions
- <Open question 1>
- <Risk 1>

Sizing rules

You need the plan sized so the LLM can execute it without mixing unrelated changes.

Use these rules of thumb:

Small (hours to 1 to 2 days): one PLAN.md.
Medium (1 to 2 weeks): one PLAN.md with explicit phases.
Large (multi-week): plan/phase-1a-...md, plan/phase-1b-...md, etc.

When in doubt:

Split by file ownership (phases should avoid editing the same files).
Split by interface boundaries (one phase defines types/contracts; later phases implement).

Verification and definition of done

Make verification explicit in the plan so you don’t have to negotiate it mid-session.

Bad:

“Add tests”

Better:

“Add unit tests for Foo and run go test ./... (expected: exit 0).”

If your phase can’t be verified, it probably isn’t a phase yet.

Verification

If you follow the template above, you should be able to run something like:

# Example: lint and test gates.
# Replace with your repo's actual commands.

go test ./...

git diff --stat

Expected results:

go test exits 0.
git diff --stat shows only the files you intended to touch in this phase.

Gotchas

Plans that mix “what” and “how” become unreadable quickly.
If you don’t write down constraints, the LLM will invent defaults.
A “phase” that touches 30 files is usually multiple phases.

Continue -> Chapter 3: Prompt Documents: Prompts That Survive Sessions

Chapter 1: A Practical Workflow for LLM-Assisted Development That Doesn't Collapse After Day 2

Thu, 15 Jan 2026 09:00:00 -0500

Series: LLM Development Guide

Chapter 1 of 16

Next: Chapter 2: Planning: Plan Artifacts, Constraints, Definition of Done

What you’ll be able to do

You’ll be able to take a real development task and run an LLM through a repeatable loop that:

Survives breaks and multi-day work.
Produces output you can actually review.
Includes verification steps, not just code.
Creates a paper trail of decisions and assumptions.

TL;DR

Treat the LLM like a senior engineer who can execute quickly, but has no durable memory.
Externalize memory into three artifacts: plan/, prompts/, and work-notes/.
For large projects, add phase specification docs and phase implementation prompt docs (see Chapter 7).
Execute in small logical units, with verification and atomic commits.
If you’re fighting output quality, upgrade the model or shrink the scope.
Never paste secrets, PII, or production data.

Trust contract (read this before you paste anything)

Security: do not paste secrets, tokens, customer data, or anything you would not publish in a public repo.
Staleness: model names, pricing, and vendor policies change frequently. Treat examples as illustrative as of 2026-02-14.
Prereqs: you can run tests, review diffs, and explain the change in a code review.

Why most LLM-assisted development fails
The workflow
Quick start: copy/paste kit
Worked example: Helm chart from a reference chart
Verification
Failure modes

Why most LLM-assisted development fails

Most failures are workflow failures, not “prompting” failures:

You jump straight to implementation without a plan.
You don’t provide reference implementations, so you get generic output.
You lose context across sessions.
You don’t verify output.
You batch changes into giant commits that are hard to review or revert.

The workflow

This is the smallest loop I’ve found that stays stable after day 2:

Plan -> Prompt docs -> Work notes -> Execute -> Verify -> Commit

The artifacts are simple:

plan/: what we’re doing and how we’ll know it’s done.
prompts/: the reusable prompts aligned to phases.
work-notes/: state, decisions, assumptions, open questions, and a running session log.

When work scales to multi-week delivery, promote this into explicit phase specification docs plus phase implementation prompt files so scope and verification stay deterministic across sessions.

Quick start: copy/paste kit

This is intentionally minimal. It’s enough to make sessions resumable.

1) Create the artifact directories

mkdir -p plan prompts work-notes

2) Create a minimal plan

cat > plan/phase-1.md <<'MD'
# Phase 1: Plan

## Overview
<One sentence: what we are building>

## Goals
- <Goal 1>
- <Goal 2>

## Constraints
- <Constraint 1>
- <Constraint 2>

## Definition of done
- [ ] <Verification command + expected outcome>
- [ ] <Verification command + expected outcome>

## Out of scope
- <Thing we will not do in this phase>
MD

3) Create a phase prompt doc

cat > prompts/phase-1.md <<'MD'
# Phase 1 - Execution Prompt

## Role
You are a senior software engineer.

## Context
- Plan: plan/phase-1.md
- Work notes: work-notes/phase-1.md
- Reference implementation(s): <paths>

## Task
Implement the smallest logical unit that moves this phase forward.

## Constraints (follow exactly)
- MUST follow patterns in the reference implementation.
- MUST propose verification commands.
- MUST NOT change files outside this phase scope.

## Session management
As you work, update work-notes/phase-1.md:
- Decisions (with rationale)
- Assumptions
- Open questions
- Session log entry

## Commit discipline
After each logical unit:
1. Stop and summarize what changed.
2. Propose a commit message.
3. Wait for approval.
MD

4) Create work notes

cat > work-notes/phase-1.md <<'MD'
# Phase 1 - Work Notes

## Status
- [ ] Not started
- [ ] In progress
- [ ] Blocked
- [ ] Complete

## Decisions

## Assumptions

## Open questions

## Session log

## Commits
MD

Worked example: Helm chart from a reference chart

This example is about correctness and maintainability, not “Helm tricks”.

Scenario

Goal: create a new chart (for example, metrics-gateway) by following a reference chart (for example, event-processor) that already works in your environment.

The important part is the inputs you give the model. Don’t describe the reference chart. Paste it.

Reference inputs (what to paste)

Run these commands in your repo and paste their output into your planning prompt:

tree charts/event-processor/
sed -n '1,200p' charts/event-processor/Chart.yaml
sed -n '1,200p' charts/event-processor/values.yaml
sed -n '1,200p' charts/event-processor/templates/_helpers.tpl

Plan prompt (high-signal)

I want to create a new Helm chart for a service called `metrics-gateway`.

Reference implementation: charts/event-processor/ (this is our standard).
The new chart MUST follow the same structure and conventions.

Here are the reference inputs:
- tree output: ...
- Chart.yaml: ...
- values.yaml: ...
- templates/_helpers.tpl: ...

Please:
- Analyze the reference chart patterns.
- Produce a phased plan with verification steps.
- Call out any open questions you need answered (ports, probes, resources).

Execution prompt (phase-aligned)

Once you have the plan, generate prompt docs aligned to phases (scaffold, core templates, env overrides, validation). Each prompt should:

Name the deliverables.
Repeat constraints.
Include “update work notes” instructions.
Include verification commands.

What “done” looks like

A good end state is boring:

The new chart is structurally identical to the reference chart.
The values structure matches (so operators don’t re-learn config surfaces).
helm lint and helm template succeed.
Changes are split into reviewable commits.

Verification

You can verify you’re actually following the workflow, not just producing text:

# Artifacts exist.
test -d plan && test -d prompts && test -d work-notes

# A plan exists and is not empty.
test -s plan/phase-1.md

# A prompt doc exists.
test -s prompts/phase-1.md

# Work notes exist.
test -s work-notes/phase-1.md

If you are doing the Helm chart example:

helm lint charts/metrics-gateway
helm template charts/metrics-gateway >/tmp/metrics-gateway.rendered.yaml
test -s /tmp/metrics-gateway.rendered.yaml

Expected results:

The commands exit with code 0.
The rendered YAML file is non-empty.

Failure modes

Skipping references: you get generic output that doesn’t match your repo.
Skipping verification: you ship code that “looked right.”
Letting sessions run too long: context drifts and you lose earlier constraints.
Batching commits: review slows down and rollback gets painful.
Using the wrong model: cheap models are fine for boilerplate, but can burn hours on complex reasoning.

Continue -> Chapter 2: Planning: Plan Artifacts, Constraints, Definition of Done

Cost Is a Reliability Problem

Sat, 13 Dec 2025 12:00:00 -0500

Why this matters

Traditional reliability focuses on uptime. AI systems add a second axis:

Your system can be “up” while your budget is on fire.

A runaway agent doesn’t always crash services. Sometimes it:

loops tool calls
retries incorrectly
escalates to larger models repeatedly
expands context windows unnecessarily
performs expensive searches without stopping

The result: surprise bills, throttling, and eventually hard outages when quotas are hit.

Google’s SRE framing around error budgets is a useful mental model: budgets create a control mechanism that balances stability with velocity. [1][2] FinOps frames cost management as a collaboration practice between engineering, finance, and business. [3]

This article is the practical bridge: use budgets and guardrails like you would for reliability.

TL;DR

Treat cost as an SLO: define acceptable spend per run / per tenant / per day.
Enforce budgets at multiple layers:
per request/run
per tool
per tenant
per environment
Use hard limits + soft limits:
soft: degrade model/tool choices
hard: stop the run and ask for approval
Add cost circuit breakers:
abort on runaway loops
quarantine tools causing repeated retries
Make cost visible (metrics + dashboards) so teams can improve it.
Align with FinOps: shared accountability, not “billing surprises.” [3]

Cost failure modes in agent systems
Define cost SLOs and budgets
Budget layers: run, tool, tenant, environment
Soft limits vs hard limits
Circuit breakers for runaway behavior
Cost-aware tool and model selection
Dashboards and alerts
A production checklist
References

Cost failure modes in agent systems

1) Infinite or long loops

Common triggers:

ambiguous tool outputs
brittle parsing
“try again” reflexes
non-idempotent retries

2) Tool spam

Agents sometimes “search until confident.” If you don’t cap it, you get 20+ tool calls on a single request.

3) Model escalation cascades

If your policy says “if uncertain, use a better model,” you can create a cost escalator:

cheap model -> “uncertain” -> expensive model
expensive model -> still uncertain -> more calls

4) Context growth

If you keep appending tool outputs to the prompt, costs grow superlinearly and performance can degrade.

5) External quotas become outages

Even if cost is acceptable, external services (email APIs, GitHub, calendars) can rate limit you. Cost and reliability are coupled.

Define cost SLOs and budgets

Start with simple “production truths”:

How much is one agent run allowed to cost?
What is an acceptable daily spend per tenant?
What is the max “blast radius” of a single request?

This maps cleanly to SRE’s error budget concept: budgets constrain unsafe behavior while preserving velocity. [2]

Example cost SLOs (pragmatic)

Per run: <= $0.10 (p95), <= $0.50 (max)
Per tenant/day: <= $50/day
Per user/day: <= $5/day
Per tool call: <= 3 calls to expensive tools

These aren’t universal. They’re explicit. That’s what matters.

Budget layers: run, tool, tenant, environment

1) Per-run budget

Tracks:

max model tokens
max tool calls
max wall-clock time
max “expensive operations” count

Most important budget. This is where you stop runaway behavior early.

2) Per-tool budget

Some tools are inherently expensive:

large searches
long-running jobs
heavy data exports

Budget these separately:

max calls
max payload size
max time range

3) Per-tenant budget

Without this, your best customers can melt your infra.

Per-tenant limits:

requests/min
concurrent runs
daily cost cap

4) Per-environment budget

Environments have different rules:

dev: cheap, permissive, more logging
prod: bounded, gated, auditable

This is where you implement “read-only mode” during incidents.

Soft limits vs hard limits

Soft limits (degrade gracefully)

When approaching budget:

switch to cheaper models
reduce context size (summarize)
narrow tool search range
skip non-essential steps

Hard limits (stop the run)

When budget is exceeded:

stop tool calls
stop escalation
request user confirmation / approval
produce a partial answer with an explanation

This is exactly the “control mechanism” idea behind error budgets: it gives the system permission to shift focus when constraints are exceeded. [1]

Circuit breakers for runaway behavior

Add circuit breakers that detect “this is going bad”:

loop detector: same tool called with similar args repeatedly
retry storm: high retry count for a tool within a run
no progress: plan step count increases without new evidence
latency breaker: tool p95 spikes beyond threshold

When triggered:

stop the run
quarantine the tool for this run
degrade to safe alternatives
emit high-signal telemetry

Cost-aware tool and model selection

Cost control is easier if it’s designed into selection:

Rank tools with a “cost weight” (latency + upstream cost + risk)
Prefer read-only tools unless a write is required
Use caches for common retrieval results
Use deterministic summarization boundaries for tool outputs

If you already implement a tool selector (see “Million Tool Problem”), cost becomes another rerank feature.

Dashboards and alerts

This is where FinOps and SRE meet: cost is an operational signal.

Dashboards

spend/day by tenant
cost per run distribution
top cost drivers (tools and models)
runaway breaker triggers

Alerts

daily spend exceeded
sudden spend spikes (slope alerts)
high frequency of loop breaker events
high fraction of runs hitting hard limits

AWS’s Well-Architected Cost Optimization pillar frames cost optimization as a continual process across the workload lifecycle. That mindset applies here too. [4]

A production checklist

Budgets

Per-run cost and tool-call budgets exist.
Per-tenant daily caps exist.
Per-tool “expensive operation” caps exist.

Enforcement

Soft limits degrade gracefully (cheaper models, narrower queries).
Hard limits stop and request approval.
Circuit breakers detect loops/retry storms.

Telemetry

Cost metrics emitted per run and per tenant.
Breaker events recorded and alertable.

Culture

Cost management is a shared practice (FinOps), not a surprise invoice. [3]

References

[1] Google SRE Workbook - Example Error Budget Policy: https://sre.google/workbook/error-budget-policy/ [2] Google SRE Book - Embracing Risk (error budgets as control mechanism): https://sre.google/sre-book/embracing-risk/ [3] FinOps Foundation - What is FinOps? (definition and principles): https://www.finops.org/introduction/what-is-finops/ [4] AWS Well-Architected Framework - Cost Optimization pillar: https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-optimization.html

Go MCP Server Ecosystem

Sun, 01 Sep 2024 00:00:00 +0000

Summary

This project is a growing ecosystem of Model Context Protocol (MCP) servers written in Go. Each server wraps a real service (calendar, email, task management, knowledge base, etc.) and exposes it as a typed, tool-based interface for MCP clients (e.g., Claude Desktop / Claude Code). [1][2]

The theme is simple: agents are only as useful as the tools they can call, and “tooling” needs the same production bar as any other integration layer: security boundaries, backpressure, observability, and predictable failure modes.

Open-source MCP servers

iCloud Calendar MCP Server (CalDAV): list calendars, search events, create/update/delete events; includes recurring event expansion, multi-account support, rate limiting, retries, audit logs, and Prometheus/health endpoints. [4]
iCloud Email MCP Server (IMAP/SMTP): search and read mail, send/reply, manage folders, handle attachments, and apply safety annotations (read-only vs destructive) with strict input validation. [5]
Todoist MCP Server (REST API v2 + Sync batching): manage tasks/projects/labels/comments; supports bulk operations with rate-limit-aware batching and Todoist filter syntax. [6]
Notion MCP Server (Notion REST API): pages, databases, blocks, comments, users; includes templates, exports (Markdown/CSV), smart queries, and built-in throttling/retries. [7]

Private / not-yet-open-sourced connectors

I’ve also built MCP connectors for enterprise systems that aren’t ready to open-source yet (either due to org-specific assumptions, credentials, or hard-coded domain models):

Kubernetes
Argo CD
SonarQube
GitHub
Temporal
OpenText Octane

(These follow the same design patterns described below.)

Problem

Agents need to interact with real systems: calendars, email, task systems, and internal developer platforms. Without a standard interface, every tool integration becomes a one-off, and reliability/guardrails drift between projects.

MCP solves the “standard interface” problem by defining how a host/client can discover and call server-exposed tools over a consistent protocol. [1][2] This ecosystem focuses on solving the remaining hard part: making those integrations production-grade.

Constraints

Local-first security boundary: credentials live on the host where the server runs (env vars, secret mounts, keychain tooling); the server talks directly to the upstream service with no proxy SaaS. [4][5]
Safety by design: explicit tool schemas, input validation, and tool classification (read-only vs mutating) so clients can apply guardrails. [4][5]
Fast & predictable: low startup time and bounded tool-call latency (timeouts + backpressure). [4][5][7]
Operable like a real service: logs that correlate per request, rate limiting, retries/backoff where appropriate, and health/metrics where it matters. [4][6][7]
Portable distribution: ship as single Go binaries (and containers where useful), so the “tool layer” is easy to deploy alongside agents. [4][5]

Architecture

At a high level, every server follows the same pattern:

MCP client (hosted by Claude / an agent runtime) communicates with the server (typically over stdio transport).
The server validates inputs, applies middleware (timeouts, logging, rate limits), and calls the upstream API/protocol.
Results are mapped into safe, typed tool outputs (and errors are normalized for the client).

┌───────────────────────────┐ MCP (tools) ┌────────────────────────────┐
│ Claude Desktop / Code │ ───────────────────────────▶ │ mcp-<service> (Go binary) │
│ (MCP host + client) │ ◀─────────────────────────── │ - tool schemas + handlers │
└───────────────────────────┘ JSON-RPC/session │ - auth + validation │
 │ - rate limit + retries │
 └───────────┬────────────────┘
 │
 │ service protocol / API
 ▼
 ┌──────────────────────────────┐
 │ iCloud / Todoist / Notion ... │
 └──────────────────────────────┘

Cross-cutting “production traits”

Instead of building one-off scripts, these servers implement common production patterns:

Timeout middleware on every tool call (so agents don’t hang forever). [4][5][7]
Request correlation IDs and structured logs (debuggable across multi-step agent runs). [4][5]
Rate limiting + backoff when upstream services throttle (e.g., iCloud and Notion). [4][7]
Bulk operation strategies that reduce API calls (e.g., Todoist Sync API batching for bulk changes). [6]
Health + metrics endpoints where running in containers makes sense (notably the iCloud Calendar server). [4]
Automated CI (race detector, linting, vulnerability checks) to keep “tool servers” from becoming unreviewed glue. [4][5]

Key decisions

Go for tool servers: predictable concurrency, easy cross-platform builds, and the “single static-ish binary” deployment model fits MCP servers well, especially when they’re launched per-session or run as small sidecars. [4][5]
Independent binaries per integration: calendar ≠ email ≠ tasks. Separate processes isolate failures, limit blast radius, and make upgrades/rollbacks straightforward.
Local-first auth: app-specific passwords (iCloud), API tokens (Todoist), integration tokens (Notion). The servers are designed so secrets stay on your machine / in your cluster secrets manager, not copied into prompts. [4][5][6][7]
Use an MCP SDK, focus on semantics: the implementations use the Go MCP SDK (mark3labs/mcp-go) so most effort goes into tool behavior, validation, and safety. [8][9]

Outcome

This ecosystem has produced multiple MCP servers that are:

useful (real workflows: schedule management, inbox operations, task execution, knowledge base automation),
operationally hardened (timeouts, retries, rate limits, observability),
portable (binaries + releases for easy distribution),
and structured enough to be safe (typed schemas, validation, tool annotations).

Concrete examples from the current repos:

The iCloud Calendar server exposes 5 tools, supports multi-account, and includes health + Prometheus metrics, audit logging without PII, retries/backoff, and rate limiting. [4]
The iCloud Email server exposes 14 tools and includes thread-safe IMAP access, request correlation IDs, strict validation, and “read-only vs destructive” tool annotations. [5]
Tagged releases exist across the servers (e.g., iCloud Calendar v1.1.0, iCloud Email v0.6.0, Todoist v1.0.0, Notion v0.8.0 published on Feb 7, 2026). [4][5][6][7]

Stack

Go, MCP, mark3labs/mcp-go, CalDAV, IMAP/SMTP, REST APIs (Todoist/Notion), Docker (distroless where applicable), Prometheus metrics (where applicable).

References

[1] Model Context Protocol (MCP): Specification (Protocol Revision 2025-11-25). https://modelcontextprotocol.io/specification/2025-11-25 [2] Model Context Protocol (MCP): Architecture (Protocol Revision 2025-06-18). https://modelcontextprotocol.io/specification/2025-06-18/architecture [3] Roy Gabriel: “Go MCP Server Ecosystem” (original portfolio page). https://www.roygabriel.dev/projects/mcp-servers/ [4] GitHub: roygabriel/mcp-icloud-calendar. https://github.com/roygabriel/mcp-icloud-calendar [5] GitHub: roygabriel/mcp-icloud-email. https://github.com/roygabriel/mcp-icloud-email [6] GitHub: roygabriel/mcp-todoist. https://github.com/roygabriel/mcp-todoist [7] GitHub: roygabriel/mcp-notion. https://github.com/roygabriel/mcp-notion [8] GitHub: mark3labs/mcp-go. https://github.com/mark3labs/mcp-go [9] go.mod (module dependencies) for the MCP servers (e.g., mark3labs/mcp-go used in this ecosystem). - https://raw.githubusercontent.com/roygabriel/mcp-icloud-calendar/main/go.mod - https://raw.githubusercontent.com/roygabriel/mcp-icloud-email/main/go.mod - https://raw.githubusercontent.com/roygabriel/mcp-todoist/main/go.mod - https://raw.githubusercontent.com/roygabriel/mcp-notion/main/go.mod

Llm | Roy Gabriel

Agent Swarms: The New Workforce Architects and Engineers Must Lead

Why this shift keeps showing up

TL;DR

Contents

What Agent Swarms Do Today

Cruvero as the Working Example

The New Role for Architects and Engineers

Why You Must Start Today

References

LLM Development Guide

Chapter 16: Worked Example: Converting an Ansible Playbook to a Go Temporal Workflow

What you’ll be able to do

TL;DR

Table of contents

Scenario

Reference inputs

Plan and phase structure

Implementation skeleton (Go)

Verification

Gotchas

Cruvero - AI Agent Ecosystem Platform

Summary

The Problem

Architecture

Neuro-Inspired Intelligence

Enterprise Governance

Tool Ecosystem & MCP Integration

Observability & Operations

Key Decisions

Outcome

Stack

Chapter 15: Worked Example: Creating a Helm Chart From a Reference Chart

What you’ll be able to do

TL;DR

Table of contents

Scenario

Reference inputs

Phase 1: Plan

Phase 2: Prompt docs

Phase 3: Execute in logical units

Strategy A (recommended): copy the reference chart, then adapt

Strategy B: scaffold from scratch, guided by the reference

Verification

Gotchas

Chapter 14: Building a Prompt Library: Governance + Quality Bar

What you’ll be able to do

TL;DR

Table of contents

Library structure

Prompt entry template

Contribution guidelines

Governance

Verification

Chapter 13: Templates + Checklists: The Copy/Paste Kit

What you’ll be able to do

TL;DR

Table of contents

Plan template

Prompt template

Phase spec template (large projects)

Phase implementation prompt template (large projects)

Work notes template

Session checklists

PR description template

Verification

Chapter 12: Team Collaboration: Handoffs, Shared Prompts, and Review

What you’ll be able to do

TL;DR

Table of contents

Handoff patterns

Mid-phase handoff

Phase boundary handoff

Shared prompt libraries

Review checklist

Verification

Chapter 11: Measuring Success: Solo + Team Metrics Without Fake Precision

What you’ll be able to do

TL;DR

Table of contents

Go: propagate cancellation everywhere with `context`

Go: per-tenant rate limiting with `x/time/rate`