Yogthos has been using AI coding agents daily for months, and this essay distills what actually works. His framing: an agentic loop is like evolution — the model proposes code, tests catch the problems, feedback iterates — but it only converges if you set up the right structure around it.
What’s safe to delegate:
- Boilerplate: service endpoints from a sample response, UI screens from API docs — the tasks models have seen a million times
- Exploring an unfamiliar codebase: tracing call graphs and finding where things are wired
- Bridging language gaps: writing idiomatic code in a language you’re rusty in
- Researching prior work before you commit to an approach
When to take the wheel — the part most people get wrong:
- Architecture and design stay yours. Agents produce “correct-looking but structurally wrong” code — e.g., a string method routed through a generic dispatch table when a compile-time check would do
- Never give a blank canvas: lay out the file structure and components yourself, then let the model fill the gaps
- Plan first: have the model write a phased plan and draw a diagram of the flow, then review the diagram before any code
- The more scaffolding you provide, the less room the agent has to invent its own (wrong) structure
His infrastructure tricks: tests as a contract (the model can’t say it’s done if the tests fail), a separate critic role that reviews each diff, sqlite as project memory instead of markdown files that go stale, and treating the model as a leaf node inside deterministic control flow rather than trusting it end-to-end.
The honest bottom line: you are still the engineer. The LLM saves you from typing boilerplate and looking up syntax — it does not do your thinking, and it will confidently produce the wrong shape if you don’t know what the right shape is.