Skip to the content
Software Made Clear
Search the whole site About

TOPIC 43 ARTICLES

Software Factories & AI Coding Workflows

How to turn a request into a tested software change with AI agents, existing development tools and people who review the work and handle failures.

NEW TO THE TOPICStart with the big pictureWhat a software factory is WANT THE FULL ROUTE?Follow the four stagesFrom the first request to learning after release

EXPLORE THE TOPIC

Start here, then see what’s new

The introduction comes first. Recent writing follows, with dates to help you spot new ideas.

START HERE 01 / 43 FIRST READ What a software factory is See how a software factory connects planning, coding, tests and review, what AI agents do, and where a person still needs to decide. Read it →
DEEP DIVE Code Review in the Age of AI-Generated PRs A read order and copy-paste checklist for reviewing an AI-authored pull request, plus the sourced figures that motivate each step and where each one comes from. Read it →
DEEP DIVE The Bus Factor in an AI-Written Codebase: How to Measure Who Actually Understands Your Code Audit your AI code bus factor with five concrete comprehension checks, an interactive adjustment, and a transparent hypothetical example. Read it →
DEEP DIVE AI agent user experience: keep people in control Design agent interfaces that show the permitted task, support precise corrections and make approvals meaningful, without inventing confidence scores. Read it →
DEEP DIVE AI coding and the human attention bottleneck Keep AI-generated changes understandable: decide permissions before coding, inspect code and tests, and stop starting work when reviewers cannot keep up. Read it →
DEEP DIVE AI confidence explained: what does 90% mean? Distinguish a model's confidence score from measured accuracy. Work through calibration, missed cases and thresholds without treating certainty as permission. Read it →
DEEP DIVE AI decision models explained: choices and checks Follow a support request through rules, model classification and application checks. Learn what decision models such as Jev do, and what they do not prove. Read it →
DEEP DIVE An Angular software factory, one feature at a time Follow one Angular booking feature from agreed behaviour to reusable components, server checks and tests, then reuse the parts that should stay consistent. Read it →
DEEP DIVE Designing tools for AI agents: clear inputs, safe actions Follow a document update through tool discovery, exact identifiers, version checks and permissions. Learn why valid JSON is not a valid action. Read it →
DEEP DIVE Do AI agents learn? Memory is not model training Distinguish conversation history, saved memory, retrieval, changed instructions and model training. Follow one preference and see what to test. Read it →
DEEP DIVE Model cascades: when a cheap first decision saves money Calculate a two-stage AI workflow's complete cost, then count the relevant material its first filter misses. Compare savings without quietly lowering quality. Read it →
DEEP DIVE RAG troubleshooting: find where the evidence was lost Trace a wrong RAG answer from its source through indexing, retrieval and context assembly. Separate missing evidence from a model misreading good evidence. Read it →
COMPARISON Single-agent vs multi-agent: when splitting the work helps Compare one agent with several using the same task. See when separate investigations help, when dependencies get in the way, and what to measure. Read it →
DEEP DIVE The AI vampire: when faster coding creates more work What the AI vampire means, what the research supports, and how a worked review-budget example helps teams avoid turning faster coding into overload. Read it →
DEEP DIVE Turn vague AI requests into decisions you can test Replace a vague request to find useful information with explicit questions, supplied comparison text, meaningful outcomes and reviewed test cases. Read it →
DEEP DIVE Type-safe AI output is not the same as a correct decision A model can select a valid document ID and still select the wrong document. Separate output shape, meaning, permission and execution with one worked example. Read it →
DEEP DIVE What is an AI agent? Follow the next decision Follow a support request to see how an AI agent chooses tools, uses their results and stops—and how that differs from a chatbot or fixed workflow. Read it →
DEEP DIVE Why AI-generated tests can pass with the wrong code Run a booking example where tests miss a deadline bug. Add the missing boundary check and see what coverage and mutation testing tell you. Read it →
DEEP DIVE 12-factor agents: actions, saved progress and retries Learn the twelve agent-design principles through a pull request that times out: what the model proposes, what the program allows and how work resumes. Read it →
DEEP DIVE AI software factory limits: tests, maintenance and review See what passing tests can miss in an AI software factory: duplicated rules, growing review queues and changes that are difficult to undo. Read it →
DEEP DIVE Context engineering: what an AI agent needs to see Learn how to choose an agent's instructions, code and test results, avoid stale information, and distinguish context engineering from prompting and RAG. Read it →
DEEP DIVE Context rot: when to shorten or restart an AI session Recognise repeated mistakes and buried requirements in an AI coding session. Learn what context rot means, when to reset and which work to preserve. Read it →
DEEP DIVE Loop engineering: when an AI agent should retry or stop Design repeated agent work around actual test results, saved progress and stopping rules. Follow a repair loop and a recurring maintenance example. Read it →
DEEP DIVE Research, plan, implement: prepare the next coding step Guide an agent through existing code: find the current behaviour, agree on the change, plan a testable part and pass on findings without a whole chat history. Read it →
DEEP DIVE Spec-driven development: keeping specifications and code aligned Learn which specifications to maintain, how they differ from implementation plans, and what to do when the written rule, tests and running code disagree. Read it →
DEEP DIVE Deterministic steps and AI steps Choose scripts for explicit rules and AI for investigation. See when one model call is enough, when a workflow fits, and which checks code must enforce. Read it →
DEEP DIVE Ephemeral environments and seed data Give an agent a runnable test environment with isolated state and invented data. Learn what to preserve, what to clean up and which startup costs to measure. Read it →
DEEP DIVE From vague request to ready ticket Turn a vague request into a coding task by checking the existing code, asking specific questions and recording the behaviour and tests people agreed on. Read it →
DEEP DIVE Golden sets: testing the factory Compare agent changes on repeatable tasks with expected outcomes, turn discovered failures into regression cases and measure complete runs rather than one step. Read it →
DEEP DIVE Harness engineering: the tools and checks around an agent See how a harness supplies tools and permissions, enforces access rules, and lets you replace a component without silently changing its meaning. Read it →
DEEP DIVE How agents hand work over through saved records See what one agent should leave for the next: the request, changed code, test results and unfinished work, with an example handover record. Read it →
DEEP DIVE Incidents back into the backlog Turn repeated errors into useful follow-up work: group related events, update existing tickets and distinguish a returning defect from delayed old reports. Read it →
DEEP DIVE Measuring a factory honestly Compare similar work with and without a software factory, counting review, rework and quality alongside speed. Avoid rewarding code volume over useful changes. Read it →
DEEP DIVE Orchestrator, or just a pipeline? Decide whether an agent task fits your existing CI pipeline or needs saved workflow state for approvals, restarts and shared ownership. Read it →
DEEP DIVE Prompt injection in a pipeline See how instructions hidden in tickets, code or logs can redirect an agent, why structured handovers do not remove the risk and which permissions to restrict. Read it →
DEEP DIVE Scoped credentials and the kill switch Limit what each agent can read and change, stop new and active work, and test that temporary permissions expire without relying on instructions alone. Read it →
DEEP DIVE The coding agent and its repair loop Follow a coding agent from a ready task to a tested change, including limited repair attempts, scope changes, blocked tests and a handover to a person. Read it →
DEEP DIVE The human merge gate Decide what a person must review before an agent's change is merged, how consequences affect review depth and how to prevent approval becoming a formality. Read it →
DEEP DIVE The pull-request review agent Use an AI reviewer to inspect proposed code, tests and requirements. Keep revision-specific findings separate from fixes, build results and merge approval. Read it →
DEEP DIVE Verifying after the deploy Check that the intended version is serving before judging a release. Distinguish missing version information, rollout delays and failed behaviour checks. Read it →
DEEP DIVE What a merged change costs Calculate agent costs across complete tasks, including retries, failed runs, test environments and human review. Compare savings without weakening checks. Read it →
DEEP DIVE When an agent stops and asks Design an agent's handover to a person: ask a specific question, save progress, route it to someone who can decide and resume after checking the answer. Read it →
DEEP DIVE Who owns the factory Decide who maintains the agent tools, answers questions and handles failures. Match support hours and the manual fallback to how teams use the factory. Read it →