Video summary

Lead Architect Reveals His Rules for Coding Agents

Main summary

Key takeaways

Technology

Summary

Carlos Kelkboom argues that coding agents are good at producing large, self-contained implementations in one pass, but less effective at maintaining and evolving an application through repeated changes. He uses agents as implementation tools while retaining human responsibility for product decisions, architecture, and structure.

How Carlos works with coding agents

  • Scaffold before delegating. He manually creates folders and files, defines project boundaries, and adds comments, class or function names, signatures, diagrams, and examples. For a compiler, for instance, he might define the lexer file and token structure before asking an agent to implement them.
  • Make the task and architecture explicit. He decides important matters—such as how components fit together, how the application will be deployed, and which storage or database choices to use—instead of leaving them for the agent to invent. Without this direction, agents may duplicate code, create overly broad objects, ignore existing scripts, or build something difficult to extend.
  • Discuss before implementation. His primary agent operates in an “open” mode: it can teach, ask questions, and help clarify the task, but cannot modify files. It can launch implementation sub-agents only when sufficiently confident; he describes using a confidence threshold above 90%.
  • Give agents broad, well-defined work. Carlos says agents often do better with a large task specified carefully up front than with many iterative changes. He tries to resolve conflicting ideas and clarify requirements before implementation begins.
  • Review early and discard freely. He works in Git worktrees, checks an implementation after roughly an hour or two, and asks whether it matches his expectations and follows the scaffold. If he cannot understand the code or recognize the intended structure, he throws the work away rather than merging it. He then discusses what went wrong with a fresh agent context and adjusts the requirements or scaffold before trying again.
  • Run parallel experiments. He may have several agents work in separate branches or worktrees, then ask another agent to compare the results and retain only the good parts. The underlying principle is that generated code is cheap, so experiments should be easy to discard and redo.

Context and project knowledge

Carlos describes a harness for giving agents relevant project knowledge without overwhelming them with a large, costly context:

  • It represents information as a distributed graph, with Markdown files describing nodes and edges.
  • Front matter supports keyword search and a factorized index. Paths, hashes, URLs, and short descriptions point to deeper information.
  • The agent progressively follows relevant links, with information ranked for usefulness. Carlos says he often has it inspect commits and diffs before full code, then drill further into the source when needed.
  • Knowledge from conversations can be added to the graph for later retrieval.
  • The design aims to preserve context across sessions while keeping it manageable and distributed, rather than placing everything in one large database or prompt.

Engineering quality, review, and testing

Carlos distinguishes writing code from engineering an application. Agents can produce code, he says, but may struggle to preserve architectural consistency as a project changes. He describes a compiler feature that ended up implemented five times after a month of agent-assisted work, illustrating the risk of brute-force iteration without clear structure.

He also worries that large agent-generated changes can make conventional review ineffective. His proposed response is not to abandon review, but to make changes easier to understand: keep features smaller where possible, preserve the reasoning behind changes, and maintain collaboration through meaningful review conversations.

He suggests deeper validation techniques, including:

  • Static analysis to check how much of the original scaffold remains intact.
  • Examining commits individually to understand how each moved the implementation forward.
  • Mutation testing, which he notes can be computationally expensive.
  • Better ways to visualize both the architecture and the path taken to reach the final code.

Learning and collaboration

The speakers discuss a shift toward developers working with agents instead of colleagues. Carlos sees declining pull-request discussion and team coordination as a risk: software can be demonstrated quickly in isolation, while product decisions, user needs, and the work required to finish and maintain a product receive less attention.

He recommends creating more opportunities for people to share work, ask questions, review one another’s projects, and learn together. Agents provide quick answers, but may tell users what they want to hear; relying on them too heavily can reduce learning and reflection. Carlos argues that developers who have learned engineering fundamentals will be better equipped to use agents than those who rely on agents without developing that foundation.

Practical learning approach

For a new language or unfamiliar kind of project, Carlos recommends:

  1. Examine existing open-source projects.
  2. Ask an agent to explain their strong and weak patterns and teach the fundamentals.
  3. Compare the new language with one you already know. For example, ask what changes are needed to write idiomatic Go after learning C#.
  4. Sketch a small scaffold or proof of concept and ask the agent to critique it.
  5. Take time to absorb what you have learned before committing to a larger implementation.

Views on future programming languages

Carlos argues for more deterministic programming, particularly as software moves further into robotics, satellites, GPUs, and other constrained or safety-sensitive contexts. He advocates eliminating heap allocation, pointers, and dynamic memory in favor of bounded execution and data laid out predictably in memory. His example is a satellite with a fixed amount of memory, where developers should be able to reason confidently about resource use.

He imagines a three-stage programming model:

  1. A human-facing language combining natural language and structured elements.
  2. An intermediate, visual or audio representation that lets an agent explain the intended behavior and a person refine it.
  3. A deterministic machine representation.

In his view, the resulting runtime could be consistent even if the human-facing layers were customizable. He also notes that Rust offers constrained ways to write deterministic programs, but describes it as difficult to change once code is working. He sees its borrow checker as a way to manage heap data that might be unnecessary in a heap-free design.

Broader AI outlook

Carlos distinguishes between promising AI breakthroughs—such as work in medicine, materials science, and robotics—and language models, which he finds useful but potentially wasteful and expensive. He also raises concerns about concentrated power, privacy, and whether AI will genuinely distribute opportunity.

Another concern is that if organizations stop training junior engineers and stop reviewing work together, the industry could become dependent on tools without maintaining the skills needed to build software.

Guides and actionable recommendations

  • Scaffold project structure and boundaries before delegating implementation.
  • Clarify requirements and architecture through a discussion-only agent before it changes files.
  • Use open-source code and agent-guided explanations to learn unfamiliar technologies.
  • Check work early in a separate worktree; discard code that does not match expectations or cannot be understood.
  • Try parallel implementations in separate worktrees, then compare and selectively merge them.
  • Preserve project knowledge through progressive disclosure rather than placing all context in one prompt.
  • Keep human review, collaboration, testing, and product thinking central to agent-assisted development.

Main speakers and sources

  • Carlos Kelkboom — Lead architect and guest; explains his coding-agent workflow, scaffolding approach, harness design, and views on programming languages.
  • Interviewer/host — Beyond Coding; asks about agent workflows, learning, collaboration, review, and the future of software engineering. The host’s name is not stated in the subtitles.
  • SlopCodeBench — A benchmark mentioned by the host while discussing agents’ difficulty with iterative changes. The host describes a prior result of roughly 15% for a model/version discussed in that context.

Rate this summary

Your feedback will help improve summaries.

Improve this summary

Reprocess with a stronger model when the summary feels incomplete or inaccurate.

Pro

Translate summary in another language

Pro

Ask questions to this video

Chat for follow-up questions, clarifications, and source-backed answers.

Coming soon

Share this summary

Original video