Syntax - Tasty Web Development Treats

Host Scott Tolinski, Wes BosOfficial Site ↗Technology & AI

Podcast Articles

5 articles

Oct 212026

WTF Is a Software Factory?

On Syntax, Swamp Club CEO Adam Jacob defines a software factory — the SDLC loop handed to agents — and shows the mechanics: intent compiled into deterministic automation, black-box tests as the safety rail, the slop-factory exit being more structure, and organizations as the unsolved layer.

WTF is a Software Factory?2026-10-21

Oct 162026

What Is a Durable Agent, and Why Does Pi Durable Make It Easy?

On Syntax, Scott Tolinski defines a durable agent — crash-surviving, resumable, never repeating a side effect — and shows how Pi Durable delivers it: persist every step, declare which tools can rerun, and any client steers the same mid-flight agent. The demo closes Sentry errors into merged fixes automatically.

You need to check out Pi Durable2026-10-16

Oct 142026

What Happens When an AI Team Clean-Room Ports Photoshop in Two Weeks?

On Syntax, a clean-room reimplementation with a two-week commit history opens real layered Photoshop files nearly perfectly and faster than Photoshop. The hosts' read: the gap is interaction polish, platform gatekeeping is returning, and two moats remain — UI quality and caring past two days.

Adobe has a big problem2026-10-14

Oct 72026

What Does Sustainable Work With Coding Agents Look Like?

On Syntax, the hosts put numbers on healthy AI usage — most employers cover $200–$500 a month, $200 subscriptions beat enterprise token billing, and Wes metered $1,100 of weekly tokens on his — then add the guardrails, the wait-time discipline, and the honest answer to lost motivation.

Who maxes out 5 AI subscriptions?2026-10-07

Sep 302026

Why Build Desktop Apps with GPUI Instead of Electron?

Scott Tolinski's case on Syntax: for small personal desktop software, a shipped Chromium costs more than it buys. GPUI, the Rust UI framework behind Zed, keeps a React-shaped API in one native program, updates utilities in megabytes via GPUI Kit, and accepts non-native UI, a WASM-only web target, and a young ecosystem as the trade.

I’m Using GPUI For Everything2026-09-30

Episodes

5 episodes · newest first

WTF is a Software Factory?

An interview with Adam Jacob, CEO of Swamp Club, on software factories. The product thesis: turn natural-language intent into deterministic modular automation — typed components, wired workflows, stored queryable data — so behavior runs identically without burning frontier-intelligence tokens, model swaps become one-component refactors, and the loop inverts: a deterministic system that calls out to intelligence when it needs it. The definition: a software factory hands as much of the SDLC loop as possible — ultimately everything but inputs, outputs, and some middle spots — to agents, keeping the system stable, architecture-aligned, and non-regressing; no two factories are the same, which is why the term confuses. The slop-factory objection is conceded for unchanged SDLCs and answered with more structure, not less. The organizational layer is the unsolved part: a trustworthy factory breaks control points, engineers ship without permission, and product people must pivot from directing to reviewing outcomes. On jobs, automation history says demand caps, and no cap has been found for software; LinkedIn could prototype an operating system in a week — but the real opportunity is not faster copies (the vibe-coded Adobe suite has yet to be made better) and factories as a creative outlet. Engineering guidance: black-box tests first (they make refactoring and therefore the factory safe), integration tests stay, unit tests are an open question (ThoughtWorks found agents worse with TDD; strong types absorb the role), and the stance is fix-the-factory, not blame-the-robots — build the machine that builds the thing. Skills are scoped to judgment, taste, and reasoning as measurable pieces, exemplified by an adversarial skill holding a 100 percent Lighthouse score.57:34 · 2026-10-21

You need to check out Pi Durable

A solo deep-dive in which Scott Tolinski argues that agents which run long, start themselves, and perform non-repeatable side effects must be durable — resumable, crash-surviving, and exactly aware of their current step — and that Pi Durable, a library from the team behind the Pi agent harness, delivers that durability while letting him delete roughly 8,000 lines of custom plumbing. The mechanism: persist everything as it goes (messages, tool calls, pending waits), declare per tool whether a rerun is safe, and let a fresh process open the storage and continue. Because state lives in one store, every screen becomes a client of the same agent, and multiplayer, steering, and forking arrive for free; chat-history resume fails because execution state is more than text. The demo is his self-healing pipeline: Sentry errors trigger a webhook through a Cloudflare tunnel, Sentry's root-cause analysis feeds the agent, which fixes, tests, opens, and (for personal software) merges a pull request, then resolves the issue in both systems with a full audit trail — and he can question the same agent afterwards rather than starting fresh. The stack is not Cloudflare-locked: it runs in a plain browser on IndexedDB, on his Mac mini with Node and SQLite, in durable objects, or on Deno's equivalent, with any model provider — and the Pi author runs a multiplayer agent app entirely on an Android phone. He closes by telling agent builders to make their agents durable and to point an agent at the examples folder rather than the README.15:16 · 2026-10-16

Adobe has a big problem

A two-week-old clean-room reimplementation of most of the Adobe suite triggers the episode. Scott — a 25-year Photoshop user who has disliked Adobe publicly since 2017 and pays $80 a month only because nothing else comes close — tests the port on his real files and reports that layered filter stacks, blend modes, masks, and text come through nearly perfectly, faster than Photoshop, with the UI built in Rust on its own crate. Clean-room means one agent documents the application and a separate implementation agent, which never touched the original, writes the code; whether that was truly followed is unverified, but thousands of tests and fixture files exist. The hosts place the event in the industry moment: four months after 'where are all the vibe-coded Photoshops,' UI interaction remains AI-generated software's weakest point (collapse behaviors, control-click masking, drag-and-drop), and a two-gigabyte seven-artboard file crashes the app. The Figma MCP controversy runs alongside — Figma gatekeeps tool approval while platforms from Amazon to Twitter wall agents off, echoing the API wars — and Dylan Field's clapback at Anthropic lands because Anthropic too restricts where subscriptions may run. The conclusions: the Photoshop replacement will not be a free clone but a generational shift, as Figma was for design; and two moats remain for creative software — genuinely good UI interaction, and someone who cares past two days — illustrated by the audio crackles and dropped frames that full-time Adobe employees exist to chase, and by DaVinci Resolve's cadence of useful releases as the model winner.35:08 · 2026-10-14

Who maxes out 5 AI subscriptions?

A potluck episode of listener questions. The through-line is the working conditions of AI-era development: what self-promotion looks like after blogs (opinions, and authenticity as the new gate — AI-fakeable output is discounted while traceable human work stands out), what to do while agents run (document UI problems in detail rather than idle; tighter loops beat long turns), what employee AI budgets actually look like ($200–$500 a month for most, enterprise token billing a worse deal, restraint a skill), and how transactional email should be built (standard APIs or SMTP over proprietary ones, because deliverability is fragile). On agent control, Scott lays out deterministic guardrails — harness hooks that block an rm, deny lists, linters, frame-rate tests, routing automations like his Jellyfin status check, agents.md rules, container isolation — plus Wes's escape-key habit, and the steering comparison: stop by default, let Claude Code pick up mid-run, Codex's queue-next-turn is the current best, OpenCode has none. Adoption advice for an engineering lead: skip the one-prompt stunts; use walkthroughs, a Sentry-style internal Slack channel, and screen recordings. On agent UIs, chat-shaped super-apps (Codex-in-ChatGPT, Grokbot, Muse) are consolidating while custom builds break weekly. The most personal exchange confronts lost motivation: AI coding feels like Game Genie cheats, and Scott's recovery is moving joy up a layer — strategy, refinement, and improving one's own process and harness, so code becomes the result of process improvement. The closing architecture question gets a middle-path verdict — custom tooling around a harness yes, the harness itself no — under a shelf-life warning: much of what they learned in eight months is already obsolete, so audit which installed pieces still earn their token churn.52:19 · 2026-10-07

I’m Using GPUI For Everything

In this solo-topic episode, Scott Tolinski walks Wes Bos through GPUI, the Zed team's GPU-accelerated UI framework for Rust desktop applications, and argues it has replaced Electron and Tauri in his own workflow. The framing is a web developer's tour: GPUI keeps a React-shaped mental model — components, props, state, a render function, and an explicit notify — while styling becomes chained inline methods that read like Tailwind. A live doc check finds flexbox but no CSS grid, and the GPUI Kit component library is presented as the practical unlock, with its data table and virtualization called out. The middle of the episode handles community friction: the GPUI CE fork exists because contributors feel the Zed team prioritizes its own needs, and a maintainer quote explains why GPUI Kit will not support the fork. Scott demonstrates the small personal utilities he has already shipped with GPUI — a multi-machine project monitor, a Hazel-style file automator, a window-placement tool — and grounds the whole pitch in size economics: DaisyDisk updates at eight megabytes where an Electron counterpart would ship roughly 267 MB of Chromium. The downsides are stated plainly: nothing is native UI, the web target is WASM rather than the DOM, the ecosystem is young, the platform is desktop-only in practice, and testing requires computer-use tooling, which he addresses with his own accessibility-tree-driven Jev test project. His verdict: not for mobile or web, excellent for small native desktop software, with AI agents writing the Rust competently.32:44 · 2026-09-30