Working with Coding Agents

Problem-first prompting, architecture, parallel agents, cross-model review, and agent-ready systems

Lex Fridman interviews David Heinemeier Hansson about moving from handwritten code to agent-driven development. DHH reports that agents wrote all new functionality in Omarchy Quattro, while a Basecamp experiment showed that individually plausible generated changes can collectively damage a mature architecture. He recommends describing problems rather than prescribing implementations, preserving system shape, and keeping human judgment on product direction and merges. His speedups, costs, model rankings, and labor forecasts are practitioner reports, not controlled comparisons.

Roelant Dieben demonstrates an end-to-end GitHub Spec Kit workflow

Roelant Dieben demonstrates GitHub Spec Kit with GitHub Copilot: store non-negotiable rules in a constitution, capture intent in a specification, move technical choices into a plan, generate ordered tasks, then implement an HTTP MCP server. The demo relies on prepared branches for most stages and shows one MCP Inspector result; it offers no prompt-first baseline, test output, or comparative quality, time, or cost evidence.

Kieran Klaassen on preserving judgment so each agent-assisted delivery improves the next

Kieran Klaassen presents compound engineering: keep human judgment at brainstorming and polish, automate the repeatable middle, and store corrections and rationale so future work starts with more context. He demonstrates the loop on Cora, where he is the primary engineer with design and database support. Claims that one engineer beats teams and that implementation is ‘mostly solved’ are practitioner judgments; the talk offers no comparative delivery, quality, or token-use measurements.

Seven videos on grilling, prototyping, planning, review, and software quality

A reviewed seven-video route through Matt Pocock’s agent-skills and engineering-workflow uploads from May 25 to August 19, 2026. Six tutorials cover Grill Me interviews, anti-slop review, repository-aware implementation, throwaway prototypes, Wayfinder decision maps, agent-facing writing, deterministic setup, and collaborator questionnaires. In a conversation hosted by Pocock, Uncle Bob Martin argues for deterministic quality gates, specialized agents, and modular architecture. The demonstrations and productivity claims are practitioner evidence, not controlled comparisons.

Theo Browne on auditing, testing, and adapting agent skills instead of blindly installing them

After a week using skills from Matt Pocock and Lauren Tan’s pstack, Theo Browne shows how he audits skill collections against his own agent history, treats descriptions as routing triggers, tests text-only skills before installing them, and keeps only the workflows that fit. Examples cover clearer agent writing, design interviews, blast-radius checks, and decision trails. The results are personal demonstrations, not controlled evaluations.

Why more terminals are not more leverage, when asynchronous work helps, and which fears need a different response

In this Italian-language follow-up to his first FOMO video, Salvatore Sanfilippo argues that dozens of interactive coding-agent sessions dilute the human attention still needed for product direction and careful steering. He recommends focusing on a few related projects and reserving parallelism for long-horizon investigations. The recommendations and economic forecasts are practitioner judgments, not measured comparisons.

What to stop chasing and what to practice: domain judgment, model intuition, clear briefs, and simple orchestration

Salvatore Sanfilippo argues that coding-agent FOMO targets the wrong skills: natural-language interaction is quick to learn, while durable leverage comes from domain and software knowledge, model intuition, and clear communication. He recommends simple orchestration, working implementations as references, fast written briefs, and models as tutors. YouTube offers an English dubbed track beside the Italian original. The project outcome and model preferences are first-person reports.

Five curated interviews on software factories, agent orchestration, review, and harness design

A manually reviewed selection from the David Ondrej Podcast featuring Dexter Horthy, Thorsten Ball, Matt Pocock, Kun, and Magnus Müller. The conversations examine how agentic engineering shifts attention from code generation toward product judgment, architecture, context, orchestration, verification, and small adaptable harnesses.

A question-driven editorial route through selected talks in the rolling Coding Agents playlist published by the AI Engineer channel—not complete event coverage. The speakers remain the sources for their individual claims.

Thorsten Ball on prompts as information routing, screenshots, diagnostics, and agent-friendly codebases

In this Laracon US 2026 talk, Thorsten Ball explains prompting as an information-design problem: show coding agents where authoritative context lives, externalize hidden constraints, use screenshots and diagnostic reports as compact evidence, and move recurring instructions into the codebase so shorter prompts can still work.

Jason Liu on persistent project threads, recurring wake-ups, goal verification, and coordinated workstreams

Jason Liu presents a personal operating model for long-running agent work: named project threads, reviewable context, reusable skills, scheduled wake-ups, observable goal checks, and monitor threads that coordinate downstream work. He also discusses the limits of broad computer access, live-connector evaluation, token-intensive workflows, and cross-project memory.

Thariq Shihipar on capability overhang, unknowns, and ambitious agent workflows

Thariq Shihipar presents a field guide to working with Fable: expose a model's uneven capabilities through the right tools, identify unknowns before long agent runs, use blind-spot passes, prototypes, interviews, references, and implementation notes, and judge the work by the value it creates rather than the code it generates.

How to package repeatable agent tasks, load the right context, and test whether a skill helps

WorkOS developer experience engineers Nick Nisi and Zack Proser show how to package instructions, references, and scripts for a repeatable task in an agent skill. The description helps the agent decide when to load the skill, while optional files keep unrelated context out. Running the same task with and without the skill shows whether it improves the result. Team ownership and versioning remain unsettled, and the evaluation figures are approximate.

Lucas Meijer on Pi, context management, and evaluating agent work

Lucas Meijer shares habits for agent-assisted engineering: ask agents for HTML reports, make repositories easier to navigate, define evaluation criteria before a run, and request videos, screenshots, and slide decks that speed up review. The talk becomes a hands-on Pi demo covering tree-shaped context management, discarding unhelpful side quests, custom slash-command extensions, virtual-terminal visibility, and self-modifying software.

The rebranded Build Crew live series from the Amp team: live coding sessions, Prompt Duel at Dawn challenges, and Amp Credits prizes, continuing the community format around agent practices and real-time development.

A live series from the Amp team on agent practices and prompting: structured prompts, chain-of-thought prompting, the Oracle sub-agent for hard reasoning, external memory with short threads, and practical tips from real development scenarios and the Build Crew community.

Mario Zechner on disk-backed agent state, queryable context, compaction recovery, and review checkpoints

Mario Zechner demonstrates a control-heavy Claude Code workflow for established codebases: reviewed project docs, pre-compaction task summaries, jq-queried symbol indexes, persisted porting plans, compilation, and human checkpoints. His report that this cut a 68-file Spine runtime port from about two weeks to one day is an anecdote without logs or a baseline. The July 2025 Claude Code internals and pricing are historical, and his permission-bypass flag is not a security recommendation.

Beyang Liu at AI Engineer Conference

Beyang Liu traces AI coding tools from autocomplete to autonomous agents and defends contested design choices: autonomous edits, minimal UI, and model coupling. He covers Amp’s implementation, power-user practices such as detailed prompts, feedback loops, and sub-agents, and anti-patterns such as micromanaging and underprompting.