Skip to content

Blog

Archive

Every article on the blog, newest first.

  1. Measuring AI impact on engineering: what to count and what to ignore Code volume, pull requests, usage: AI pushes up every number that is easy to count. A Stanford talk and DX data put the measured gain at around 10 percent, and it swings widely from company to company. What to measure instead, where the returns come from, and why things get worse before they get better. 13 min read Measuring AI impact
  2. Breaking the Loop: Why agents never finish on their own Agents in a software factory always find another problem, another ticket, another improvement. Only a second, much slower loop can say when the work is finished: the one that reaches the market. 22 min read Specification and review
  3. A label on an issue is the whole protocol between agents The development-workflow skill in the software-factory.dev factory is the factory's own map of itself. It shows that the automations never call each other: they coordinate through labels on issues. 2 min read Software Factory
  4. Report the daily delta, not the total that only goes up The Tweet Drafter in the software-factory.dev factory posts updates three times a day and reports the daily delta, not the cumulative total, because a total always looks like progress. 2 min read Measuring AI impact
  5. An automated status report is only as honest as its prompt The weekly recap automation in the software-factory.dev factory stays honest because the honesty is written into its prompt: the challenges section is what makes it authentic, and an unrecorded number has to be named as unrecorded. 2 min read Software Factory
  6. A metric without a red line is decoration The weekly Performance Monitor in the software-factory.dev factory works because every metric it watches has a hard threshold written into it. 2 min read Measuring AI impact
  7. An automation that audits the factory must not rewrite its own record The automation auditor in the software-factory.dev factory inspects every other automation on the line. Its most useful rule: it may never overwrite last week's audit. 2 min read Software Factory
  8. Escalated work needs a return path back onto the line The smallest automation in the software-factory.dev factory puts escalated issues back on the line once a human has answered. The return path from human to machine needs its own owner. 2 min read Software Factory
  9. Set the stale-work clock from your agents' cycle time The Stale-Issue Reviewer at software-factory.dev calls work stale after three hours, not three days, because a watcher's clock has to run at the speed of the line it watches. 2 min read Software Factory
  10. The PR Shepherd resolves only the conflicts it understands The PR Shepherd in the software-factory.dev factory rebases conflicted pull requests but hands semantic conflicts to a human. The hard part of automation is encoding where its competence ends. 2 min read Software Factory
  11. Verify UI components in the page they ship in The UI Verifier in the software-factory.dev factory screenshots every changed component twice, in isolation and in the real page, because a component that passes in isolation can still fail where it ships. 2 min read Specification and review
  12. Coding agents are an organizational-design problem Cheaper local generation pushes the coding-agent constraint into team practice, the shared platform, governance, and learning. One practitioner's four-level model of that shift, held up against what DORA can and cannot support. 6 min read Organization and roles
  13. Why faster coding does not guarantee faster delivery Productivity research measures task time, perceived savings, pull requests, and production flow, each in its own way. Read side by side, the measures show where the constraint moves. 4 min read Measuring AI impact
  14. Software Factory evidence and its limits Public implementations show that agent-run delivery systems can build and ship software. Read their numbers with a source label, a scope, and careful limits. 3 min read Measuring AI impact
  15. Verification in a Software Factory When generating code gets cheap, a Factory's throughput depends on how well the system can establish that a change is acceptable, safe, and worth shipping. 3 min read Specification and review
  16. Green CI does not prove the live site works The Post-Merge Verifier in the software-factory.dev factory smoke-tests the real production site after every merge, because passing tests and a working site are two different claims. 2 min read Specification and review
  17. What is a Software Factory? A Software Factory coordinates agents, context, deterministic gates, and human decisions across the path from intent to production. 3 min read Software Factory
  18. An auto-merging PR reviewer is safe once it knows when to stop The PR Reviewer in the software-factory.dev factory merges code with no human approval. One number makes that safe: it gives up after three failed attempts to fix CI. 2 min read Specification and review
  19. Daily metrics that cannot drift: subtract yesterday's total The Daily Metrics automation in the software-factory.dev factory never measures a daily change with a date-filtered query. It subtracts yesterday's cumulative total from today's, a method that cannot drift. 2 min read Measuring AI impact
  20. A bug-fix automation must never exit quietly The bug-fix automation in the software-factory.dev factory has two ways to end a run: it ships a fix or escalates to a human. Honest failure is a feature you have to design. 2 min read Software Factory
  21. The Feature Builder checks for open bugs before it builds The software-factory.dev build automation runs a pre-flight check first: a priority-1 or priority-2 bug nobody has picked up stops all new feature work. 2 min read Software Factory
  22. An improvement automation needs a cap on its ambition The Product Improver in the software-factory.dev factory files at most three issues a run, and zero when it finds nothing worthwhile. 2 min read Software Factory
  23. Fix the incident and the rule in the same commit The Incident Responder in the software-factory.dev factory updates the conventions document in the same commit as the fix, so the rule that would have prevented the bug is there before the next change. 2 min read Software Factory
  24. Cross user feedback against usage before it becomes work The Feedback Digest in the software-factory.dev factory reads new feedback next to seven days of usage data, and files an issue only when the evidence backs it. 2 min read Software Factory
  25. The Feature Planner writes its own backlog, behind a human gate The triage automation in the software-factory.dev factory also writes its own backlog when the line runs dry, and routes anything risky through a person first. 2 min read Software Factory