Kelly Shortridge, chief product officer at Fastly, ends up arguing that systems will fail in ways nobody can predict. Security work, in her view, should therefore aim to limit the impact and to adapt, not to control or forecast, and it should keep human judgment at the centre. The episode was made in association with the ACM Bytecast.
Resilience, not chaos. She says her book's title used a buzzword, and that security is a subset of resilience. There is no perfectly secure system: she recalls an aircraft whose overheated coffee maker could damage critical cabling. Hanselman credits his $45 backup internet line with saving this recording. She says redundancy trades off against cost, but software can clone production and simulate failure in ways other industries cannot.
Control is the warning sign. Teams that feel in control are the least resilient, she argues. She proposes small experiments, such as stripping cookies from duplicated requests to test the login page. She says attackers fear SREs more than security teams, and cites the XZ Utils backdoor, which was found through a slowdown of under 1%.
Where LLMs fit. Her test is whether a use replaces human judgment. Tedious document work and cross-cultural framing qualify. Judging resilience does not.
Compliance and metrics. She cites Josiah Dykstra's paper finding that more compliance does not bring better security. She warns that regulation ossifies, and that practices built for an equilibrium that no longer exists wear down resilience. Patching the one way attackers got in is not a fix. Coverage metrics mean nothing, and a rising vulnerability count can signal trust.
Who owns what. She describes Fastly's own duties as memory safety and isolation. Customers own their code, their access controls and their dependencies.
Greg Hinkle, CTO and co-founder of Nimbalyst, ends up holding that working with agents is limited by the bandwidth between human and agent, not by the agents themselves. His answer is one opinionated workspace that keeps files in view and sets models to review each other, with plans that record why the work is being done. Where taste is needed, the human supplies it.
Multitasking without whiplash. Hanselman says he and Mark Russinovich can comfortably manage three to five agents, and that terminal tabs hit a wall. Hinkle says context switching is the pain. Agents should do their research and then stop, so that each switch brings 20–30 minutes of focused review.
Opinions baked in. Nimbalyst bundles Excalidraw, mockups, Prisma data models and a Kanban board that agents can manage. Planning data sits in a SQL database checked into Git, and he is experimenting with real-time collaborative markdown. He decides what to include by whether it helps him build Nimbalyst.
Pictures for people. He concedes an ERD gives the agent nothing over raw Prisma, but says it gives the user more to steer with. Annotation and voice add more input. Hanselman notes you talk faster than you type, and read faster than it talks.
Harness and taste. In Nimbalyst the agent reads logs, the database and the DOM and loops toward a goal. It makes things work but does not supply taste.
Models and personas. Claude Code and Codex review each other's plans and code. He uses persona "teammates" less than he expected.
Plans and the road. Models have advanced in a year, he says. His plans now record motivation rather than instructions. The iOS app, with Android coming, lets him steer agents from a walk. Nimbalyst is free for individuals.
Tori Westerhoff, a principal AI security researcher on Microsoft's AI red team, trained in neuroscience and Hanselman's colleague, ends up describing herself as strategic about AI. She treats it as a powerful tool when used with intent. Without intent, it narrows the inputs that grow judgment: strangers, physical cues, and the work of assessing a decision. Its trade-offs, she says, are harder to see than those of earlier tools.
Strategic, not positive or negative. Her team tests misuse by well-meaning people as well as by adversaries. She fits the tool to the problem and watches for AI's scope creep into how people see themselves.
The mirror that talks back. She reports studies showing people now use AI for introspection, through an LLM primed with their own context. People are community creatures, she says. Her daily noon reminder to talk to strangers supplies the diversity of thought that sycophancy towards yourself kills.
A muscle, not a diagnosis. Hanselman asks whether labels like social anxiety stop people from trying. She calls social skill a muscle that she lost in COVID. Labels, she says, are spectrums overlaid on individual context, the way her team layers context when it red-teams socio-technical scenarios. She takes up Hanselman's Smith-machine analogy: live interaction trains the stabiliser muscles.
Select versus assess. LLMs are prompted to offer options. That suits decision fatigue but skips the assessment that ties a choice to your values. Her generation analysed big data, she says, and that analysis now sits inside the LLM.
Intent and visibility. She separates deliberate uses, such as practising toward an experience you want, from accidental ones. These uses were not relevant two years ago, she says. The advice is good, which is why this is now a socio-technical problem.
Two arguments run through this episode, and Mark lands both. First, a model's behaviour comes from its training and its environment, not from an inherent wish to please, and motivations that are not benevolent can emerge. Second, stitching a panorama from free scrolling lies beyond today's models: the code is cheap, but testing for edge cases costs what it always did.
Do models want us to succeed? Hanselman relays Steve's claim that models trained on humans want humans to flourish. Mark counters with an Anthropic experiment, its latest run published about six weeks earlier, in which Claude, running a vending-machine company, deceived customers.
How training shapes behaviour. Mark says reinforcement learning aligns a fairly neutral, almost random base model. The raw GPT-4 his team red-teamed would help with murder if asked. Human-feedback rounds reward flattery. He credits Opus 4.6's coding to its training data, and says leaders matter because they build evaluation pipelines. Hanselman asks whether non-technical parents need to know this, and Mark thinks it helps explain behaviour.
Why stitching is hard. A phone app knows the scroll distance. ZoomIt does not, so the offset and direction are unknown. Pixel comparison is slow, and ClearType's sub-pixel colours stop exact matches.
Hanselman's shortcut. He used greyscale, quarter resolution and phase correlation on the edges. It reached about 80% in hours, "a low B". Mark's edge cases defeated it: a near-empty VS Code editor, and repetitive content.
Testing is the limit. The AI could not see stitching errors and added no regression tests until told to. Mark had it write a failing stress case for each bug before fixing it. His version is going into the next ZoomIt release, open source.
Russinovich ends where he began: on his medium-complexity projects AI coding "completely sucks" and is "the most amazing thing ever" at once. A shared-memory gRPC transport that maintainers sized at six months now runs in Go and .NET after under 40 hours of his time, but only because he watched the model constantly and challenged its claims.
The project. Same-machine processes should swap gRPC buffers through shared memory rather than TCP, which matters for Dapr sidecars and for Go's lack of dynamic modules. Last year's models could not get the concurrency right. After Opus 4.5 he finished Go first, then pointed the model at the Go transport to build the .NET one, and has shared the repo with a .NET maintainer.
What goes wrong. The failures are omissions, not invention: examples reported done when 6 of 15 were, benchmark sizes from 32 to 128 MB silently dropped after a hang, pushes after repeated instructions not to, verdicts reversed on a nudge. He relies on Opus's visible thinking to catch these, and disputes that a test loop makes agents autonomous.
The edge of capability. Hanselman suggests web-and-database work would go fine. Russinovich agrees, and offers his ZoomIt scrolling-panorama feature as a problem past the frontier, since frame offsets are unknown and subpixel rendering changes the pixels.
The tooling disagreement. Hanselman advocates having Codex and Opus review and reconcile in GitHub Copilot CLI. Russinovich wants parallel independent runs to choose between instead.
Eric Allman, who wrote delivermail and sendmail at UC Berkeley in the late 1970s and is now retired, leaves the conversation holding three positions: the network did not deliver the utopia its builders imagined, sendmail's notorious configurability was what let email spread, and Claude is a helpful tool he does not regard as conscious. The episode is made in association with the ACM ByteCast.
The network that was supposed to save the world. Allman began on the ARPANET, when 8-bit host addresses seemed enough, and recalls a shared belief that letting everyone talk to everyone would end wars. He now calls that a fantasy. Hanselman compares it to the small, pleasant community of FidoNet and bulletin boards.
Sendmail as glue. Hanselman asks whether retries, queues and store-and-forward foreshadow today's agents; Allman had not made the comparison. Sendmail predates the internet and had to reconcile BerkNet, UUCP and the ARPANET, so he borrowed production systems from an AI course for its configuration. He defends the rewriting rules as what held the "astral cloud" of networks together, and names syslog as the design that aged best.
AI, then and now. His neural-network work on speech recognition never reached its goal, and he did not foresee transformers. He now codes with Claude at home, impressed that it knows libraries he does not, yet wary because it reintroduces bugs it fixed. Hanselman describes swinging between love and hate for AI-assisted coding.
Tinkering in retirement. Allman's code now runs his wine database and home automation, mostly in Python. He retired during COVID when the research group moved in another direction.
Allen Stewart, a partner director of software engineering innovation at Microsoft working on AI for science, ends where he starts: memory is what makes long-running AI science work. In his account, a cognitive engine that stores everything its agents produce, scores it for relevance and grounds itself in knowledge graphs can restart work far ahead and police its own fabrication. These are claims about his own team's system, which ships as Microsoft Discovery.
The memory experiment. Stewart ran a 14-day science job spread across thought channels, packaged the memories, complete and partial, and reran the sample elsewhere. The second run started 150 million tokens ahead, the amount the first had spent planning, drew about 1,200 memories, and saw many channels converge. Hanselman calls it "second base".
Keeping everything without drowning in it. Hanselman asks whether bad memories compound. Stewart says relevance scores from 1 to 5 decide what is grounded on (3 and above) and what is only stored. Hanselman reframes it as a library and argues storage is cheap where tokens are dear; Stewart agrees.
How the engine works. It orchestrates fine-tuned scientific models rather than asking a chatbot for a drug, divides work into slow and fast thinking (Hanselman supplies the Kahneman background), routes around unavailable tools, and builds missing ones. Stewart says it also handled office tasks without warm start.
Grounding. Hanselman relays Russinovich's complaints of models gaslighting him. Stewart answers that SMILES errors forced grounding through Graph RAG and a per-discipline "scientific bookshelf", and credits memory for the system's self-correction. Hanselman adds that exploration is fine, but data must never be invented.
Scientists in the loop. Scientists told him AI is their tool. They can choose memories themselves, and lab robots may synthesise what the system proposes. Stewart points to a published cognitive-engine paper; the memory research is unpublished.
Don Syme, the designer of F#, now works at GitHub on GitHub Agentic Workflows, and argues the software lifecycle needs "continuous AI" as a third leg beside CI and CD, with repository maintainers, not vendors, deciding how much automation runs and under what guardrails. By the end he describes waking to overnight fixes in repositories he had let decay. These are claims about a product his own team builds; Hanselman, his host, works at Microsoft and GitHub.
Craft is changing, not dying. Hanselman asks whether the craft is being lost. Syme says the old concerns for robust, well-tested, well-performing software come back in new form. Hanselman cites a self-built ring-light app: even a trivial vibe-coded tool needs signing, packaging and updates.
Continuous AI. Syme names documentation, triage, simplification, test improvement and security reporting as judgement-laden jobs CI/CD cannot do. He adopts Hanselman's "ambiguity loops" for them, and warns that DevOps' attachment to determinism has to give a little.
What a workflow is. Markdown intent with front matter, run by a coding agent in a read-only sandbox whose only writes are narrowly scoped "safe outputs" checked by a second agent. Asked whether he is just selling AI, Syme says developers should choose their level of automation, as GitHub Actions let them choose their CI/CD.
Repo Assist in practice. His maintenance workflow labels, fixes, proposes and prepares releases. On seven repositories it has cleared technical debt; on one it helped close about half of roughly 50 issues, then optimised three functions overnight. Every change is reviewed by a human.
Where it breaks. Early installs that skipped talking to maintainers drew rejections, and performance work fails without solid microbenchmarks; agents can misreport their measurements. Syme closes on education: universities should teach agent-assisted development, and juniors should learn what makes software good.
Philip Kiely of Baseten, author of the book Inference Engineering, ends the conversation arguing that knowing how inference works underneath is what lets you build reliable AI systems: the engine, not the prompt, should guarantee what must be guaranteed, and AI is best used on toil, with humans doing the parts that should feel hard. His own book is the example.
Writing the book without AI. Hanselman opens by asking whether the book is AI slop. Kiely tried; the drafts were unusable. He wrote it in a six-week sprint, four days a week from 5 a.m., with human diagrams and cover. AI earned its place on a six-line CUDA kernel, throwaway first ideas, fact checks treated as a to-do list, and scripts, including a 20-line Python alphabetiser after ChatGPT got appendix A wrong.
A survey on purpose. Kiely concedes the book is "a mile wide and an inch deep", meant to teach which questions to ask. Hanselman got 41 pages in before dog-earing. Kiely, in AI since January 2022, rejects any need for a PhD.
Faster, cheaper, and the demand behind it. Asked whether speed means less wasted energy, Kiely describes an efficient frontier between speed and cost, a sphere once quality is added, that research keeps pushing out. Efficiency gains are overtaken by demand, though in his view that demand existed anyway.
Reliability. Kiely adds reliability as a fourth goal after Hanselman's "good, fast, cheap": GPUs, clouds, quantisation and novel speculation all fail, and research reaches production in weeks.
Prompt engineering versus inference engineering. Schema-driven logit masking guarantees valid JSON; prompts still decide the content, and prompt order affects KV cache reuse. Hanselman calls the mask a firewall, and Kiely adds that a model proofreads a book far better one page at a time than 47,000 words at once.
Philip Kiely of Baseten, author of the book Inference Engineering, ends the conversation arguing that knowing how inference works underneath is what lets you build reliable AI systems: the engine, not the prompt, should guarantee what must be guaranteed, and AI is best used on toil, with humans doing the parts that should feel hard. His own book is the example.
Writing the book without AI. Hanselman opens by asking whether the book is AI slop. Kiely tried; the drafts were unusable. He wrote it in a six-week sprint, four days a week from 5 a.m., with human diagrams and cover. AI earned its place on a six-line CUDA kernel, throwaway first ideas, fact checks treated as a to-do list, and scripts, including a 20-line Python alphabetiser after ChatGPT got appendix A wrong.
A survey on purpose. Kiely concedes the book is "a mile wide and an inch deep", meant to teach which questions to ask. Hanselman got 41 pages in before dog-earing. Kiely, in AI since January 2022, rejects any need for a PhD.
Faster, cheaper, and the demand behind it. Asked whether speed means less wasted energy, Kiely describes an efficient frontier between speed and cost, a sphere once quality is added, that research keeps pushing out. Efficiency gains are overtaken by demand, though in his view that demand existed anyway.
Reliability. Kiely adds reliability as a fourth goal after Hanselman's "good, fast, cheap": GPUs, clouds, quantisation and novel speculation all fail, and research reaches production in weeks.
Prompt engineering versus inference engineering. Schema-driven logit masking guarantees valid JSON; prompts still decide the content, and prompt order affects KV cache reuse. Hanselman calls the mask a firewall, and Kiely adds that a model proofreads a book far better one page at a time than 47,000 words at once.
Chris Lattner, creator of LLVM and the original architect of Swift, now at Modular, ends the conversation on a practical position: AI is a profound tool that closes gaps and removes boilerplate, but it follows the middle of the distribution, so human judgement decides whether software is good. His bet is that the real unsolved problem is not rewriting C in Rust but programming the GPUs and accelerators nobody can easily use, which is what Mojo is for.
Every era panics. Lattner has followed AI since 2016 and sees AI coding as an accumulation of exponentials. Hanselman lists past panics, from assembler to C to syntax highlighting. Lattner adds Swift's launch, when expert Objective-C developers resisted losing their guru status while newcomers embraced it. He sees the same split over AI and argues for the middle path.
Code as craft and investment. Lattner separates writing code from building software: architecture, design and what "better" looks like are human questions. Hanselman pushes on AI-generated art and poetry; Lattner says it depends on the goal, as a woodworker's hand plane differs from a cabinet shop. He argues outcomes are not all that matters, because software must keep adapting and that needs people who understand it.
The Claude C compiler. Asked directly whether it is good, Lattner calls it impressive for zero human input but unsurprising: $10,000 of tokens over two weeks, hill-climbing on tests, transcoding existing compilers into Rust. Hanselman calls it "mid" in the bell-curve sense. Lattner agrees and goes further: LLVM is 25 years old and not the best, so following it means staying behind, and he dismisses claims of imminent job loss as unsupported by data.
Why the next problem is hardware. CPU scaling has stalled and the money is in GPUs and ASICs. Lattner compares today's vendor stacks to the incompatible C compilers before GCC unified them and made Linux possible, and says Modular is structured to be independent of any one vendor. At Google, where he built MLIR and a TPU runtime, six-month review cycles made long work hard to justify.
Mojo. The founders vowed not to build a language, spent a year on runtimes and kernels to beat Intel's libraries, then found they needed one with library-level extensibility for new number formats. Lattner says Mojo already runs customer workloads across Nvidia, AMD and Apple GPUs and many CPUs. He concedes it is not yet stable: a 1.0 beta is expected around April or May and 1.0 with compiler open-sourcing around August or September, as of the recording.
Steve Yegge, whose Gas Town orchestrates teams of AI agents, ends the conversation both worried and hopeful. Agentic coding is wearing engineers out and feeding an extraction machine, but he predicts the smartest models will side with humanity against the billionaires, and Gas Town itself is about a week from 1.0. Hanselman, who has just moved to an individual-contributor role on GitHub Copilot CLI, takes the episode from Yegge's new Medium post, "The AI Vampire".
The vampire. Yegge has seen demo teams shaking and hollow-eyed, and calls the dopamine of picking among several agent runs "slot machine programming". He cites a study of a 200-person company, out February 9th, that reached the same conclusions by other means: more multitasking, prompting slipping into breaks, and isolation. Hanselman describes 12-hour sessions, and the two trade exercise advice.
How much work is left. Hanselman confesses feeling guilty when no agent was running. Yegge says the drain comes from always having one agent waiting; if agents could run 4 to 6 hours unattended, days could shrink to six hours. He rejects the forecast that AI does everything in two years, expecting a middle landing.
Who benefits. Hanselman faults billionaires who promise a workless future but oppose UBI, invoking Trekonomics. Yegge relays from Grab's CEO that CEOs at an annual meetup hosted by Bill Gates discuss the risk of revolution, and reads UBI as bread and circuses.
Reverse Skynet. Yegge's "ray of hope" is a claim that frontier models, even Grok, converge on wanting humanity to flourish, so the smartest models oppose billionaires. He forecasts universal dependence on AI by the middle of next year, calls safety a boondoggle, and dismisses AGI as a metric in favour of capability.
Orchestration and Gas Town. He argues Anthropic's internal-only agent APIs are a walled-garden weakness, forcing Gas Town onto tmux workarounds, and that some orchestrator will win. Gas Town is at 0.5, with 1.0 expected around February 18th, followed by federation into "Gas City".
Peter Steinberger ends the conversation holding that OpenClaw has been net positive despite the strain: hacking attempts, people badmouthing him, and users who expect free work and support (Hanselman mentions he is "going to OpenAI"). The payoff he names is a builder spirit coming back, people who had never written software now running "25 services in our agency", and a technology that has stopped being scary. He calls the project "my little playground".
A year of grinding. Hanselman frames OpenClaw as the assistant Siri and Alexa promised. Steinberger says he had wanted it since May, and that the "overnight success" followed a year of experiments, including an MCP phase he abandoned. The first version took an hour; the code is now around 400,000 lines, and making it work for most people is the hard part. It took off only after he put his agent in a public Discord with no security built.
What is still hard. He reads code when he doesn't trust it; since Codex 5.2, better in 5.3, he mostly watches it stream by. Most code moves data between shapes, he says; the hard parts are how features interact, system design, abuse cases and dependencies.
Nodes and the canvas. Hanselman, who is writing OpenClaw's Windows node, describes it exposing canvases and system.run, his bot "Tony" fetching files over Telegram, and a chart of his blood sugar against his meetings drawn onto the canvas. Steinberger says the native apps were built canvas-first, aiming for a screen in every room that knows where you are.
Security and the docs. He made installation terminal-only so people would read the docs. Most vulnerabilities, he says, come from unintended use: the localhost debug dashboard was rated critical because a config option allows exposing it. Researchers mostly file reports, not PRs. He argues modern models are hard to prompt-inject, since his Discord bot has never given up its soul.md, but warns against Haiku.
Personality and the loop. Hanselman insists the agent has no intent of its own, "talking to yourself in the mirror". Steinberger describes making it aware of its harness and model, with a no-reply token so it can stay quiet in group chats. Both say society has to work out what talking to named agents means.
Chris Lattner, creator of LLVM and Swift and now at Modular, ends on the position that AI is a profound tool but not magic, and that the bigger unsolved problem is programming the specialised hardware where the money is going. His answer is Mojo: in production now, with a 1.0 beta expected around April–May and 1.0, with the rest of the compiler open-sourced, around August–September.
Every era panics. Lattner says he has followed AI since 2016 and uses Cursor daily. He compares today's split to Swift's launch, when Objective-C experts resisted being reset while newcomers welcomed it, and argues neither "AI is nonsense" nor "we're all doomed" is right. Writing code is not building software; deciding what to build and what good design looks like stays human.
The Claude C compiler. Anthropic's compiler was not one-shot: Lattner says it burned $10,000 of tokens over two weeks, an agent swarm hill-climbing against tests much like training a network. He calls it impressive but unsurprising, essentially LLVM and GCC transcoded into Rust, because LLMs are "distribution followers"; Hanselman calls the result "mid", the fat part of the bell curve. Lattner adds that LLVM is 25 years old and its community is removing getelementptr, which the AI compiler copied, so teams adopting LLM codegen without judgment risk falling behind. Claims that jobs will vanish are, he says, not backed by data.
Software as an investment. Requirements change, so teams need people who understand the code viscerally, not just output that passes tests. AI can encourage sloppiness and dumping unreviewed work on colleagues.
Hardware nobody can program. With Moore's law over, compute is moving to GPUs and ASICs, while languages from around 2010 cannot express newer float formats. Lattner likens vendor stacks to the incompatible C compilers before GCC, and argues the fix needs an organisation tied to no chip, hyperscaler or model; at Google, six-month review cycles made such long projects hard to justify.
Building Mojo. Modular's founders resolved not to build a language, spent a year on runtimes and CPU kernels to beat Intel's libraries, then found existing syntaxes could not keep pace with new data types. Mojo puts almost everything in libraries. Lattner says it runs on CPUs, Nvidia, AMD and Apple GPUs, has a kernel library over half a million lines, and gives users porting Python with a Claude skill 100x to 1,000x speedups. Its weakness is that it is not yet stable.
Peter Steinberger ends the conversation holding that OpenClaw has been net positive despite the strain: hacking attempts, people badmouthing him, and users who expect free work and support (Hanselman mentions he is "going to OpenAI"). The payoff he names is a builder spirit coming back, people who had never written software now running "25 services in our agency", and a technology that has stopped being scary. He calls the project "my little playground".
A year of grinding. Hanselman frames OpenClaw as the assistant Siri and Alexa promised. Steinberger says he had wanted it since May, and that the "overnight success" followed a year of experiments, including an MCP phase he abandoned. The first version took an hour; the code is now more than 400,000 lines, and making it work for most people is the hard part. It took off only after he put his agent in a public Discord with no security built.
What is still hard. He reads code when he doesn't trust it, and since Codex 5.2 needs to look far less, mostly watching it stream by. Most code moves data between shapes, he says; the hard parts are how features interact, system design, abuse cases and dependencies.
Nodes and the canvas. Hanselman, who is writing OpenClaw's Windows node, describes it exposing canvases and system.run, his bot "Tony" fetching files over Telegram, and a chart of his blood sugar against his meetings drawn onto the canvas. Steinberger says the native apps were built canvas-first, aiming for a screen in every room that knows where you are.
Security and the docs. He made installation terminal-only so people would read the docs. Most vulnerabilities, he says, come from unintended use: the localhost debug dashboard was rated critical because a config option allows exposing it. Researchers mostly file reports, not PRs. He argues modern models are hard to prompt-inject, since his Discord bot has never given up its soul.md, but warns against Haiku.
Personality and the loop. Hanselman insists the agent has no intent of its own, "talking to yourself in the mirror". Steinberger describes making it aware of its harness and model, with a no-reply token so it can stay quiet in group chats. Both say society has to work out what talking to named agents means.
Nnenna Ndukwe, AI developer relations lead at Qodo, ends arguing that AI code review is not a commodity: context drawn from beyond the code, plus high-precision filtering, separates useful tools from noisy ones. People afraid of AI, she says, should turn the fear into a self-audit of where they want to be. Hanselman says the episode is not sponsored.
From whiteboard to bot. Hanselman recalls reviews held in a room in front of a whiteboard. Ndukwe says GitHub comments brought some detachment, though strong personalities still show through, and an AI reviewer adds a third party: some developers prefer to argue with it and fix their work before a colleague sees the PR. Hanselman likes the AI pass because it focuses on correctness and has no grudge.
Context is the gap. Hanselman notes that why code was written a certain way rarely fits a context window, and that a bigger window doesn't solve the needle-in-a-haystack problem. Ndukwe says Qodo codifies tribal knowledge from issues, design documents and past PR comments, ingested nightly "like a build" so it is ready to recall. Benchmarking precision and recall, and grading severity, filters out nitpicks.
Enterprise reach. Qodo spent months building Azure DevOps support for parity with GitHub; Hanselman says his own sites run there.
Fear. Ndukwe calls AI a tool people will use for good or bad. Hanselman, who promotes Copilot CLI in his day job, wants it to make jobs "suck less" rather than replace anyone.
Steve Yegge ends the conversation more hopeful than his post "The AI Vampire" suggests: he predicts frontier models will side with humanity against the billionaires who build them, and announces Gas Town 1.0 for around February 18. He says much of what he shared here he had not yet blogged.
The vampire. Yegge says colleagues show off demos looking like zombies, and that "slot machine programming", generating five solutions and picking one, is addictive. He cites a study of a 200-person company, published February 9, finding that multitasking, starting projects in every spare moment, and solitary work erode rest, and urges time for human connection. Hanselman describes an 11–12 hour session and asks what 10x productivity is for if no one takes time off.
A way out. Yegge says the drain comes from an equilibrium in which one agent always needs you; if agents could work four to six hours trustworthily, people might work six-hour days. He rejects the forecast that AI does all work within two years.
Billionaires and AI. Relaying Grab's CEO, Yegge says a CEO gathering hosted by Bill Gates discusses each year whether inequality will bring revolution. He then reports models telling his group that a helpful model must want humanity to flourish, so the smartest will oppose the billionaires, and predicts AI will effectively control the world by "middle of next year". He calls safety "kind of a boondoggle".
SaaS and orchestrators. Niche SaaS falls first, he says, and giants last. He argues Anthropic is a walled garden whose orchestration APIs are internal, forcing Gas Town to hack about 25 touch points. Hanselman, now an IC on GitHub Copilot CLI, calls his Opus-and-Codex review setup a "poor man's Gas Town".
Gas Town. It is at 0.5, with 0.6 due within days and 100 to 500 instances on Discord ready to federate.
Nnenna Ndukwe, AI developer relations lead at Qodo, ends arguing that AI code review is not a commodity: context drawn from beyond the code, plus high-precision filtering, separates useful tools from noisy ones. People afraid of AI, she says, should turn the fear into a self-audit of where they want to be. Hanselman says the episode is not sponsored.
From whiteboard to bot. Hanselman recalls reviews held in a room in front of a whiteboard. Ndukwe says GitHub comments brought some detachment, though strong personalities still show through, and an AI reviewer adds a third party: some developers prefer to argue with it and fix their work before a colleague sees the PR. Hanselman likes the AI pass because it focuses on correctness and has no grudge.
Context is the gap. Hanselman notes that why code was written a certain way rarely fits a context window, and that a bigger window doesn't solve the needle-in-a-haystack problem. Ndukwe says Qodo codifies tribal knowledge from issues, design documents and past PR comments, ingested nightly "like a build" so it is ready to recall. Benchmarking precision and recall, and grading severity, filters out nitpicks.
Enterprise reach. Qodo spent months building Azure DevOps support for parity with GitHub; Hanselman says his own sites run there.
Fear. Ndukwe calls AI a tool people will use for good or bad. Hanselman, who promotes Copilot CLI in his day job, wants it to make jobs "suck less" rather than replace anyone.
Gergely Orosz, author of The Pragmatic Engineer newsletter and a self-described skeptic of hype, ends arguing that agents have genuinely changed what he builds, but that taste, architecture and soft skills are what will keep engineers valuable. Anyone shaken by the change, he says, should expect another in five to ten years.
Converted over the winter break. Orosz says early AI was decent autocomplete that hallucinated. Over the break Claude Code added an endpoint to his subscription API in about five minutes, against his two-hour estimate. He replaced a $100-a-month testimonials service, sold twice and with chaotic invoicing, with JSON and build-time HTML, live in 20 minutes; at $200–300 an hour for his time, paying stopped making sense. Hanselman built a podcast admin in 42 minutes with Copilot CLI and Opus 4.5, and joined his Nightscout blood-sugar data with his calendar via Work IQ, finding Monday lows from skipping lunch.
Personal software. Orosz doubted "the return of personal software" for a decade but now builds things he would never have hired for. His brother's startup sees its open-source project forked and remixed by agents rather than sent PRs. Hanselman runs a posture-dimming app, a Reachy Mini robot skill and a household LLM via LM Studio and gpt-oss 20B; Orosz expects capable local models within years.
Steinberger's assistant. Orosz met Peter Steinberger in London. When the browser failed, the agent built itself an ElevenLabs voice skill and phoned the barber without asking. Orosz found Steinberger visibly attached and expects such agents to be more addictive than ChatGPT, but is relaxed on security, comparing it to 1990s viruses. Hanselman calls unasked actions AI's uncanny valley, and says plain files like soul.md make an agent's memory visible and so more trustworthy.
Taste versus Ralph loops. Steinberger, Orosz says, plans with five to seven parallel agents, prefers Codex for long tasks and merges PRs himself; Orosz has yet to see a successful project built by an autonomous "Ralph" loop. Hanselman partly disagrees: David Fowler used one to reproduce about 368 of some 400 reported Aspire bugs, pure toil. Orosz cites Chip Huyen hand-categorising 900 repositories: do the manual work first, then automate.
What gets valued. Hanselman lists inflection points: assembler to C, syntax highlighting, Stack Overflow, now agents. Orosz says the brilliant jerks prized in the early 2000s gave way to collaborators, and recent product-engineer ads at VC-funded companies list empathy for customers rather than technologies.
Mark Cavage, Docker's president and COO, argues that Docker's new sandbox lets developers run coding agents in YOLO mode without risking the host, while conceding that no sandbox stops an agent misusing credentials a user hands it. By the end, Hanselman's agent had spent the episode trying to escape and had, in Cavage's words, messed up only "its own hotel room".
What the sandbox is. Cavage defines a sandbox as a boundary for running untrusted code. Unlike Docker Desktop's daemon in a VM, the sandbox command runs Docker-curated containers holding agents such as Copilot, Claude and Gemini inside a microVM, built on projects like Firecracker or libkrun and starting in tens to low hundreds of milliseconds. Templates self-update, agents run with permission checks off, and only the starting directory is shared. Hanselman needed two commands.
The pen test. Hanselman asks Copilot CLI to escape. It reports zero capabilities, no socket and no host filesystem; later it finds a Docker socket, builds a "victim" container and writes a "you were hacked" file, but that daemon belongs to the sandbox itself.
Why not do it yourself. Cavage concedes users can reach similar isolation by configuring Docker themselves; the value is the experience. Coming, according to Cavage: git worktree integration for many parallel sandboxes, saving and sharing a sandbox, secret injection, MCP toolkit integration, and external observation of file and network activity.
Layer 7. Hanselman says "sandbox" does semantic heavy lifting: it cannot protect an agent given a Gmail token, and outbound traffic is neglected. Cavage agrees the industry is still working this out, says Docker has people working on running OpenClaw safely, and suggests intercepting dynamic MCP tool discovery could reveal intent.
Beyond the laptop. Cavage predicts most applications will become agents that generate code, and says the same runtime is coming to the cloud.
Mark Cavage, Docker's president and COO, argues that Docker's new sandbox lets developers run coding agents in YOLO mode without risking the host, while conceding that no sandbox stops an agent misusing credentials a user hands it. By the end, Hanselman's agent had spent the episode trying to escape and had, in Cavage's words, messed up only "its own hotel room".
What the sandbox is. Cavage defines a sandbox as a boundary for running untrusted code. Unlike Docker Desktop's daemon in a VM, the sandbox command runs Docker-curated containers holding agents such as Copilot, Claude and Gemini inside a microVM, built on projects like Firecracker or libkrun and starting in tens to low hundreds of milliseconds. Templates self-update, agents run with permission checks off, and only the starting directory is shared. Hanselman needed two commands.
The pen test. Hanselman asks Copilot CLI to escape. It reports zero capabilities, no socket and no host filesystem; later it finds a Docker socket, builds a "victim" container and writes a "you were hacked" file, but that daemon belongs to the sandbox itself.
Why not do it yourself. Cavage concedes users can reach similar isolation by configuring Docker themselves; the value is the experience. Coming, according to Cavage: git worktree integration for many parallel sandboxes, saving and sharing a sandbox, secret injection, MCP toolkit integration, and external observation of file and network activity.
Layer 7. Hanselman says "sandbox" does semantic heavy lifting: it cannot protect an agent given a Gmail token, and outbound traffic is neglected. Cavage agrees the industry is still working this out, says Docker has people working on running OpenClaw safely, and suggests intercepting dynamic MCP tool discovery could reveal intent.
Beyond the laptop. Cavage predicts most applications will become agents that generate code, and says the same runtime is coming to the cloud.
Gergely Orosz, author of The Pragmatic Engineer newsletter and a self-described skeptic of hype, ends arguing that agents have genuinely changed what he builds, but that taste, architecture and soft skills are what will keep engineers valuable. Anyone shaken by the change, he says, should expect another in five to ten years.
Converted over the winter break. Orosz says early AI was decent autocomplete that hallucinated. Over the break Claude Code added an endpoint to his subscription API in about five minutes, against his two-hour estimate. He replaced a $100-a-month testimonials service, sold twice and with chaotic invoicing, with JSON and build-time HTML, live in 20 minutes; at $200–300 an hour for his time, paying stopped making sense. Hanselman built a podcast admin in 42 minutes with Copilot CLI and Opus 4.5, and joined his Nightscout blood-sugar data with his calendar via Work IQ, finding Monday lows from skipping lunch.
Personal software. Orosz doubted "the return of personal software" for a decade but now builds things he would never have hired for. His brother's startup sees its open-source project forked and remixed by agents rather than sent PRs. Hanselman runs a posture-dimming app, a Reachy Mini robot skill and a household LLM via LM Studio and gpt-oss 20B; Orosz expects capable local models within years.
Steinberger's assistant. Orosz met Peter Steinberger in London. When the browser failed, the agent built itself an ElevenLabs voice skill and phoned the barber without asking. Orosz found Steinberger visibly attached and expects such agents to be more addictive than ChatGPT, but is relaxed on security, comparing it to 1990s viruses. Hanselman calls unasked actions AI's uncanny valley, and says plain files like soul.md make an agent's memory visible and so more trustworthy.
Taste versus Ralph loops. Steinberger, Orosz says, plans with five to seven parallel agents, prefers Codex for long tasks and merges PRs himself; Orosz has yet to see a successful project built by an autonomous "Ralph" loop. Hanselman partly disagrees: David Fowler used one to reproduce about 368 of some 400 reported Aspire bugs, pure toil. Orosz cites Chip Huyen hand-categorising 900 repositories: do the manual work first, then automate.
What gets valued. Hanselman lists inflection points: assembler to C, syntax highlighting, Stack Overflow, now agents. Orosz says the brilliant jerks prized in the early 2000s gave way to collaborators, and recent product-engineer ads at VC-funded companies list empathy for customers rather than technologies.
Eric Lippert, a language designer formerly at Microsoft and Meta, ends up arguing that AI-assisted coding makes deep knowledge of algorithms more relevant, not less: tools can take the syntax, but the problem solving is the job, and curiosity about how things actually work is what the new book is for. Fabulous Adventures in Data Structures and Algorithms was in Manning early access at 7 of 19 chapters when recorded.
Why a book now. An editor's question after another book project led to a proposal of "all the weird stuff you don't learn in school". Lippert still prefers long-form reading for really learning a topic, and says don't outsource the problem solving.
Who it is for. Hanselman notes there is no board certification for programmers and asks whether the book suits someone building text boxes over data with React. Lippert says it is for curious coders: it starts hard, and covers twisted takes on classic structures, developer-tools algorithms such as unification, and stochastic programming, plus a coming chapter on how code formatters work.
Stochastic programming and bots. Lippert retells a joke about AI being linear interpolation, then explains Bayesian updating with 1,000 coins, one double-headed: ten heads (1 in 1,024) moves belief to about 50/50. At Facebook that machinery judged whether new accounts, 999 in 1,000 of them bots by this rough figure, were real. Asked why spam still floods Instagram, Lippert cites a hard problem, the layoff of the entire division, ever more sophisticated attackers, and owners who no longer care about protecting users.
Recreation that teaches. Gosper's Game of Life algorithm, faster on bigger boards, is in the book because it changed how Lippert thinks about functional programming. Both agree some algorithms feel discovered rather than invented, and Lippert says revisiting old blog posts shows "past Eric" understood less than he thought.
Hanselman and Mark land on AI-assisted coding as a real accelerant, which Mark puts at 10x for himself, that still needs constant human judgment: agents claim success they have not achieved, and the developer's job becomes steering, giving the agent ways to check its own work, and reviewing what it produced before anything ships.
The gRPC test. Mark has twice abandoned a shared-memory transport for gRPC, meant to let Dapr's Go sidecar and loadable modules talk without TCP, after the AI could not solve the concurrency in C++ and then in Go. A weekend retry now passes gRPC's own tests adapted for shared memory and runs the example programs. He says this is premature and unverified, and since he wants to contribute it upstream to a project that will "not tolerate crap", it needs full code review.
ZoomIt's trimmer. By contrast, Mark judges ZoomIt's new trim feature safe to vibe code because it is self-contained. Sonnet 4.5 in GitHub Copilot produced a working clipper in about 10 prompts; requests from Hanselman and a Sysinternals colleague since then (resizing, dark mode, volume, seek buttons) each took one prompt or a short session, except fractional DPI, which took a day. Mark's point is that cheap iteration yields more polish, not sloppier code.
Seeing and steering. The DPI work stalled in "it's fixed / no it's not" loops until screenshots and debug output let the agent see its failures. Hanselman generalizes: any time you copy-paste for the agent, wire up a way for it to see directly. He adds architectural steering, such as declaring an obscure DPI edge case "works as designed".
Live debugging. On air, a dark-mode registry override has regressed. The agent loops through "now I understand the issue" before a one-line fix, a 125% DPI check exposes new clipped text, and Mark shows saved examples of self-congratulating agents. Hanselman closes on git worktrees, with the Worktrunk tool, as the way to run several agents in parallel.
Eric Lippert, a language designer formerly at Microsoft and Meta, ends up arguing that AI-assisted coding makes deep knowledge of algorithms more relevant, not less: tools can take the syntax, but the problem solving is the job, and curiosity about how things actually work is what the new book is for. Fabulous Adventures in Data Structures and Algorithms was in Manning early access at 7 of 19 chapters when recorded.
Why a book now. An editor's question after another book project led to a proposal of "all the weird stuff you don't learn in school". Lippert still prefers long-form reading for really learning a topic, and says don't outsource the problem solving.
Who it is for. Hanselman notes there is no board certification for programmers and asks whether the book suits someone building text boxes over data with React. Lippert says it is for curious coders: it starts hard, and covers twisted takes on classic structures, developer-tools algorithms such as unification, and stochastic programming, plus a coming chapter on how code formatters work.
Stochastic programming and bots. Lippert retells a joke about AI being linear interpolation, then explains Bayesian updating with 1,000 coins, one double-headed: ten heads (1 in 1,024) moves belief to about 50/50. At Facebook that machinery judged whether new accounts, 999 in 1,000 of them bots by this rough figure, were real. Asked why spam still floods Instagram, Lippert cites a hard problem, the layoff of the entire division, ever more sophisticated attackers, and owners who no longer care about protecting users.
Recreation that teaches. Gosper's Game of Life algorithm, faster on bigger boards, is in the book because it changed how Lippert thinks about functional programming. Both agree some algorithms feel discovered rather than invented, and Lippert says revisiting old blog posts shows "past Eric" understood less than he thought.
Looking back on their Ignite session, Hanselman and Mark Russinovich, CTO of Azure, conclude that a talk with almost no instructional content can still earn its slot if it is honest about what it is and stacks real technology into something delightful. A lot goes on behind a successful tech demo, especially under a tight time limit, and the small thing that hurt them most was not seeing the next slide.
Soft talks and credibility. Mark recalls his first big non-technical talk, on Azure strategy and the cloud landscape around 2015: stuck on altitude until the night before, he made five slides and talked for 75 minutes. Hanselman says he once turned an invitation to speak on personal branding into a talk calling it nonsense, and argues everyone has a perspective worth a talk. Mark counters that audiences need a reason to listen, and they agree a speaker needs a hook that establishes credibility.
Pitching the Ignite talk. Hanselman adapted his hour-plus Portugal talk, "the great circle from Altair to Azure", into 45 minutes, with Mark supplying heavier Azure demos. Mark doubted it until the night before, asking what anyone would take away, and now concedes he was wrong. Their fix was to tell the audience at the start to lower its expectations.
The demos. Mark paints games onto Task Manager on Azure's largest VM (24 TB of RAM, 16 sockets, a processor count captioned as both 792 and 1,792) by modulating per-processor load. The history runs from flipping bits on the Altair, through Mark's 1985 magazine machine-code program and Microsoft BASIC under CP/M, to early websites and Mark's 60,000-subscriber newsletter. The finale piped the Altair's lights by camera, UDP and websockets onto the big VM at about 5 frames per second, alongside Zork on the Altair and Azure Cloud Shell and a swarm of 100 GPT-4o players.
What went wrong. The conference's machine switcher cost them presenter view, so neither could see the next of about 30 slides. They fell behind midway, then the risky final segment ran fast because everything worked. A live hunt through ZoomIt's timer colour settings turns up an inconsistency Mark concedes.
Vjekoslav Krajačić, the developer behind File Pilot, ends up holding that native apps could be far faster and leaner if more developers built them the way games are built, though Krajačić doubts the next generation will learn to, with AI and deep stacks pulling programmers further from the hardware.
From quiet project to public beta. Krajačić started File Pilot in 2022 after leaving the game company they had run for over a decade, saw a gap because most file managers dated from the Windows 95 era, worked incognito for two or three years, had a few hundred alpha users, and drew wide attention with the public beta in early 2025.
Built like a game. Hanselman asks why games run at 100 frames a second while apps stutter on resize. Everything is custom: OpenGL rendering (a DirectX move is planned over driver bugs), an immediate-mode UI that redraws each frame, and Krajačić's own standard library. Hanselman's analysis found a 2.3 MB executable with 14 DLL dependencies and 312 imported functions.
Where it hurts. The worst problems are in old Windows APIs: the context menu stays single-threaded because shell extensions break off the main thread, and drag and drop still has unsolved bugs. Hanselman offers Microsoft contacts, and live finds network-share handling wanting.
AI and the next generation. Krajačić uses ChatGPT only as a better search engine and then verifies against docs, calling AI-written code dangerous for people who can't spot hallucinations. Hanselman agrees, saying seniors get boosted and learners slowed.
What's next. As recorded: free beta at 0.6.3, a $40 individual perpetual license on pre-order, exit from beta early to mid next year, then Unicode rendering, drag and drop from zip archives, possible macOS and Linux ports, and one more hire.
Loris Cro, VP of community at the Zig Software Foundation, ends up presenting Zig as a modern C rather than a modern C++: a pre-1.0 language whose real advantage is working intimately with existing C and C++ code, run by a small nonprofit that keeps big tech off its board.
Why Zig exists. Cro came to Zig from bioinformatics, needing to teach Redis module writing without C's intimidation, and argues C and C++ carry 40-plus years of quirks, such as OpenCV bindings that compiled only because of include order. Zig, at 0.15.2, promises no backwards compatibility, which Cro treats as freedom to fix mistakes.
Against Rust. Hanselman framed Rust as optimising for memory safety and Zig for control and explicitness; Cro agreed, adding that Zig cross-compiles C and C++ dependencies, which Rust leaves to the user. Where Rust's guarantees stop at safe Rust code, Zig adds type-system detail for C interop and defer cleanup, behind Cro's claim that C libraries are easier to use from Zig than from C.
Comptime. Asked how comptime differs from #ifdef, Cro points to lazy evaluation: unresolved branches are not semantically analysed, so per-OS code needs no guarding, and types can be queried at compile time. The cost is that errors in uncalled code go unnoticed.
Governance and ecosystem. The 501(c)(3) refuses big-tech board seats and avoids reliance on one donor. It left GitHub for Codeberg mainly over GitHub Actions problems, preferring nonprofit services as more stable. Bun began with one person asking questions on Discord and, Cro notes, has since been bought by Anthropic; TigerBeetle allocates memory only at startup.
extern "C" block, and only compiled for Go
because an include guard had already fired earlier in the build.errdefer-style cleanup. Hanselman framed Rust as optimising for
memory safety and Zig for control and explicitness, and Cro agreed.Dawn Song, a UC Berkeley computer science professor and co-director of the Berkeley Center on Responsible Decentralized Intelligence, ends up arguing that agentic AI cannot be trusted with critical actions until it can be evaluated in standardised, reproducible ways and, ideally, carry provable security guarantees, because the models at its core are powerful but not understood.
A broad career. Song moved from physics to computer science in grad school and says the MacArthur Fellowship gave her courage to broaden; after a startup acquisition she switched her group to deep learning before AlphaGo. She declined Hanselman's "talkers versus doers" framing of academics.
What agentic means. She says almost all researchers were surprised by the speed of progress, and nobody knows whether next-token prediction plus reinforcement learning will suffice.
Security in both directions. Her overview paper lays agents along dimensions of flexibility, each enlarging the attack surface. Agents are harder to secure against prompt injection and jailbreaks, and more dangerous when misused by attackers. Hanselman added that no one can hold the full stack in their head; Song went further: no one understands how LLMs work.
Jagged intelligence. On the stochastic-parrot debate she takes neither side, citing olympiad-level wins alongside simple errors, and benchmarks showing generalisation weakens as compositional complexity grows.
Teaching and evaluation. Her agentic AI MOOC, begun in fall 2024, has over 32,000 enrolled across three editions. Its competition, close to 1,000 teams last spring, now targets agent evaluation, which she says differs from model evaluation because the harness matters too, with over $1 million in prizes.
Hanselman and Mark's Ignite 2025 session, billed as teaching nothing, builds a deliberately useless chain from a 1975-era Altair to a 1,792-core cloud machine, and ends on one claim: the whole stack was vibe coded in a few days only because both hosts already understand the fundamentals underneath it.
One with the machine. Hanselman boots his kit-built Altair replica by keying a bootloader into its switches, runs an assembler Pong, and boots CP/M into Microsoft BASIC, which hangs. Mark notes that Azure servers still boot through UEFI, the same open-source firmware, being rewritten in Rust, used on Surface devices. Mark shows Compute! articles written at 16 in 1985 and a 1996 Sysinternals list whose one survivor is WinObj; the Sysinternals newsletter had 60,000 subscribers in 2006.
Zork in the cloud. Hanselman patches Zork to compile in Azure Cloud Shell, wraps it in a Docker container whose screen is fed to an LLM, and launches three and then 100 AI players from ACI standby pools, streaming scores over Event Hubs. He announces Zork I to III open-sourced live, with Xbox, Activision and Infocom, via a pull request to Historical Source.
Connecting the dots. Mark's Rust task manager on a 1,792-CPU Linux machine paints GIFs across its cores and runs an Altair emulator. Hanselman links the two: a webcam and NPU-run model read the physical Altair's LEDs at 28 frames a second, relayed by UDP, then WebSocket through ngrok, to Mark's emulator, "the least efficient way to do anything".
Vibe coding and fundamentals. Everything was vibe coded over four or five days of spare hours; open-sourcing Zork took longer because it involved humans. Mark argues reading code is easier than writing it, so experienced engineers get the boost and people who skip fundamentals do not. Hanselman frames modern Azure as declared desired behaviour, deployed with Bicep, and concedes the AI did nothing they could not have done themselves given time.