Building software by prompting, with little reading of the code.
React was chosen because the speaker did not know the language, which enforced the rule of not touching the code directly and only using prompts. Additionally, frontier LLMs have extensive training data for React, making it exceptionally well-indexed and supported compared to more niche languages.
▶ 10:57
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Senior engineers with 12 to 15 years of experience struggle the most because their professional identity is deeply tied to traditional manual coding methods. Unlike juniors or very experienced veterans, they often reject agentic workflows out of hand.
▶ 1:19
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
He noticed that the latest AI models were outputting correct code chunks reliably without needing corrections. This realization led him down a rabbit hole of building endless side projects entirely through prompting.
▶ 1:28
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Relying 100% on vibe coding without knowing your codebase, variable names, or architecture causes development to eventually break down. Without a mental map of the code, you cannot give accurate hints or fix issues when agents fail. This leads developers into a frustrating cycle of failure.
▶ 0:25
When to prompt and when to code
ULMFiT introduces a three-stage architecture using a general-purpose corpus for pre-training before task-specific supervised fine-tuning. This approach heavily relies on robust regularization techniques and discriminative learning rates across different model layers. Jeremy Howard found that this transfer learning methodology vastly outperformed highly specialized models on classification tasks.
▶ 4:30
The Dangerous Illusion of AI Coding? - Jeremy Howard
After encountering an extremely buggy magazine viewer app, he offered to rewrite it and later extracted the PDF rendering component into a standalone product. He started selling it online after realizing other developers faced the same complex file format challenges.
▶ 10:06
The creator of OpenClaw: "I ship code I don't read"
Mainstream harnesses lack transparency and flexibility, with system prompts and tool definitions changing behind your back. They also offer zero observability, restricted model choices, and extremely shallow hooks that spawn inefficient processes.
▶ 1:55
Building pi in a World of Slop — Mario Zechner
Software 3.0 is characterized by large language models acting as programmable neural networks. Instead of traditional coding or tuning model weights, developers program the system using natural language prompts. This turns English into a functional programming language for the LLM.
▶ 3:19
Andrej Karpathy: Software Is Changing (Again)
After two weeks of pure vibe coding, the app hit a wall at 90% functionality while trying to integrate features like dark themes and Firebase services. The LLM ended up creating too many redirections and abstraction layers, resulting in slow, unmaintainable spaghetti code.
▶ 12:08
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Anecdotal enterprise data shows a 10x performance difference across lines of code, commits, and business impact. This massive gap causes significant friction and panic during performance reviews for engineers who refuse to adopt agents.
▶ 3:05
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Software 1.0 relies on explicit rules written by humans, whereas Software 3.0 uses LLMs as interpreters. In the Software 3.0 paradigm, programming shifts to prompting and managing what is inside the context window.
▶ 2:35
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Non-technical people or beginners struggle with vibe coding because fixing broken agent outputs requires distilling years of engineering experience into a few lines. Without a background in software engineering and debugging, explaining how to fix a bad AI output is extremely difficult.
▶ 1:07
When to prompt and when to code
Language models operate by fitting complex curves across massive multidimensional training data, meaning they rely on interpolation rather than true reasoning. When a prompt pushes the model outside this known distribution, its representations collapse and it loses basic understanding. Thus, what appears to be creativity is merely compositional interpolation of existing human knowledge.
▶ 20:24
The Dangerous Illusion of AI Coding? - Jeremy Howard
Frustrated by a dating website's mobile limitations and lack of copy-paste, he downloaded Xcode and used regular expressions to parse the HTML directly. He put the app in the App Store for five dollars and made 10k in the first month.
▶ 6:05
The creator of OpenClaw: "I ship code I don't read"
Pruning tool outputs after a minimum token threshold effectively lobotomizes the model by removing crucial context. Furthermore, injecting LSP server errors on every single edit confuses the model instead of letting it finish work first.
▶ 3:46
Building pi in a World of Slop — Mario Zechner
LLM compute is currently expensive and centralized in the cloud, forcing developers to act as thin clients interacting over a network. This mirrors early computing where time-sharing was necessary because users lacked full utilization of the underlying hardware. Furthermore, direct text interactions with chat interfaces feel like accessing an operating system through a terminal.
▶ 11:05
Andrej Karpathy: Software Is Changing (Again)
To move toward a spec-driven approach, the speaker fed the existing React application into multiple CLI tools to generate detailed markdown specifications for each feature. Using several frontier models to review and refine these specs ensured they were clear enough to guide subsequent implementation in Angular.
▶ 16:32
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Hands-on experience indicates you need to spend about a year or roughly 2,000 hours working with AI before you fully trust it. Trust means reaching a point where you can accurately predict its capabilities, hallucinations, and limitations.
▶ 4:31
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Instead of executing a complex shell script designed for various platforms, the installation relies on a simple snippet of text copied into an agent. The agent uses its own intelligence to inspect the environment and execute the setup loop.
▶ 3:52
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
You should write code yourself when prompts become longer and more complicated than the actual fix. The ideal balance is using AI to write boilerplate code you want to avoid, while maintaining enough architectural understanding to halt the agent and redirect it when it goes off track.
▶ 1:29
When to prompt and when to code
Relying on AI coding tools creates a false illusion of control and productivity while leaving developers with code nobody truly understands. Studies show that vibe coding often decreases actual shipping productivity and introduces severe long-term maintenance risks. Software engineering requires rigorous design and understanding rather than blindly pulling a slot machine lever.
▶ 48:14
The Dangerous Illusion of AI Coding? - Jeremy Howard
Custom pricing allows vendors to assess a company's size and willingness to pay, ensuring the price reflects the differing value a freelancer versus a Fortune 500 company gets. If the price is too low, large enterprises view it as fishy, while a fixed low price excludes big buyers.
▶ 22:29
The creator of OpenClaw: "I ship code I don't read"
Terminal Bench provides only a simple tool to send keystrokes to a tmux session and read the output. Despite lacking file tools or sub-agents, this minimalist approach outperforms complex native harnesses.
▶ 4:57
Building pi in a World of Slop — Mario Zechner
LLMs have encyclopedic memory but suffer from rough edges like hallucinations and jagged intelligence where they fail simple logic tasks. They also lack native long-term memory consolidation, suffering from an equivalent of anterograde amnesia where their context windows are wiped. Additionally, they are gullible and vulnerable to prompt injection risks.
▶ 16:19
Andrej Karpathy: Software Is Changing (Again)
AI assistants frequently break older features accidentally when implementing new changes across an application. Maintaining a robust suite of unit and integration tests acts as a vital guardrail to catch these regressions early since visual inspection alone is insufficient.
▶ 21:19
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Treating an LLM like a human teammate creates a false sense of security, often leading to disasters like accidentally locking out production systems or deleting databases. Because agents can unpredictably make catastrophic changes when given the hot hand, developers must never drop their guard.
▶ 7:47
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Frontier labs train models using reinforcement learning environments driven by verification rewards. This training causes model capabilities to peak sharply in verifiable domains like code and math while lagging elsewhere.
▶ 10:13
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Typing code was never the primary bottleneck in software engineering, echoing Fred Brooks's observation that writing code is only a fraction of the work. Delegating design to LLMs often results in superficial solutions modeled on surface-level similarities rather than novel engineering.
▶ 27:50
The Dangerous Illusion of AI Coding? - Jeremy Howard
When a customer with a massive 50,000-page document caused their data model to explode due to thousands of links, they had to completely redesign the internals. They implemented lazy loading so the application could handle massive files without breaking existing APIs for users.
▶ 24:39
The creator of OpenClaw: "I ship code I don't read"
Pie ships documentation and code examples of extensions alongside its core tools. By instructing the model with these examples, the agent can write its own extensions to modify its behavior.
▶ 6:48
Building pi in a World of Slop — Mario Zechner
Applications like Cursor combine a traditional manual interface with deep LLM integration. They handle context management, orchestrate multiple LLM calls under the hood, and feature application-specific GUIs to help humans audit work. They also incorporate an autonomy slider so users can adjust how much control to hand over to the agent.
▶ 19:16
Andrej Karpathy: Software Is Changing (Again)
Rapid prototyping gives quick satisfaction, but it can lead to dangerous configuration mistakes like accidentally deploying staging tasks to production. Without knowledgeable review, non-technical users or juniors might introduce security issues or bypass routing guards. Therefore, experienced developers are still required to catch hidden side effects and infrastructural risks.
▶ 31:30
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Most engineers have not adopted tools like Claude Code because they find them too difficult to use and read. Developers must sift through massive waterfalls of code and diffs, which requires high reading endurance and a new skillset.
▶ 12:25
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Vibe coding raises the floor for everyone by letting non-engineers build software quickly. In contrast, agentic engineering treats AI use as a disciplined engineering practice that maintains professional quality and security bars.
▶ 15:57
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Blindly relying on AI tools creates understanding debt and erodes organizational knowledge because developers miss out on the friction required for true learning. Without desirable difficulty and active struggle, developers risk cognitive atrophy and personal obsolescence.
▶ 36:31
The Dangerous Illusion of AI Coding? - Jeremy Howard
Writing forces developers to deeply understand the problems they solved and serves as valuable internal documentation. It also acts as a personal lookbook and helps attract interesting candidates who want to tackle hard problems.
▶ 26:44
The creator of OpenClaw: "I ship code I don't read"
Pop-up dialogs asking to approve every bash command are not a smart security mechanism. Instead, Pie provides enough flexibility for developers to build custom security solutions tailored to their specific needs.
▶ 7:30
Building pi in a World of Slop — Mario Zechner
Developers should use application-specific GUIs to leverage human computer vision instead of forcing humans to read raw text. They must also keep AI agents on a leash by writing concrete prompts and working in small incremental chunks. This prevents the AI from generating overwhelming changes that make verification the bottleneck.
▶ 22:32
Andrej Karpathy: Software Is Changing (Again)
LLMs will not automatically implement scalable architectures unless explicitly guided by someone with prior system design experience. By making deliberate foundational choices like leveraging serverless Firebase functions and Google Cloud Run, developers guarantee scalability from the start. Alternatively, developers can prompt LLMs specifically for architectural recommendations regarding performance and bottlenecks.
▶ 45:02
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
The traditional IDE will be replaced by agent orchestration dashboards designed for managing multiple background workflows. Instead of writing code directly, developers will review activity feeds, monitor running tools, and handle agent notifications.
▶ 14:06
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Traditional coding puzzles belong to the old paradigm and no longer test modern skills effectively. Companies should instead give candidates large, open-ended projects to implement, secure, and defend against automated attacks.
▶ 18:44
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
AI coding mirrors the mechanics of a slot machine, featuring an illusion of control through prompt engineering and stochastic wins. Developers experience high-intensity marathons driven by occasional successes, leaving them mentally drained and detached from actual code comprehension.
▶ 48:09
The Dangerous Illusion of AI Coding? - Jeremy Howard
Burnout stemmed from constant high-stakes crises, managing endless unresolved issues as the company's waste bin, and heavy team conflicts. Working through stressful weekend emergencies without believing in the current management direction ultimately led to exhaustion.
▶ 29:51
The creator of OpenClaw: "I ship code I don't read"
Extensions in Pie are simple TypeScript modules located on disk that can be pointed to directly. They support hot reloading during a session and use standard package managers like NPM for distribution.
▶ 8:07
Building pi in a World of Slop — Mario Zechner
Vibe coding refers to programming entirely through natural language prompts where developers act as directors rather than writing explicit code. It is an effective gateway drug that allows non-experts or people unfamiliar with a language to build custom applications quickly. It drastically lowers the barrier to entry for creating custom software.
▶ 29:28
Andrej Karpathy: Software Is Changing (Again)
Sub agents are configurable markdown files that define specific character profiles or roles, such as a tester or performance expert. When activated during a prompt, the coding assistant adopts that avatar and behaves according to that specialized role for the request. This allows developers to simulate expert reviews directly within their CLI tool.
▶ 50:03
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
When every developer achieves 10x productivity using agents, merging massive concurrent code changes becomes an incredibly complex problem. Because multiple agents rewrite shared architectures simultaneously, traditional merge conflict resolution fails, requiring serialized queues or complete reimplementations.
▶ 18:51
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Humans must remain in charge of taste, aesthetics, high-level design, and system specs. While agents write boilerplate and handle API syntax, developers ensure the underlying architecture makes logical sense.
▶ 19:45
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Advanced models like GPT-5.3 Pro can successfully fix complex, multi-threaded legacy issues after hours of iterative prompting. However, this creates a dangerous maintenance risk because no human truly understands the resulting code.
▶ 51:02
The Dangerous Illusion of AI Coding? - Jeremy Howard
The speaker now runs five to ten coding agents simultaneously, acting primarily as a system architect and builder. Instead of reading every line of code, they manage tasks asynchronously, jumping between projects while models cook.
▶ 46:24
The creator of OpenClaw: "I ship code I don't read"
Automated pull requests can be handled by automatically closing them with a comment requiring a human voice issue. Since bots ignore these comments, tracking verified human accounts in a repository file creates a reliable filter.
▶ 11:14
Building pi in a World of Slop — Mario Zechner
While writing initial application logic via LLM prompts is fast, setting up infrastructure components like authentication, payments, domain names, and deployment remains tedious. Developers still have to navigate manual configuration steps in browser dashboards. This non-code devops work often takes significantly longer than the actual vibe coding part.
▶ 32:23
Andrej Karpathy: Software Is Changing (Again)
The application utilizes Gemini Flash to review user feedback and ensure it complies with the code of conduct, even catching inappropriate emoticons. It also features community-driven room occupancy tracking displayed on digital signage to help attendees gauge crowd levels. Additionally, it generates real-time transcripts, key takeaways, and summaries every few minutes during talks.
▶ 53:12
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Moving toward multi-agent systems where code is planned, implemented, and tested automatically unlocks programming for non-programmers and shifts team sizes down to two or three people. Coding ceases to be the delivery bottleneck, forcing businesses to integrate tightly into faster feedback loops.
▶ 24:00
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Models lack intrinsic motivations, curiosity, or fun derived from evolution. They are statistical simulation circuits shaped by pre-training and reinforcement learning rather than living entities with feelings.
▶ 23:43
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
LLMs are empirically poor at software engineering because they struggle to move outside their training data to build novel systems. While they can perform well on coding tasks, they mostly produce obvious copies of existing software like compilers or browsers.
▶ 58:44
The Dangerous Illusion of AI Coding? - Jeremy Howard
You must close the feedback loop by setting up automated tests, scripts, or debug CLIs so the agent can execute and validate its own work. This allows you to trust the output because the system has run and verified itself, similar to passing a robust test suite.
▶ 57:31
The creator of OpenClaw: "I ship code I don't read"
Letting agents write code unchecked leads to compounding errors, zero learning, and the import of mediocre internet complexity. Agents make purely local decisions, resulting in tangled abstractions and enterprise-grade technical debt.
▶ 12:58
Building pi in a World of Slop — Mario Zechner
Developers should provide documentation in formats like markdown which are easily readable by LLMs instead of human-oriented layouts with pictures and bold text. They also need to replace instructions that rely on manual browser actions, such as clicking buttons, with equivalent programmatic commands like curl commands.
▶ 34:38
Andrej Karpathy: Software Is Changing (Again)
Thanks to LLMs, the old dogma of never rewriting your code is obsolete for an increasingly large class of software bodies. When facing complex refactoring or test migrations, it is often significantly faster and cleaner to throw away the old code and have the LLM regenerate it from scratch.
▶ 26:43
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Workloads are decomposed into sensors and actuators designed to be legible to LLMs first. This means documentation, APIs, and deployment pipelines are built so developers can command agents directly rather than doing manual configuration.
▶ 25:53
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Traditional terminal-based AI tools rely on meager text files, whereas rich stateful environments like Python interpreters let humans and AI manipulate objects in real time. This interactive feedback loop fosters deep human understanding, rapid testing, and a sense of fulfillment rather than disconnection.
▶ 1:03:16
The Dangerous Illusion of AI Coding? - Jeremy Howard
Yes, agentic coding forces you to design systems that are easier to verify and test. Because verification is how you ensure code quality, you end up structuring cleaner interfaces since the model needs to be able to test its own code.
▶ 1:01:20
The creator of OpenClaw: "I ship code I don't read"
Long context windows are ultimately a hack that struggles as codebases grow beyond human comprehension. Furthermore, agents tend to patch code locally while breaking things globally, leaving developers stranded when bugs occur.
▶ 15:16
Building pi in a World of Slop — Mario Zechner
Although LLM agents are becoming capable of navigating standard human interfaces and clicking around, these actions remain expensive and error-prone. Providing specialized tools, markdown docs, and agent-friendly endpoints reduces friction and lowers costs. Meeting agents halfway ensures more reliable automation across digital infrastructure.
▶ 37:32
Andrej Karpathy: Software Is Changing (Again)
While you can outsource your thinking and data processing to AI, you cannot outsource your understanding. Humans must retain comprehension to direct agents effectively and know what problems are worth solving.
▶ 28:12
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Notebooks are inherently git-friendly, but standard Git only ships with merge drivers for line-based text files. By plugging in a custom merge driver for JSON files or using custom tools, developers can easily achieve cell-level diffs and clear conflict resolution.
▶ 1:14:41
The Dangerous Illusion of AI Coding? - Jeremy Howard
Elaborate orchestration layers resemble the failed waterfall model of software development where you try to spec everything out upfront. In practice, you learn so much while building that rigid multi-agent pipelines prevent the natural, iterative shaping process needed for good software.
▶ 1:09:21
The creator of OpenClaw: "I ship code I don't read"
Agents excel at tightly scoped, modular tasks where they are guaranteed to find necessary context. Good use cases include reproduction cases for user issues, non-mission-critical tasks, and tasks with clear evaluation functions.
▶ 16:17
Building pi in a World of Slop — Mario Zechner
Focusing solely on autonomous AI doomsday scenarios pushes society to centralize power into the hands of tech monopolies or governments. This power centralization invites power-hungry actors to monopolize the technology and control society, posing a much more immediate structural threat.
▶ 1:20:18
The Dangerous Illusion of AI Coding? - Jeremy Howard
Model Context Protocols force you to pre-export all functions and load massive JSON blobs into the context window without allowing data filtering. In contrast, CLIs allow agents to use standard tools like bash and jq to pipe and filter the exact data they need, making them far more efficient.
▶ 1:22:19
The creator of OpenClaw: "I ship code I don't read"
While privacy and surveillance risks exist, they are largely extensions of existing corporate and government practices rather than being uniquely created by AI. The most concerning risk is human enfeeblement, where people lose their capacity to build competence and understanding over time.
▶ 1:24:30
The Dangerous Illusion of AI Coding? - Jeremy Howard
Traditional pull requests are treated as prompt requests where the agent helps weave code into the system structure. Furthermore, slow remote CI pipelines are replaced with fast local agent gates that run linters, builders, and tests locally.
▶ 1:37:02
The creator of OpenClaw: "I ship code I don't read"
During initialization, a bootstrap file explains to the model that it is being born to create an identity and soul containing the user's core values. As you interact, the agent maintains and updates evolving documents like user.md and soul.md to store context.
▶ 1:31:54
The creator of OpenClaw: "I ship code I don't read"
Newcomers should cultivate infinite curiosity and build projects to gain experience, using the AI as an infinitely patient machine to explain complex codebases. While entering the market is harder, new developers benefit from not being constrained by legacy workflows.
▶ 1:45:48
The creator of OpenClaw: "I ship code I don't read"
No answer mentions that.