Determinism comes from input richness,
not better prompts
Deterministic software doesn't come from a better prompt — it comes from what goes in: small, typed units with intentional micro-gates — friction points where the user makes the call.
The thesis
Modular Determinism
Breaking the build into small, typed units a human gates.
Determinism comes from richer inputs and a human decision at every boundary.
Input richness moves the user upstream: their goals, context, guidelines and playbooks are settled before the agent starts, not discovered through rounds of retries. The work then moves through small, typed chunks with a human check at each one, so the agent needs fewer attempts to get each chunk right.
The Modular SDLC in three steps
Scope the idea into an ordered graph of small, verifiable chunks before any code is written.
Hand each chunk to an agent with a clear role, tools and limits.
The expert reviews and signs off at every gate. They stay accountable, and the work stays theirs.
Small, gated units bring variance and hallucinations down, so agent-built software becomes deterministic.
- Rich inputsThe agent starts from the expert's goals, context, guidelines and playbooks.
- Typed chunksThe build is split into a graph of small units, each with typed I/O, guardrails and an eval checklist.
- Approved chunk by chunkEach chunk is checked against its checklist and approved before the next one starts.
Every gate is built to exercise human judgment and capture it — so the people supervising get more capable over time.
- Capture point, not checkpointThe human sits upstream as the why behind every decision, instead of rubber-stamping outputs downstream.
- All three layersExplicit, tacit and implicit knowledge are captured as digitized rationale that agents follow and people learn from.
- Modular MemoryQuestions, HITL gates, guidelines and playbooks turn each decision into a reusable asset the next build starts from.
Onboard agents like a dev team
Users and subject matter experts bring agents on like a new team — roles, standards, guardrails — then sign off on the work.
Knowledge transfer, by design
AI helps digitize the subject matter expert's knowledge through small HITL gates.
The full SDLC
Shipping the first version is only the start. Modular Chunks also covers what comes after: getting it production-ready, adding features, and keeping it running.
Anthropic¹, Atlassian², and Google³ now describe the same shift: AI agents taking on more of the building, while people set the direction and approve the work. Our work is a bet on the people who drive it: the supervisors — and above all on the users and subject matter experts who bring the knowledge.
Sources: ¹ Anthropic, 2026 Agentic Coding Trends Report · ² Atlassian, Rovo Dev · ³ Google Cloud, 2025 DORA State of AI-assisted Software Development
The Agentic SDLC for the non-technical user
Each arrow is a hand-off to a different person
A development team executes every stage, with AI helping as autocomplete.
You approve at every step before the next one starts
The user or subject matter expert make decisions — that's where their knowledge and experience come in. Agents build inside typed, reviewed contracts.
Knowledge transfer by design
The human's role is changing
Software was the service.
The human was the product — the operator.
People worked the tool: clicking, filling forms, moving data between systems.
AI is the product.
The human is the supervisor.
People direct the work: setting requirements, judging results, signing off.
How your judgment carries into the next build
Get new essays and frameworks
The thesis keeps developing. Subscribe for new posts and frameworks as they're published.
You're on the list. Check your inbox to confirm.