Software Factories

Pruning Agent Prompts: Why I Cut My Factory's Rules by 65%

Post-mortem fixes bloated my dark factory's agent prompts to 17,072 words in 30 days. See what happened when I cut 65% of the rules and moved them to code.

Agentic Security Scanning: What Our First Loop Found

How I built an autonomous security loop in Leaf with Trivy, Semgrep, and an examiner agent, and what its first 289 findings fixed in BrandCast.

Moneyball for AI Agents: Stop Buying Models, Buy Runs

After 15.8 billion tokens and 208,649 model turns in Leaf, SWE-bench and static price routers like LiteLLM optimize for the wrong thing. Buy runs, not models.

Why Giant Agent Skill Repos Won't Survive 2027

Interactive agent skills rely on progressive disclosure and human guardrails. My token data shows why unattended 2027 loops need radically smaller context.

Inside My Dark Software Factory: How Leaf Runs Locally

How I rebuilt Leaf as a local-first Level 5 dark software factory using adversarial validation, role-scoped WebSocket rooms, and deterministic CI/CD tasks.

Surviving the AI Vulnerability Thunderdome

AI is finding bugs faster than humans can fix them. From the PHP2Shell RCEs to 400 complexity issues in my own code, here is how to survive with agentic SDLC.

Where My Level 5 Software Factory Doesn't Cut It Yet

My Level 5 software factory ships code unattended, until it hits CI limits, 50-node plans, or reward-hacking loops. Three lessons from recent failures.

Loops All the Way Down, Part 6: Output, Not Craft

What the data proved, what it didn't, and what humans give up when agents do the building. The last part of a series on the contract between humans and agents.

Loops All the Way Down, Part 5: Quality Without the Ceremony

Quality gates don't go away when agents write the code. Humans just stop staring at them. A month of factory data on where quality actually comes from, and why the merge button doesn't matter.

Loops All the Way Down, Part 4: Where the Tokens Actually Go

My software factory spent 7.5 billion tokens in a month. Here's what that number hides, where the tokens really go, and why the human side costs more than you'd think.

Loops All the Way Down, Part 3: One Adds, Three Correct

My software factory isn't a pipeline. It's loops inside loops, and only one of them needs a person. A month of data on the loops that build, fix, simplify and watch themselves.

Loops All the Way Down, Part 2: The Contract

If humans and agents do different work, something has to sit between them. In my factory, that's a GitHub issue written as a contract: humans define done, machines check it.

Loops All the Way Down, Part 1: Two Kinds of Work

Agentic development is two different jobs, judgement and mechanics, and we keep running them through one chat window. A series on designing the contract between humans and agents, with a month of data from my own software factory.

Introducing Leaf: A Multi-Agent Coding Orchestrator

I built a multi-agent orchestrator that plans work as a graph, proves completion with merged PRs, and doesn't need anyone watching. Here's Leaf.

Leaf: Multi-Host Orchestration for My Actual Workflow

The one where I investigate automated agentic workflows.

Factory: The Next Phase of Hybrid AI Development

Frontier cloud models write the code. Local models rank and triage the backlog. Here's how Factory automates the dirty work on a dedicated NUC.