Working with Coding Agents

Useful — Adds a concrete account of a spec-centered workflow that failed for Pocock and browser access improving agent feedback, alongside shared domain language; outcomes are practitioner-reported, not comparative evidence.

Clear communication, maintainable code, and browser feedback for agents

Matt Pocock discusses design interviews, shared domain language, and improving the code and feedback available to agents. His video-editor case contrasts a spec-centered workflow that failed for him with renewed attention to maintainability and browser access. Includes primary-source learning and gradual delegation. Practitioner experience, not controlled comparisons; based on a recovered English transcript with unverified caption kind.

Useful — Demonstrates asynchronous work and end-to-end review evidence across delivery, based on Amp-team experience rather than controlled outcomes.

Asynchronous work, end-to-end evidence, and agents across the delivery lifecycle

Thorsten Ball demonstrates his Amp workflow: batch alternatives instead of waiting on agents, request end-to-end evidence before reviewing critical code, make development and production tools discoverable, and evaluate repository instructions in fresh environments. Includes rollout monitoring and a feature-flagged memory-warning case study. Amp-team experience and product demonstrations, not controlled productivity or safety findings.

Useful — Adds practical steering and progress-update advice while distinguishing reduced idle time from sustained creative involvement.

Salvatore Sanfilippo on agent latency, progress updates, and staying involved in design

Salvatore Sanfilippo describes retaining creative involvement through detailed product decisions, asking agents to announce significant steps, and using observed display behavior to steer changes. He distinguishes reducing idle time with parallel projects from preserving flow, and cautions against making automation more stressful. Personal experience and advice, not measured productivity findings; summarized in English from Italian auto-generated captions.

Useful — Connects design investigation, small prototypes, iterative steering, and screenshot checks through a practitioner CAD workflow.

Salvatore Sanfilippo on design investigation, iterative steering, and visual checks

Salvatore Sanfilippo explains his AI-assisted CAD workflow: investigate representation and algorithms, build a small prototype, steer interaction and performance, and give the agent screenshot-based checks. He argues for tools usable by both people and agents. Based on Italian auto-generated captions, summarized in English; development time and project outcomes are personal reports, while predictions about AI and design remain forecasts.

Context — Adds a validation failure anecdote and permission trade-offs within a broader weekly product roundup, not a durable setup guide.

Selected agent-workflow segments: Pi Radius, remote sessions, permissions, and validation

Syntax discusses Pi Radius as a managed model gateway, remote agent sessions with Herder, and the trade-off between personal-agent access and prompt-injection risk. A concrete validation anecdote shows an agent accepting malformed metadata instead of rejecting it. This summary selects coding-agent material from a broader weekly roundup; product descriptions and workflow outcomes are host-reported, based on English auto-generated captions.

Useful — Offers selected orchestration and verification discussions, with some overlap across collections.

Six curated interviews on software factories, agent environments, review, and harness design

A manually reviewed selection from the David Ondrej Podcast featuring Armin Ronacher, 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, working environments, context, orchestration, verification, and small adaptable harnesses. Practitioner observations and forecasts are not controlled findings.

Essential — Shows how typed specifications, call-path investigation, and small local reviews support production changes.

Code-shaped specs, deliberate context selection, and local review

Dillon Mulroy explains how he steers coding agents with TypeScript types, call paths, planned tests, Pi conversation branches, and local review of small stacked changes. He also discusses lost flow, human accountability, overlapping team roles, and the cost of autonomous loops. A practitioner interview, not an independently measured productivity study or a verification of provider policies.

Useful — Connects cloud-agent execution with staged migrations, scoped credentials, and customizable internal apps; the CI and code-review arguments remain first-party opinions without comparative reliability data.

Quinn Slack discusses cloud sandboxes for parallel agent work, staged production migrations with log monitoring, short-lived read-only credentials, and agent-customizable internal apps. Includes a debate over whether agent-run tests can replace CI and Amp's no-mandatory-review policy. First-party experience and forecasts, not comparative security or reliability evidence.

Useful — Explains isolated work and serialized shipping; its root-access defaults are not a general recommendation.

David Ondrej on reusable skills, human-owned decisions, parallel agents, and bounded review

David Ondrej walks through his multi-agent setup: persistent VPS sessions, reusable planning and review skills, worktree isolation, serialized shipping, architecture decision records, and read-only production analysis. A Hostinger-sponsored practitioner demo, not a productivity benchmark or security recipe; command-pattern hooks do not establish safe unrestricted execution, and the root-access and credential-discovery example should not be copied as a default.

Useful — Explores invariants and risk-based automation, not a blanket recommendation to stop reviewing code.

Kody, reusable automation, system-level review, and human product ownership

Kent C. Dodds and Joel Hooks discuss turning agent-driven processes into durable software, composing reusable primitives, recording invariants and architecture decisions, and keeping product choices and accountability human. Dodds describes Kody's risk-based auto-merge workflow and domain-checked secret substitution. This is a practitioner account from an early-access product, not proof that code review is unnecessary or that agents are immune to prompt injection.

Useful — Shows narrow migration and review evidence in a legacy-codebase demonstration that remains unfinished.

Cursor workshop on coverage audits, scoped migration plans, Jira handoffs, and cloud-agent review

Cursor's field-engineering workshop uses a WordPress PHP-to-React migration to demonstrate auditing test gaps, narrowing a plan to one screen, creating phased Jira tickets, and delegating implementation to cloud agents with separate PRs and review evidence. It also sketches maintenance automations. The live migration does not finish during the session; earlier runs illustrate testing and multi-PR review, not proof of regression-free migration.

Context — Repeats brief-writing advice in secondary commentary; the summary challenges an unsupported model-specific verification claim.

Ben AI on complete task briefs, clarification interviews, intent, and exit criteria

Ben AI presents seven prompting rules: specify the whole job, clarify unknowns, explain intent, define completion, give reasons for guardrails, avoid redundant double-check prompts, and set a reusable output style. A creator's interpretation of Anthropic guidance with personal examples, not a comparative evaluation; the advice about verification prompts should not replace task-specific tests or required review.

Useful — Contrasts agent difficulties in mature architectures with work on new projects.

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.

Useful — Explains focused revision loops, reusable TDD skills, and human-readable behavior checks as practitioner techniques rather than benchmarked improvements.

Lada Kesseler describes refining agent output through focused write-read-revise loops, teaching TDD through reusable skills, and separating agent-facing tests from human-readable behavior checks. A practitioner interview covering review, exploratory prototypes, and her reservations about software factories; improvements are speaker-reported, not benchmark results.

Useful — Describes concurrent task prioritization and video approval before merging; outcomes are self-reported and the speaker discloses vendor credits.

Ryan Carson describes prioritizing concurrent Devin threads, using Watchdog to triage customer-account problems, and requiring video approval before his land PR playbook merges. He and the host discuss verification, design handoffs, and why customer learning matters more than code volume. Based on English auto-generated captions; workflow outcomes are speaker-reported, not independently verified. Carson discloses receiving monthly Devin credits from Cognition.

Context — Illustrates specification-driven work in a prepared demo, without a comparative test of its superiority.

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.

Useful — Explains how preserving corrections and their rationale can improve later engineering work.

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.

Essential — Connects repository-aware skills with deliberate planning and engineering workflows.

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.

Useful — Demonstrates auditing and adapting borrowed skills to the work a repository actually needs.

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.

Useful — Examines attention limits and when selective parallel work is worth its coordination cost.

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.

Context — Collects practical demonstrations and practitioner accounts; tool capabilities and workflow outcomes are not independently evaluated.

Six selected videos on collaboration, review, remote execution, memory, and MCP

An editorial selection from Syntax's channel uploads, combining the existing Zed/Delta interview with five videos on code review, remote coding agents, long-term memory, and MCP. The summaries distinguish demonstrations, practitioner reports, proposals, and product claims from independently measured outcomes. This is not an official Syntax course or a summary of the full uploads playlist.

Useful — Shows why domain knowledge and clear briefs matter more than chasing every new tool.

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.

Useful — Organizes engineering talks around practical questions; some also appear as standalone resources.

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.

Essential — Shows concrete investigation and context-routing patterns rather than generic prompt formulas.

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.

Useful — Explains persistent goals and stopping conditions for keeping agent work bounded.

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.

Useful — Explains how to discover unknowns and bound ambitious work before delegating it.

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.

Essential — Explains skill triggers and progressive loading, with evaluation that compares work with and without a skill.

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.

Useful — Adds concrete review-artifact and context-tree practices beyond an introduction to Pi.

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.

Context — Records historical experiments and live-demo failures rather than a consistent starting workflow.

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.

Context — Mixes news and live experiments; selected practical episodes offer more focused value than the whole series.

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.

Useful — Shows how failed tasks become personal evaluations and product principles support critique rather than automatic approval.

Personal evals, context engineering, and product-principle review loops

Tobi Lütke explains how he retains failed tasks as model evaluations, supplies enough context to make work plausibly solvable, and codifies non-platitudinous product principles. Shopify uses AI critiques to find discussion points and refine those principles rather than as an automated approval gate. The practices and outcomes are Lütke's account.

Useful — Offers documentation, indexing, and checkpoint practices, with historical CLI and pricing details.

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.

Useful — Explains clear briefs and feedback loops, while its product-specific details are historical.

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.