Thoughts on software engineering, LLM-assisted development, and building production systems.
Software architects and engineers who treat AI as simple autocomplete will watch their skills become obsolete in 12 to 36 months. How I built Cruvero as the production control plane for agent swarms that now outperform the top 1 percent of FAANG engineers. Includes my real production example of prepping data and fine-tuning my personal model on two RTX 5090 GPUs.
A trust-first, executable loop for LLM-assisted development: plan artifacts, prompt docs, work notes, verification, and commit discipline (with a worked example).
A production-first guide to running Model Context Protocol servers safely: threat modeling, input validation, budgets, rate limits, and telemetry, implemented with Go patterns.
A production-first comparison of Go and Java Spring Boot for enterprise APIs, focused on real operational cost drivers: memory, startup, deployment surface area, and observability.
An end-to-end example of migrating a procedural runbook to a durable Temporal workflow using reference implementations, phased prompts, and verification.
An end-to-end example of the workflow: plan, prompt docs, work notes, execution loop, and verification to create a new Helm chart from a known-good reference.
How to build and maintain a team prompt library that stays useful: structure, templates, contribution rules, and governance.
A production-first field guide to the 90s-era patterns that quietly tax delivery speed, quality, and reliability - and the modern replacements that actually work.
Minimal templates for plans, prompts, work notes, and checklists. Copy, adapt, and keep the workflow consistent.
How to make LLM-assisted development work on a team: handoff artifacts, shared prompt libraries, and review discipline.
How to measure whether LLM-assisted development is actually helping: practical metrics, baselines, and lightweight reporting.
Concrete stop rules for LLM-assisted development, plus common pitfalls and a recovery checklist when things go sideways.
Why 40-page decks and SharePoint document graveyards slow software delivery - and the lightweight, versioned alternatives that actually help teams ship.
Practical data-handling rules for LLM-assisted development: what never to paste, how to sanitize, and how to verify you didn't leak secrets.
Model choice is an engineering decision: match capability to task complexity, upgrade when stuck, and avoid stale vendor claims.
An example-heavy pattern for multi-week LLM-assisted work: phase specifications, implementation prompt documents, and strict execution gates.
How to scale LLM-assisted development from a 1-day task to multi-week work: sub-phasing, parallelization, and repo hygiene.
A production-first look at how role stacks, handoffs, and proxy decision-making quietly slow delivery, degrade quality, and burn out engineers - and what to do instead.
A repeatable execution loop for LLM-assisted work: implement small units, update notes, verify, and commit (without batching).
How to preserve state across LLM sessions with work notes: decisions, assumptions, open questions, session logs, and commit links.
Turn your plan into reusable prompt docs: phase-aligned prompts with constraints, deliverables, session management, and verification.
How to turn vague work into a phased plan that an LLM can execute safely: goals, constraints, references, verification, and stop rules.
A production-first critique of enterprise Agile theater - and a practical replacement: flow, continuous delivery, and evidence-based planning.
Tracing decisions, tool calls, cost, and side effects across an agent system - without turning logs into a data leak.
Budgets, quotas, and circuit breakers for LLM systems - because runaway cost is just an outage where the failure mode is billing.
Most agent demos assume perfect networks and short runs. Production agents need durable execution: retries, idempotency, replay, and human-in-the-loop - without losing state.
If your eval can't fail when a tool breaks, it's not an eval. Here's how to test tool selection, arguments, side effects, and safety - without flaky 'vibe checks.'
When MCP outgrows local stdio servers, you need a gateway: auth, tenancy, quotas, routing, audit, and safe tool contracts - without killing developer velocity.
Once you have dozens (or hundreds) of tools, 'just include all schemas' stops working. Here's a production-first playbook for tool discovery, ranking, and safe invocation.
Standards don't scale as documents. They scale as templates: a paved road for APIs with built-in reliability, security, and operability defaults.
Prompt injection is real - but it's not just an LLM problem. Secure agents by securing tools, secrets, egress, and outputs with a zero-trust contract.
No posts match your search.
