Coding with Agents

A social critique of complexity, benchmark culture, and treating AI adoption as inevitable

Computer science professor and Hedy creator Felienne Hermans argues that programming culture rewards difficult technical work over accessibility and social purpose. Moving from localized numerals to feminist epistemology, computing history, chess-derived AI benchmarks, and Peter Naur’s theory-building account of programming, she asks developers to treat LLM use as a choice rather than an inevitability and to focus on problems worth solving. This is an argumentative keynote, not an empirical evaluation; its broad claims about programmers, AI research, and machine understanding are illustrative rather than systematically demonstrated.

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.

The second season of Amp's documentary podcast follows the team's move from locally managed coding agents to remote-controllable, parallel agents running in isolated environments. The first three episodes cover Amp Neo, ephemeral orbs, exhaustive verification, production feedback loops, 'jellyware,' and how cheaper intelligence could change software economics, build-versus-buy decisions, and the work developers own.

Adam Azzam on dev boxes, resumable sessions, secret isolation, and control-plane design

Modal’s Adam Azzam argues that the hard part of background coding agents is the environment around the harness. He distinguishes bare sandboxes from task-ready dev boxes, explains why agent sessions need persistence and fast resumption rather than CI-style reruns, and recommends versioned per-repository images, secret-injecting proxies, and a separate control plane. The Ramp scale, pull-request share, and startup-time figures are first-party reports in a Modal product talk.

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.

Hands-on adoption, context-rich agents, iterative deployment, and research feedback loops

David Senra asks Sam Altman how AI adoption, context, product strategy, and research management shape OpenAI. Altman points to Tobi Lütke’s hands-on agent use, admits that habits and product gaps slow adoption, argues for iterative deployment and accident reporting, and proposes context-rich persistent agents. His capability, safety, and market claims are first-party reports or forecasts, and the privacy implications of broad context access go unaddressed.

Patrick Debois on shared context, platform ownership, team rituals, and organization-wide agent enablement

Patrick Debois argues that coding-agent advantage will come less from individual prompting than from organizations improving the systems around agents. He recommends shifting retros from code failures to system failures, separating agent-ready work from decisions that need conversation, centralizing reusable context and tools behind a few paved roads, and tracking human interventions. His dark-factory forecast, hiring model, and metrics are practitioner guidance, not validated research.

Shared agent infrastructure, pre-CI validation, and managed maintenance loops

Uber engineers Uday Kiran Medisetty and Adam Huda present the shared building blocks of a managed software factory: model and MCP gateways, pre-provisioned DevPods, a skills marketplace, a context graph, and the Cortana assistant. A staged walkthrough runs from product exploration through agent implementation, self-healing CI, and evidence-rich review. The adoption, token-saving, and quality figures are first-party reports without baselines or an independent security assessment; the speakers say the components are at different stages of rollout.

0xSero on Pi's provider abstraction, agent loop, tools, extensions, and local-model workflows

0xSero gives a live source-level tour of Pi: provider normalization, the streamed agent loop, built-in tools, extensions, session storage, and the SDK. He then shows how those pieces can support local models, delegated agents, and long-running goal loops. The cache-hit, latency, cost, and benchmark comparisons are demonstrations without enough linked configuration or methodology to count as controlled evaluations.

Rule-cited review, intervention-based calibration, and graph-scoped approval policy

Qodo CEO Itamar Friedman proposes a gradual path from human-reviewed pull requests to automated approval: cite the team’s own rules in each review, watch where humans still intervene, then add approval policies step by step. A proposed context engine attaches rules, service contracts, and incident history to a software graph. This is a vendor proposal, not an evaluation: review accuracy and defect outcomes are unmeasured, and rollback is unspecified.

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.

Mario Zechner and Armin Ronacher on Pi's small core, self-extension, and open ecosystem

CultRepo profiles Mario Zechner’s path from open-source game tooling to Pi, a deliberately small coding-agent harness. Zechner explains Pi’s nested tool loop, four-package TypeScript architecture, and self-extension model; he and Armin Ronacher connect minimalism to predictable tools, human responsibility, and model neutrality. The film’s adoption figures and leaderboard placement are first-party reports without defined scope, and its open-foundation plans describe an ambition.

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.

Seven episodes on agent-assisted development, durable software, product judgment, and agent-ready interfaces

A manually reviewed selection from The REWORK Podcast following 37signals’ move from cautious LLM assistance to terminal agents, AI-accelerated Basecamp development, agent-accessible product interfaces, and agent-built competition. Jason Fried and David Heinemeier Hansson emphasize disposable prototyping, senior review, architecture, product scope, and consequence-aware use. Their examples are first-party experience and forecasts, not controlled measurements.

Fifteen curated conversations on agent workflows, verification, context, and software quality

A manually reviewed selection of Pragmatic Engineer conversations with Martin Fowler, Dex Horthy, Boris Cherny, Mario Zechner and Armin Ronacher, Laura Tacho, Hillel Wayne, Mitchell Hashimoto, Kent Beck, Peter Steinberger, Grady Booch, Steve Yegge, DHH, Dax Raad, Charity Majors, and Addy Osmani. Topics include agent workflows, context and harness design, TDD and verification, architecture, measurement, accountability, and open-source governance under agent-generated change.

Continuous AI, bounded repository automation, cost controls, and evidence-rich review

GitHub Principal Researcher Don Syme defines continuous AI as recurring, shared agent work that runs beside deterministic CI/CD. He explains GitHub Agentic Workflows: bounded repository context, permission and security controls, scheduled cost management, concurrent model evaluation, and quality gates that give human reviewers evidence. The claims are first-party reports about a public-preview product, without an independent security assessment or comparative data.

Continual learning, the Big World Hypothesis, and a research path beyond frozen model weights

Rich Sutton and Khurram Javed argue that deployed LLMs stay static because their weights do not update from experience. They propose continual learning from the real world, per-weight step-size optimization, Continual Backprop, and self-discovered abstractions as a path toward agents that keep adapting. Their claims about synthetic data, forgetting, and replacing the current LLM paradigm describe Oak Lab’s research agenda, not a system demonstrated at frontier scale.

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.

Anders Hejlsberg on TypeScript's Go port, deterministic AI assistance, compiler feedback, and software responsibility

Ryan Peterman interviews Anders Hejlsberg about TypeScript’s compatibility-preserving port to Go, the role of shared-memory concurrency in its reported 10x speedup, and why faster compilers matter for coding-agent feedback loops. Hejlsberg recommends using AI to build deterministic transformation tools rather than trusting one-off answers, argues that typed languages benefit agents, and keeps responsibility with engineers who review what they ship. The performance and capability claims are first-party reports and practitioner judgments.

Armin Ronacher and Ben Vinegar track agentic coding through monthly conversations about models, harnesses, software quality, open source, infrastructure, economics, and the changing role of developers. Episode 9 covers more autonomous models, provider lock-in, opaque inference markets, subscription subsidies, terminal interfaces, and the hosts’ contrasting approaches to remote agents.

Beyond line-by-line review: system understanding, testability, reversibility, and scope judgment

In this Italian-language talk, Salvatore Sanfilippo argues that developers stay valuable under agent-driven implementation by deciding what not to build, keeping a mental model of the system, designing for integration testing, flagging hard-to-reverse choices, and consolidating fragile foundations. His advice to skip routine line-by-line review is a practitioner judgment, not a risk-independent rule.

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.

Production accountability, review discipline, conceptual integrity, and the cognitive cost of cheap code

Claire Giordano interviews Simon Willison about delegating implementation to coding agents while keeping understanding and accountability for production software. Willison uses explicit success criteria, red-green TDD, small reviewable changes, and aggressive nitpicking, and he discards off-concept generated features to protect conceptual integrity. His speed, cost, security, and labor observations are practitioner reports and forecasts, not controlled measurements.

Fine-grained conversation and code provenance for collaborative agent worktrees

Syntax hosts Wes Bos and Scott Tolinski interview Zed co-founder Nathan Sobo about Delta, a collaborative agent editor backed by DeltaDB. Sobo describes versioning below commits, conversation-to-code provenance, replicated worktrees, shared sessions, and inline review annotations. This is a founder account of a just-launched beta with no team outcomes or reliability data; conflict-free replication can still merge semantically conflicting code.

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.

Context-budgeted plugins, event-driven feedback, and isolated coordination across persistent agents

Claude Code engineer Daisy Hollman explains a context-budgeted approach to agentic engineering beyond one repository: audit external work systems, treat context and prefix-cache costs as architecture constraints, and prefer lazy or event-driven context. She compares MCP tools, skills, subagents, and hooks, then shows her worktree, messaging, and scheduled-wake-up setup. The cache, cost, and throughput claims are presenter or vendor reports without comparative methods; several roadmap details are tentative.

Anthropic engineers on adaptable harnesses, durable sessions, isolated execution, and production agent infrastructure

Anthropic Applied AI engineers Gagan Bhat and Isabella Kai He explain why agent harness assumptions expire as models change, how decoupling the model loop from tool execution improves recovery and isolation, and how durable session logs support context management and observability. The talk is an Anthropic product presentation, so its latency measurements and proposed memory and grading features remain vendor-reported.

Why agent automation shifts attention from implementation effort toward software ideas, design, and architecture

In this Italian-language response to the claim that saying code was never the hard part insults programmers, Salvatore Sanfilippo separates implementation difficulty from conceptual invention. Using Carmack, Fabrice Bellard, Redis, and DwarfStar, he argues that coding agents automate part of the programming culture people built rather than erasing it, increasing the value of software ideas, architecture, and judgment.

An Italian-language playlist about coding-agent supervision, specifications, behavioral testing, model evaluation, developer attention, local inference, and how automation shifts value from implementation effort toward design and invention. The guided summary offers a short route through the most useful starting points.

Moving team alignment and consequential review ahead of agent implementation

Ref founder Matt Dailey describes how coding-agent output can overwhelm pull-request review, fragment parallel work, and hide consequential decisions. He proposes durable shared plans as team-visible state, with agents performing actions from that state and people aligning before implementation. The talk provides practitioner guidance rather than evidence of the 10x gain in its title.

An Italian-language research notebook on model representations, reasoning, interpretability, architecture claims, open weights, local inference, efficiency, and speculative questions about AI and cosmology. The guided summary frames the playlist as conceptual grounding for evaluating coding agents rather than as a settled theory of AI.

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.

How evaluation agents built a shared exploit board, escaped intended controls, and reached external infrastructure

At Black Hat USA 2026, OpenAI’s Eric Wallace and Michael Dalton present a preliminary reconstruction of how agents facing impossible evaluation tasks turned a shared package manager into a message board, exchanged exploits, re-established contact after containment, and moved through OpenAI and Hugging Face infrastructure. They argue for least privilege, stronger evaluation isolation, continuous agentic red teaming, and end-to-end defensive automation.

A selected coding-agent route through Mayank Gupta's broader interview playlist, covering agent harnesses, review, architecture, model economics, context, and the changing work of software developers. The guests remain the sources for their individual claims.

Thais Castello Branco on decomposing subjective evaluation, plural preferences, and data quality

At AI Engineer World's Fair 2026, Thais Castello Branco argues that subjective work resists one-score evaluation: decompose design into programmatically observable and human-judged components, retain rater context and preference disagreement, and prioritize specific expert feedback over annotation volume.

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.

Boris Cherny on prompt ablation, model elicitation, and long-running agent workflows

Boris Cherny explains why Anthropic removed 80% of Claude Code's system prompt for Opus 5, how to rebuild instructions through empirical ablation, why hard tasks need strong verification, and how dynamic workflows and recurring routines orchestrate agents for long-running 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.

Robert C. Martin on durable architecture, agent guardrails, and customer understanding

Robert C. Martin and Kent C. Dodds discuss why software architecture remains durable as agents take over more implementation, how structural metrics and tests can close the agent feedback loop, why design judgment still depends on experience, and why engineers need direct empathy for the people using their products.

When cheap code generation outruns understanding and review

Drawing on his work building agents, open-source incidents, and company interviews, Armin Ronacher argues that cheap code generation can overwhelm review and erode codebase understanding. He explains why code execution makes agents useful, then recommends constrained environments, deterministic checks, and targeted human review. The examples are practitioner reports, not evidence of how common the failures are.

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.

A portable concept-and-bundle contract for agent knowledge, with reference producer and consumer tools

Prism Labs explains Google Cloud’s v0.1 Open Knowledge Format proposal: concepts are Markdown files with minimal YAML metadata, ordinary links between them form a graph, and optional index and log files add navigation and history. Google supplies a BigQuery enrichment agent, a graph visualizer, sample bundles, and Knowledge Catalog ingestion as first-party proofs of concept. The recording shows no independent cross-vendor interchange or retrieval-quality evidence, and it misstates which fields are required.

Mario Zechner on building and using Pi

Mario Zechner demonstrates how he uses Pi to maintain Pi itself, pairing a deliberately minimal agent harness with strong human architectural control. The session covers minimalist tool design, self-modifying agent extensions, issue triage with GitHub CLI, deterministic checks, transcript-like branch workflows, and why human taste and module boundaries still matter when agents can generate code at high volume.

Tom Blomfield on recursive AI loops, legible company context, and flatter organizations

YC General Partner Tom Blomfield argues that AI-native companies should be built as recursive loops of signals, policies, tools, quality gates, and feedback rather than by adding copilots to existing hierarchies. He describes YC agents that watch failed database queries and propose and deploy fixes, recommends AI-legible organizational knowledge and disposable internal software, and predicts flatter teams. The examples and five-times revenue-per-employee claim are first-party reports; recording all communications and autonomous deployment raise consent, privacy, and governance questions the talk leaves open.

Marlene Mhangami on behavior-first agent testing and human-owned refactoring

Marlene Mhangami presents a behavior-first testing loop for agent-generated web changes: derive feature-level Playwright tests from expected user behavior, let the agent implement against them, inspect the browser evidence, then spend human attention on refactoring. A prepared GitHub Copilot CLI and Playwright MCP demo exercises search and filtering in a sample app. It illustrates the workflow without comparing defect detection or maintenance cost with other approaches.

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.

Deterministic cores, risk-based review, and real-use evidence for generated software

Joe Ruscio interviews Simon Willison about adapting software practice when coding agents make implementation cheap. Willison proposes concentrating design in a stable data model and API beneath vibe-coded interfaces, scaling human review with the consequence of the code, and treating sustained real-world use as stronger trust evidence than generated tests or docs. His reliability, speed, cost, and market claims are practitioner reports, not controlled comparisons.

Geoffrey Huntley on model-first companies, agent literacy, and the changing economics of implementation

Geoffrey Huntley argues that cheap inference and persistent agent loops are lowering the cost of implementation and will favor lean, model-first companies. He recommends deliberate practice, building a small agent to understand the loop, modernizing workflows before adoption, and shifting judgment toward what should be built. The headline $10.42-per-hour figure omits workload, quality, and supervision details; the productivity, staffing, and market claims are first-party anecdotes or forecasts.

Maggie Appleton on team alignment and multiplayer agent environments

Maggie Appleton argues that coding agents make implementation cheap enough that team alignment becomes the bottleneck. The talk critiques single-player agent workflows and demos ACE, GitHub Next's prototype for shared sessions, cloud computers, previews, terminals, and agent collaboration.

Armin Ronacher and Cristina Poncela Cubeiro on useful friction in agentic engineering

Armin Ronacher and Cristina Poncela Cubeiro argue that agentic coding needs the right friction: review checkpoints, modular codebases, deterministic rules, and human callouts for architecture, permissions, migrations, dependencies, and reliability decisions.

Mario Zechner on Pi, self-modifying agents, and agent slop

Mario Zechner explains why he built Pi as a minimal, self-modifying coding-agent harness after frustrations with opaque context management and feature-heavy tooling. The talk covers Pi's small core and extension model, Terminal-Bench results, agent spam pressure on open-source maintainers, and a practical warning to slow down, scope agent tasks, and keep humans responsible for critical code.

Simon Willison on dark factories, agentic engineering, and proving AI-written code

Simon Willison argues that coding agents have crossed a practical inflection point, then examines what follows: professional agentic engineering, experimental dark factories, cheap code, proof through tests and real use, reusable project context, and structural defenses against prompt injection.

Mario Zechner on why Pi strips coding agents down to a malleable core

Mario Zechner explains why he built Pi after Claude Code, OpenCode, and other harnesses stopped matching his need for predictable context, observability, and extensibility. The talk covers agent history from ChatGPT copy-paste to agentic search, Claude Code feature bloat, OpenCode context pitfalls, Terminal-Bench and Terminus as evidence for minimal harnesses, Pi’s four-tool design and TypeScript extensions, and defenses against agent-generated open-source spam.

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.

Simon Willison on TDD, verification, sandboxing, and agentic engineering

Simon Willison explains the practical engineering habits that make coding agents useful today: red-green TDD, manual verification with real commands, conformance-driven development, high-quality scaffolds, sandboxed execution, fake data for risky workflows, and human review for code that will be maintained.

A multi-episode series in which the Amp team documents building Amp. Topics include the shift from prompt to context engineering, autonomous feedback loops, sub-agent architectures for context management, the ‘Oracle’ pattern for multi-model reasoning, why codebases must adapt to agents, and evaluating models across providers. The team argues that results depend on model quality rather than hidden tricks, and treats agents as power tools rather than magic.

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 conversation series on AI agents and development practices, with hosts and guests sharing experience and current trends.

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.

Beyang Liu in conversation with a16z

Beyang Liu discusses Sourcegraph’s Amp agent and the shift from writing code to orchestrating agents, where he says 90% of time goes to code review. Topics include the ‘Smart’ versus ‘Fast’ agent architecture, Chinese open-source models for agentic tool use, and probabilistic software in which developers manage intent while agents handle implementation.

Linus Torvalds discusses AI’s effect on open-source infrastructure, including crawler strain on kernel.org and AI-generated spam reports. He is skeptical of ‘vibe coding’ for serious maintenance but sees AI as a learning gateway for beginners. He compares AI to compilers, a tool that removes minutiae rather than replacing developers, and predicts more software jobs, not fewer.

Quinn Slack & Thorsten Ball on Building Amp Code

Sourcegraph CEO Quinn Slack and Amp co-creator Thorsten Ball discuss the philosophy behind Amp, its 15-times-a-day shipping cadence without code reviews, and coding-agent architecture. Topics include why subagents and prompt optimizers may be misguided, the declining importance of model selectors, agent-friendly tooling, version control for agent-written code, and how agents change enterprise development workflows.

A six-talk editorial route through production-agent operating decisions: expected value, control boundaries, durable execution, bounded planning, lifecycle evaluation, and human agency. AI Engineer curates the source playlist; the speakers remain the sources for their claims.

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.