# Lead Architect Reveals His Rules for Coding Agents ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents.webp]] **Creator:** Beyond Coding · **Guest:** Carlos Kelkboom · **Host:** Patrick Akil **Published:** 2026-10-14 · **Length:** 1:15:23 **YouTube:** https://www.youtube.com/watch?v=mkN4uRZYPfs > **Source note:** Summary based on English captions downloaded successfully with yt-dlp; YouTube lists a non-automatic English subtitle track. Names and technical terms were normalized against the description and external references. No Whisper or TubeAlfred was needed. Screenshots are 360p frames from the video; this is a studio conversation, not a slide demonstration. No paid promotion or affiliate disclosure was apparent in the supplied description or caption text; absence here is not proof that no commercial relationship exists. ## Outline ### 0:53 — Collaboration is slipping away - [1:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=60s) Kelkboom’s first concern is social rather than technical: engineers increasingly work with agents instead of colleagues. Pull-request discussion and shared judgment can disappear even while individual output rises. He presents this as a trend he observes through conversations with companies, not a measured industry-wide result. - [2:25](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=145s) Fast demonstrations are not finished products. Games still need game design and contact with players; an engineer must remember who the software is for. Product understanding becomes more important when implementation gets cheaper. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0060.webp]] ### 3:50 — Starting is easy; intention determines when to finish - [4:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=240s) Akil describes using subscription allowances as an incentive to start experiments before his credits expire. He can generate a game or harness without doing the hardening, packaging, and follow-through necessary to sell it. - [4:45](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=285s) Kelkboom has also left compilers unfinished. The distinction is the purpose: learning or having fun may already be a successful outcome, whereas a company or durable product requires finishing. Clarify the intention rather than treating every experiment as a failed business. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0240.webp]] ### 6:06 — Escape the agent bubble and protect thinking time - [6:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=370s) Lower the barrier to human collaboration through meetups, shared reviews, and a welcoming community. Ideas feel personal even when they are cheap globally; fear of theft or embarrassment should not prevent people from sharing them. - [8:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=480s) Asking an agent first can become a substitute for every human interaction. Multiple models and adversarial setups may challenge an answer, but they do not replace the slower reflection that helps a person form an independent view. - [9:35](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=575s) He invokes John Cleese’s open and closed modes of creativity: open exploration needs mental space, while constant feeds and immediate AI answers keep people reacting. Learning requires time to internalize patterns; speed alone is not understanding. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0370.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0540.webp]] ### 11:54 — Scaffold the architecture before asking for implementation - [12:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=720s) Kelkboom manually creates directories, files, comments, class names, and function signatures. The scaffold encodes his intended boundaries and dependency flow, rather than leaving an agent to invent the architecture while solving a local problem. - [13:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=780s) For a compiler, he sketches the lexer, language specification, abstract syntax tree to intermediate-representation flow, and example programs. This can take twenty minutes to an hour, but gives the agent a precise implementation target. - [14:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=840s) Without that structure, he has seen duplicate concepts, God objects, and deployment scripts replaced by several poorly understood alternatives. A locally functioning patch may make the overall application less coherent. The claimed productivity gains are his experience, not controlled measurements. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0720.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0810.webp]] ### 15:54 — Use agents to learn unfamiliar languages, not to bypass learning - [16:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=960s) Study several existing open-source projects, then ask the agent to distill good and bad patterns and explain their fundamentals. A teaching or questioning skill can be more useful at this stage than immediate code generation. - [16:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1000s) Step away, reflect, return with questions, and test a small proof of concept. Resist the early dopamine hit of getting a whole implementation before the design is understood. - [18:30](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1110s) His compiler anecdote illustrates the cost of skipping this: a list feature had been implemented five times. Cleanup still requires a person to recognize the duplication and understand the desired alternative. - [20:05](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1205s) When moving from a familiar language such as C# to Go, ask explicitly for idiomatic differences and review a rough scaffold. The sketch can be imperfect; its value is communicating intent and surfacing disagreements before the full build. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t0960.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1110.webp]] ### 21:14 — A speculative language with bounded memory and three layers - [21:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1280s) Kelkboom proposes eliminating the heap, pointers, and dynamic allocation in favor of a deterministic runtime. This is his language-design agenda, not a claim that existing general-purpose languages already work this way. - [21:50](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1310s) He imagines three layers: a human-facing mixture of natural and structured language; a visual or audio representation that lets people challenge what the system thinks they mean; and executable machine representation stripped of older assumptions. - [22:50](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1370s) Bounded loops and records laid out in advance would make memory use easier to reason about. Satellites and robots motivate the argument: finite memory should not be exceeded unpredictably during operation. - [24:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1460s) He contrasts CPU and GPU programming and argues for predictable data layouts and SIMD-friendly execution. His description of GPUs as having no heap or allocation is an oversimplification; GPU platforms do support dynamic allocation. - [26:15](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1575s) Rust is discussed as useful but personally difficult to refactor. He links ownership to heap management and sketches stable records accessed by indices and offsets. Removing heap allocation alone does not eliminate aliasing concerns, concurrency races, or every reason to track lifetimes. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1280.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1460.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1650.webp]] ### 28:32 — Shared definitions should evolve with the system - [28:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1720s) Akil asks how teams can communicate when even “agent” or “component” has several meanings. Kelkboom suggests starting with a small concrete shared definition—such as a customer ID—then evolving it together. - [30:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1800s) A customer schema can anchor agreement while sales and marketing maintain different views. The collaboration should cover how the definition evolves, not merely freeze today’s model. His criticism of formalized agile is an opinion about process, not a factual finding. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1720.webp]] ### 31:31 — Vibe coding can satisfy a goal without teaching the craft - [31:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=1900s) Akil values outcomes and describes a harness that lets family members create games through speech. Kelkboom accepts that a playful result that makes people happy can be a perfectly valid objective, even without deep code inspection. - [35:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2110s) The question changes if the aim is to learn game engineering or maintain a larger product. Working with an experienced designer could reveal architectural choices invisible to a solo developer and agent. - [37:15](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2235s) Scaffolding need not mean exhaustive ceremony. Identify which parts matter to the goal, and encode those priorities. Reflection between attempts lets the next version emphasize a better database model, application layer, or game-engine boundary. - [38:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2320s) He distinguishes writing code from engineering an application: agents can patch over old concepts rather than cleanly replace them. His suggested experiment is to redo the same game with explicit folders, Markdown responsibilities, assets, and dependency directions, then compare outcomes. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t1900.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2110.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2320.webp]] ### 40:12 — Code is cheap: compare parallel implementations - [40:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2420s) An experiment can be thrown away instead of incrementally defended. Kelkboom sometimes makes three branches or worktrees, lets three agents implement independently, and asks a fourth to compare them and merge only useful parts. - [41:05](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2465s) The benefit is wider exploration, not automatic correctness. The human still needs a criterion for selecting the result and must understand what is being retained. Worktrees separate working files; they do not settle merge conflicts or architectural disagreements. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2420.webp]] ### 41:45 — Scaffold deeply enough to encode the important decisions - [41:50](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2510s) His own scaffold can include Rust crates or C# projects, named boundaries, Markdown explanations, diagrams, and core files. He admits he goes deeper than he would advise everyone else to go. - [42:45](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2565s) A lexer signature forces a decision about what a token contains. An explicit source span and file/line information can be more useful than whatever enum-plus-position representation an agent would otherwise invent. - [43:30](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2610s) The experimental language project is not presented as a mature public product. He is cautious about sharing a first impression without guidance on where the design is meant to go. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2510.webp]] ### 45:09 — Democratization needs security, mentoring, and real problems - [45:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2720s) He imagines a community matching people who have spare tokens and engineering skill with practical needs. Software should solve clearly identified human problems; it is not enough merely to make generation accessible. - [46:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2780s) People building software still need help with security checks and penetration testing. His warning is that agents will not reliably supply every necessary safeguard unless someone makes those requirements explicit. - [47:30](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2850s) He worries that juniors are learning to operate a tool without the underlying craft, particularly as code-review conversations disappear. Claims about enrollment decline and industry-wide junior training are not supported by data in the episode. - [48:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=2920s) He separates three concerns: genuine scientific advances such as AlphaFold; questions about LLM economics and energy use; and concentration of wealth, privacy risk, and power in large technology firms. The prediction of an AI bubble is uncertain, not established. - [52:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3140s) He bought an unspecified machine-learning book and built small neural networks to learn the fundamentals. The lesson is to develop a base that survives two weeks away from the news, rather than chase every release. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2720.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t2920.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3150.webp]] ### 53:33 — A distributed graph for progressive context disclosure - [53:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3220s) Akil frames scaffolding as forward pressure and asks about feedback or back pressure. Kelkboom says his harness changes with models, but the persistent problem is finding the right knowledge without making context too large or expensive. - [54:50](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3290s) His analogy is a social network: first identify relevant nodes, inspect small metadata such as a one-line summary, path, or commit hash, rank relevance, and then follow links deeper. The user can confirm whether the retrieved information is useful. - [55:40](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3340s) He makes agents examine a commit diff before the full code. Seeing what changed helps prepare context for why the implementation looks as it does. - [56:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3380s) The graph is distributed rather than stored in a graph database. Markdown files represent information nodes; indexed/vector-style search and keyword search over frontmatter help locate them. The exact implementation and retrieval performance are not supplied, so this is a design description rather than a reproduced system. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3220.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3380.webp]] ### 58:18 — The main agent converses; subagents change files - [58:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3500s) His main conversational agent stays in an open mode: it does not edit code or change the machine. It teaches, asks questions, and stores useful learning in the information graph, then delegates execution to subagents. - [59:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3550s) The separation responds to a concrete annoyance: when he asked about John Cleese’s creativity talk inside a game-engine project, the agent immediately offered to implement it. Disabling direct edits helps preserve exploration instead of turning every thought into work. - [60:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3620s) He uses local model scoring, described as Gemma in the captions, and wants the agent to ask to start subagents only when it is over 90% confident it understands him. This is a self-reported control heuristic, not a statistically calibrated probability. - [61:15](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3675s) He prefers large, well-specified execution batches because he finds agents better at one-shot implementation than repeated architectural change. Akil connects that observation with SlopCodeBench. The spoken model/version and approximate 15% figure are unclear; do not treat them as a verified leaderboard entry. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3500.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3650.webp]] ### 63:07 — Reject unrecognizable output and repair the premise - [63:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3790s) Kelkboom does inspect generated code. His first gate is whether he recognizes the scaffold and expected concepts. If not, he discards the worktree rather than merging something he cannot readily reason about. - [64:20](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3860s) He can stop a long run after an hour or two, inspect it, close the agent, and start a fresh conversation about what went wrong. Conflicting design ideas or an insufficient scaffold are fixed before trying again. - [65:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3900s) The intent is to move uncertainty into explicit constraints or deterministic scripts wherever practical. This is not an instruction to skip testing whenever code looks familiar: recognition is only the first review step. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3790.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3900.webp]] ### 66:25 — Review intent, test the tests, and keep humans talking - [66:30](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3990s) Large volumes of cheap code are not an excuse to stop reviewing. Kelkboom argues for less code, smaller features, and more review steps when the result cannot otherwise be validated. This qualifies his earlier preference for big execution batches: broad generation must not become unreviewable merging. - [69:00](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=4140s) Akil suggests exposing the upfront conversation and design reasoning to reviewers, plus visualizations of where complexity was added. Review may need to examine intent and architectural change, not simply every generated line. - [70:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=4210s) Kelkboom points to mutation testing: alter code and check whether tests detect it. Passing unit tests can be too favorable to the implementation; a stronger evaluation probes whether the tests fail for deliberate mistakes. - [71:30](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=4290s) He wants analysis of how much of the original scaffold survives and how each commit advances the solution. Product vision, architecture, and deployment choices are still senior-engineering work. - [72:25](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=4345s) AWS, S3, PostgreSQL, SQLite, and local deployment illustrate decisions to settle before execution. SQLite’s file-backed nature affects persistent storage; the agent should not silently choose the operational model. - [74:10](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=4450s) They end where they began: bring engineers together to compare workflows, make mistakes, and learn. Community sessions would test whether scaffolding actually improves outcomes instead of leaving everyone isolated with an agent. ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t3990.webp]] ![[images/Lead-Architect-Reveals-His-Rules-for-Coding-Agents-t4220.webp]] ## Things mentioned ### People, talks, and research - **Carlos Kelkboom** — guest and lead architect; compiler construction and agent scaffolding are his recurring examples. - **Patrick Akil** — host; describes his own game-building harness, credit-use incentives, and outcome-focused approach. - **John Cleese, Creativity in Management** — the open/closed creativity talk is cited, not a particular book. The main-agent design borrows its distinction between exploration and execution. - **Dex Horthy** — mentioned in connection with a previous interview about context engineering. The assertion that he coined the term is not independently established here. - **SlopCodeBench** — iterative agent-coding benchmark; extends an agent’s own solution across changing specifications. - **AlphaFold / Google** — used as an example of meaningful scientific progress. The separate “cell thing” is too vague to identify confidently. ### Tools, languages, and platforms - AI coding agents, Claude (caption normalization), subagents, local Gemma scoring, adversarial/multimodel review. - Git, GitHub, branches, and **Git worktrees** — parallel experimental implementations and throwaway workspaces. - Markdown, YAML frontmatter, indexed/vector-style search, keyword search, information graphs, commit hashes and diffs. - C#, Go, Rust, JavaScript; Rust crates and borrow checking; compilers, lexers, tokens, abstract syntax trees, intermediate representations. - raylib — suggested as a possible 2D game-building tool, not demonstrated. - CPU, GPU, SIMD, heap allocation, fixed records and offsets, bounded loops, static analysis, unit tests, mutation testing. - AWS, S3, PostgreSQL, SQLite, local applications, file-backed persistence, deployment scripts. - Reddit, YouTube, LinkedIn, social media, meetups, game communities. The caption’s exact Warcraft-related title is uncertain, so it is not treated as a verified game title. ### Design and process concepts - Intent before output; product discovery; finished software versus experiments; learning versus shipping. - Architecture-first scaffolding, dependency boundaries, source spans, avoiding duplicate concepts and God objects. - Progressive disclosure, retrieval ranking, diff-first context, open conversation versus execution. - Pull-request discussion, shared evolving domain definitions, junior mentoring, security review, back pressure and deterministic checks. ### Books - **Unidentified machine-learning book — author unknown** ([52:31](https://www.youtube.com/watch?v=mkN4uRZYPfs&t=3151s)). Kelkboom says he bought a book and built neural networks. Neither title nor author is given, and the description is not distinctive enough to identify it responsibly. - **No book title is named aloud or confidently identifiable from a description.** Cleese’s talk and the benchmark paper are not silently converted into books. The phrase “bulk of my work experience” is mistranscribed as “book” around 15:16 and does not refer to a publication. ## Claims check Checks distinguish what the speakers report from what the cited source establishes. Accessed 2026-11-08; these are targeted checks, not independent replication of the workflow. | Claim | Assessment | Evidence and limits | |---|---|---| | Agents struggle to extend their own code over repeated changes. | Supported for a particular benchmark, not a universal rule. | [SlopCodeBench paper](https://arxiv.org/abs/2603.24755) describes 36 problems and 196 checkpoints, with rising structural erosion and verbosity across many trajectories. Its evaluated Python track and harnesses do not establish that every agent or real project should use one-shot generation. | | The benchmark result was roughly 15%, for a named model/version. | Exact spoken attribution not verified. | The captions garble the model name. The paper reports a best 14.8% checkpoint result, while the [leaderboard](https://www.scbench.ai/leaderboard) distinguishes strict and isolated solves. Those are not interchangeable with an end-to-end success rate. No precise model claim is reproduced from the garbled sentence. | | Worktrees let several agents work separately on one repository. | Correct, with limits. | [Git documentation](https://git-scm.com/docs/git-worktree) supports multiple working trees and branches sharing repository data. Isolation of checked-out files is not isolation of all external processes, databases, or services; integration still needs review. | | Removing the heap makes programs deterministic and removes the need for Rust-style borrowing. | Overstated. | [The Rust Book](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html) explains ownership, lifetime, stack, and heap behavior. Fixed memory layouts can bound allocation, but nondeterminism can still arise from concurrency or input; aliasing and reference lifetimes can matter without heap allocation. Rust’s borrow rules do not simply disappear as a general consequence. | | GPUs have no heap or dynamic allocation. | Incorrect as a universal statement. | [CUDA programming guide](https://docs.nvidia.com/cuda/cuda-programming-guide/05-appendices/device-callable-apis.html) documents device memory and dynamic allocation facilities. Preallocation is a common performance/design choice, not a capability limit of GPUs. | | Mutation testing probes whether unit tests detect changed behavior. | Correct. | [Stryker documentation](https://stryker-mutator.io/docs/) explains intentional mutants, killed when tests fail and surviving when tests pass. Surviving equivalent mutants are a limitation; a score is not proof of overall correctness. The CPU-damage anecdote is unverified and not an ordinary expected effect of testing. | | Cleese distinguished open and closed creative modes. | Correct attribution. | [Creativity talk transcript](https://github.com/UweKeim/John-Cleese-on-Creativity/blob/master/Transcript.markdown) describes relaxed exploration and purposeful execution. This verifies the reference, not a controlled scientific claim that agent use prevents creativity. | | A model’s “90% confidence” means it reliably understands the user. | Not established. | No calibration experiment, scoring rubric, or measured error rate is supplied. Treat the score as Kelkboom’s workflow heuristic rather than a probability guarantee. | | Collaboration and junior education are declining throughout the industry; AI is a bubble. | Unverified/generalized opinion. | The episode supplies observations and fears, not systematic enrollment, hiring, review, financial, or energy data. There may be real risks, but the scope and predictions cannot be inferred from these anecdotes. | | Manual scaffolding guarantees 10× or 100× productivity. | Not established. | The discussion uses emphatic productivity language, not a controlled comparison. Scaffolding is a plausible technique to try, and should be evaluated against actual maintenance, quality, and delivery outcomes. | ## Biographies ### Carlos Kelkboom Lead architect and software engineer introduced in this episode. Earlier Beyond Coding appearances discuss innovation and transferable engineering skills; his experience spans languages and compiler construction. In this conversation he describes an experimental programming language and a custom agent harness. Employer, formal qualifications, and the production maturity of those projects are not independently established here. Sources: [episode description](https://www.youtube.com/watch?v=mkN4uRZYPfs), [earlier innovation interview](https://www.youtube.com/watch?v=6QfyY9ffz6M), [transferable skills interview](https://www.youtube.com/watch?v=heKOXS8QZWM). ### Patrick Akil Software engineer and host of Beyond Coding, where he interviews engineers and technology leaders about technical craft, product thinking, leadership, and career development. He is the interviewer here and supplies the game-harness examples. Sources: [public profile](https://linkedin.com/in/patrick-akil), [episode listing](https://podcasts.apple.com/us/podcast/lead-architect-reveals-his-rules-for-coding-agents/id1572440477?i=1000796296724). ### John Cleese British actor, comedian, and writer associated with Monty Python and Fawlty Towers. His management talk on creativity, rather than his comedy work, is relevant here: open exploration and closed execution provide the analogy for Kelkboom’s conversational and implementation agents. Source: [Creativity in Management recording](https://www.youtube.com/watch?v=nvKeu46jgwo) and [transcript](https://github.com/UweKeim/John-Cleese-on-Creativity/blob/master/Transcript.markdown). ### Dex Horthy CEO and cofounder of HumanLayer and a previous Beyond Coding guest associated with context engineering. See [HumanLayer’s context-engineering article](https://www.humanlayer.com/blog/advanced-context-engineering) and [his Beyond Coding interview](https://www.youtube.com/watch?v=vKT59uoByXc). The present video does not establish that he originated the phrase; avoid converting the host’s attribution into a verified historical fact. His role in this note is the interview/benchmark reference, not participation in this episode. ## Practical synthesis 1. Decide whether this run is for learning, experimentation, delight, or a durable product; judge completion by that purpose. 2. Do the senior work explicitly: domain model, architecture, boundary types, deployment, and acceptance criteria. 3. Let a conversational agent question the plan before any implementation agent begins changing files. 4. Retrieve only the relevant context, progressively; use history and diffs to explain why the code exists. 5. Explore alternatives in separate worktrees, but do not mistake multiple agents for independent proof. 6. Inspect whether the result preserves the intended design. If not, repair the scaffold or premise instead of layering patches onto an incoherent branch. 7. Keep reviewable changes and strong checks, including tests of the tests when valuable. A big generation batch does not justify an unreviewable merge. 8. Continue learning and talking to humans. Generated output is not a replacement for shared understanding.