Architecting for Coding Agents: Prescribe vs Delegate

What's inside

1. Level 1: The Prescription SpectrumFree
   Learn the range of ways to direct a coding agent, from fully prescribed (you fix the design and the agent types it) to fully delegated (you state a goal and the agent decides everything else), and why most real decisions belong somewhere in between.
2. Level 2: What Changes When Agents Write the CodeFree
   See which old architecture assumptions stop holding when an LLM writes most of the code: code becomes cheap to produce, the agent's context window is limited, it forgets between sessions, and checking the work becomes the real bottleneck.
3. Level 3: Factors One and Two: Risk and Reversibility
   Use a simple grid of risk (how much damage a wrong choice does) against reversibility (how cheaply you can undo it) to decide how much a decision should be prescribed.
4. Level 4: Factor Three: Can the Agent Check Its Own Work?
   Judge how well an agent can verify a decision by itself, through compilers, tests, linters and runnable checks, and why decisions it can verify can safely be delegated further.
5. Level 5: Factor Four: How Familiar the Pattern Is
   Understand why agents handle common, well-documented patterns reliably and drift on unusual or in-house ones, and how that should change how much you prescribe.
6. Level 6: Reading the Evidence: Measured vs Opinion
   Learn to sort claims about agent-driven architecture into measured findings, vendor guidance and practitioner opinion, put a date on each, and treat no pattern in this course as settled.
7. Level 7: Pattern: Constraints Instead of Designs
   Prescribe the limits a solution must stay inside (invariants, budgets, forbidden dependencies) rather than the solution itself, so the agent keeps room to design while the important properties stay fixed.
8. Level 8: Writing Constraints an Agent Can Use
   Write constraints that are specific and testable, and that include non-goals, so an agent can follow them, check them and not bend them to fit.
9. Level 9: Pattern: Boundaries and Interfaces as the Fixed Part
   Fix module boundaries and the interfaces between them while delegating what happens inside each boundary, so agent changes stay contained and the system's shape holds steady.
10. Level 10: Contract-First Interfaces
    Express fixed interfaces as machine-readable contracts, such as OpenAPI or JSON Schema documents, protobuf definitions or typed port interfaces, so both humans and agents work from one checkable source.
11. Level 11: Pattern: Types as the Specification
    Use the type system to encode domain rules, such as branded IDs, discriminated unions and illegal states that cannot be represented, so the compiler rejects whole classes of agent mistakes.
12. Level 12: Pattern: Tests as the Specification
    Write acceptance and behaviour tests before the agent writes any code, so the tests are the specification, and learn which kinds of test pin down behaviour without pinning down the implementation.
13. Level 13: Guarding the Specification from the Agent
    Stop agents from "passing" by weakening the spec, through deleting tests, loosening assertions, skipping cases or widening types, and add stronger checks such as property-based and contract tests.
14. Level 14: Pattern: Architecture Rules Enforced by Tooling
    Turn architecture rules such as layering, allowed dependencies and banned imports into automated checks using tools like dependency-cruiser, ArchUnit, import-linter or lint boundary rules, so nobody has to remember them.
15. Level 15: Feedback Loops Agents Can Act On
    Wire architecture checks into the agent's loop, through local commands, pre-commit hooks and CI, and write failure messages that tell the agent what rule broke and how to fix it.
16. Level 16: Pattern: Instruction Files
    Use repository instruction files (such as AGENTS.md or tool-specific equivalents) to record project conventions, commands and design intent that an agent reads at the start of each session.
17. Level 17: The Limits of Instruction Files
    Understand why instruction files are a weak form of prescription: they use up context, they get followed selectively or too literally, they go stale, and nothing enforces them. Learn when to move a rule into tooling instead.
18. Level 18: Layering the Prescription Patterns
    Combine constraints, fixed interfaces, types, tests, tooling rules and instruction files into one layered prescription plan, matching each decision to the lightest pattern that controls it reliably.
19. Level 19: Pattern: Small Modules That Fit in Context
    Size and arrange modules so an agent can load everything a change needs, meaning the code, its interface and its tests, into its working context without guessing at code it cannot see.
20. Level 20: Deep Modules vs Many Thin Ones
    Weigh deep modules (a simple interface hiding a lot of behaviour) against many thin modules (small pieces exposing many interfaces) when an agent has to navigate, change and verify the code.
21. Level 21: Repeated Code vs Shared Abstractions
    Learn when cheap regeneration makes duplicated code the safer choice than a shared abstraction, and when shared code still pays for itself.
22. Level 22: Feature Slices as the Unit of Agent Work
    Organise a codebase into vertical feature slices so that one agent task touches one slice from end to end instead of spreading across layers.
23. Level 23: Disposable Components
    Design components to be thrown away and regenerated behind a stable interface, and recognise which parts of a system must never be treated that way.
24. Level 24: Rewrite Over Refactor
    Decide when telling an agent to rewrite a module from its specification beats asking it to refactor the existing code step by step.
25. Level 25: Placing Human Review Points
    Decide where in the agent workflow a person must review the work, based on the risk and reversibility of each change rather than reviewing everything equally.
26. Level 26: Combining Structural Patterns
    Put the structural patterns together into one coherent shape for a codebase and resolve the conflicts between them.
27. Level 27: Anti-Pattern: Prescription the Agent Ignores
    Find out why long or conflicting instructions are quietly dropped by agents, and how to cut them down to rules that are actually followed.
28. Level 28: Anti-Pattern: Prescription Followed Blindly
    Recognise when an agent follows a rule literally in a situation where it no longer makes sense, and write rules that state their purpose and exceptions.
29. Level 29: Anti-Pattern: Under-Prescription and Drift
    Detect architecture drift when too little is fixed: inconsistent patterns, duplicated concepts and boundaries that slowly erode across many agent changes.
30. Level 30: Anti-Pattern: Architecture Lost Across Sessions
    Understand how design intent disappears between agent sessions and handoffs, and why chat history and agent memory are not a reliable record.
31. Level 31: Keeping Design Intent Alive
    Build a maintenance loop that keeps architecture rules, decision records and instruction files in line with the real code over time.
32. Level 32: How Prescription Shapes Platform Choice
    See how the patterns chosen so far change what you need from a language, framework and host, and why platform is a consequence of prescription rather than its starting point.
33. Level 33: Strong Typing as Agent Guardrail
    Weigh the evidence and trade-offs for strongly typed languages and strict compiler settings when agents write most of the code.
34. Level 34: Fast Feedback Loops
    Design build, test and lint loops fast enough that an agent can check its own work many times within one task.
35. Level 35: Conventional Stacks and Hosting
    Understand why mainstream frameworks, conventional project layouts and declarative hosting tend to be easier for agents to work with, and what that costs.
36. Level 36: The Risk of Choosing Only What the Model Knows
    Weigh the familiarity advantage of popular, older technology against the risk of letting the model's training data decide the platform.
37. Level 37: Building a Team Prescription Policy
    Combine patterns, review points and platform choices into a written team policy that says what is prescribed, what is delegated and why.
38. Level 38: Final Challenge: Architect a Real System Exam
    For a realistic multi-team system, choose patterns from the whole catalogue, set the prescription level for each part, pick the platform, and justify every choice by risk, reversibility, verifiability and familiarity.

Access

The first 2 levels are free with a free account. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Start free →