Recorded on 23 April 2026. The AI agent space moves every week, so treat these as my notes from that point in time.
Written notes from my talk above on how coding agents are actually put together.
When people talk about coding agents, they still focus way too much on the raw model and the prompt. In practice, two tools calling the exact same model can feel night-and-day different coz of everything wrapped around the model: the harness, how context is loaded, what tools it gets, permission boundaries, memory, and the control loop.
The new “what happens when you type google.com” question
In infra interviews, the classic question is: “What happens when you type google.com into a browser and press enter?”
For agent engineering, the equivalent question now is: “What happens when you type a prompt into a coding agent and hit enter?”
Walking through that end-to-end forces you to look at the actual stack:
- Which model gets picked for this step?
- What context (
CLAUDE.md,AGENTS.md,SKILL.md, repo map) gets loaded upfront? - What files and tools is the agent allowed to see?
- Does it generate a plan first or jump straight into edits?
- What commands does the harness auto-allow vs block for approval?
- How do tool outputs get truncated/compacted before going back into context?
- How does the loop know when to retry, keep going, or stop?
- What gets written to memory after the session finishes?
- Where does the human actually review the work?
Instead of user prompt -> model answer, the real pipeline looks like:
user intent
-> context loader
-> planning step
-> tool policy
-> filesystem / terminal / browser / APIs
-> execution loop
-> checkpoints
-> human review
-> memory update
-> next run
Split planning from execution
One pattern I use constantly now: don’t use the same model/mode for planning and coding.
For anything non-trivial, I’ll give the same high-context prompt to multiple strong frontier models, let them ask clarifying questions, and compare their plans. Then I combine the best parts into a markdown checklist (PLAN.md).
Once you have a concrete checklist, you can hand execution over to a faster/cheaper coding agent (or a loop) whose only job is to tick off the checklist items one by one and run tests. The executor shouldn’t be improvising architecture on the fly.
The “Ralph Wiggum” bash loop
At its core, an autonomous loop can be as dumb as:
while :; do cat PROMPT.md | claude; done
Looks stupid, right? Put your checklist on disk, tell the agent in PROMPT.md to pick up the next unchecked item, run tests, check the box, commit, and exit. And the while loop restarts it with a fresh context window for the next item until the checklist is done.
The bash loop is 1 line, and then all the real engineering shows up around it:
- How does the loop know when the whole checklist is actually done vs stuck?
- What state gets written to disk so the next iteration doesn’t repeat failed work?
- What commands is it allowed to run unattended?
Safety belongs in the harness, not the prompt
Telling an LLM in the system prompt “please be careful and do not delete production data” is not security.
If an agent is running autonomously, safety has to be enforced outside the model by the harness:
- read-only mounts or sandboxed containers
- network allowlists
- credential proxies (so raw tokens aren’t sitting in
env) - git worktrees / branch checkpoints
- hard approval gates before destructive commands
On side projects you can go full YOLO mode (--dangerously-skip-permissions) and burn tokens fast. On prod systems, lock down the harness.
Skills, MCPs, Hooks, and plain CLIs
We finally have better ways to package agent behavior than copy-pasting giant system prompts:
CLAUDE.md/AGENTS.md: repo-specific rules and build/test commands.SKILL.md: on-demand runbooks. Instead of stuffing 20 workflows into every prompt, the agent only loads theSKILL.mdfile when the task actually needs it.- MCP servers: useful when you need to wrap a remote SaaS API, but watch out for token bloat. Loading 40 MCP tool schemas into context eats tens of thousands of tokens before you even say hello.
- Plain CLIs & unix tools: tbh most of the time
grep,find,jq,git,curl, and a 20-line Python/bash script beat a fancy MCP server. Models already know unix primitives inside out. - Hooks: if a rule is deterministic (like “run
pnpm lintafter editing a file”), don’t beg the model in the prompt to remember it. Put it in a post-edit hook so the harness runs it automatically.
Even better: just-in-time software. If an agent has to do some repetitive parsing, formatting, or verification step 10 times, ask the agent to write a small CLI script + unit test for it first, and then have future runs call that script. Deterministic code > prompt instructions every single time.
Memory and “memory dreaming”
Most people still think “AI memory = vector DB + RAG”. For personal/coding agents (like Hermes or OpenClaw running on WhatsApp/Telegram/terminal), a structured folder of markdown files (an LLM wiki) works way better than opaque vector chunks.
The catch with persistent memory is that if you let the agent append whatever it wants after every chat, your memory files fill up with stale garbage within two weeks.
What works much better is a background compaction / “memory dreaming” job: a scheduled task reviews recent session logs, proposes clean updates to USER.md / SKILL.md / AGENTS.md (especially “don’t repeat this mistake” rules), and lets you review/merge the diff.
Multi-agent boards need dependency graphs
Tools like Paperclip, Mission Control, and Symphony are turning multi-agent runs into Kanban boards where you fan out 5-10 agents across tickets.
Just like Terraform, you can’t parallelize everything blindly. Independent slices can run in parallel, shared types/interfaces have to be serialized first, and someone (either you or a coordinator agent) has to own the merge boundary. Otherwise 10 parallel agents just generate 10x the merge conflicts and AI slop.
Final note
One thing my mentor brought up during the Q&A at the end of the talk: it’s super easy for experienced engineers to roll their eyes at every new AI tool and dismiss it as hype. And yeah, 80% of it is hype.
Still, you gotta actually try the tools hands-on for a weekend, see where they break, keep the 1 or 2 primitives that genuinely speed you up, and throw away the rest. (And shoutout to Seedhe Maut at the end of the video - #TBSM4L.)