How I AIHow I run autonomous coding agents from my phone with OpenAI Symphony + Linear
CHAPTERS
- 0:00 – 1:10
Cold open: AI as leverage for small businesses (fish inventory + Pokémon cards)
Claire and Alessio jump straight into the most tangible upside of AI: helping small businesses automate real-world, manual workflows. Alessio shares a concrete example from his family’s fish-delivery business, then tees up a fun, high-stakes Pokémon card use case.
- •AI enables small business creation and quality-of-life improvements
- •Manual inventory tracking (pen-and-paper in a freezer) is ripe for automation
- •Wearables/vision systems (e.g., smart glasses) can capture real-world inventory data
- •Pokémon cards become an example of AI-driven “goal shopping” and pricing automation
- 1:10 – 2:41
Show framing + sponsor: why agent orchestration matters
Claire introduces the episode’s goal: moving beyond one-off prompting to managing longer-running, autonomous agent work. A sponsor segment (Firecrawl) positions web data access as a common bottleneck for agents.
- •Episode focus: OpenAI Symphony + Linear for autonomous engineering workflows
- •Problem statement: most people still operate as “human-in-the-loop” prompters
- •Need for agent access to reliable web data at scale (search/scrape/structured output)
- •Firecrawl pitched as infrastructure for agent-ready web data
- 2:41 – 4:31
From “agent prompter” to “agent manager”: cloud runtime and multi-channel control
Alessio explains how improved models made longer-running tasks viable, changing his mindset from prompting to managing. He argues that local, Kanban-style workflows break down when you need multiple iterations and easy intervention—so he moved agents into the cloud and added flexible control channels.
- •Early autonomous coding was a demo; newer models made longer tasks practical
- •Shift in role: prompter → manager (directing systems, not typing every step)
- •Local Kanban boards are hard to iterate on and intervene within
- •Move orchestration to a cloud VPS so agents run continuously
- •Manage agents via multiple channels: phone/text, Linear, shell
- 4:31 – 7:01
Live walkthrough: VPS + Symphony + Linear turning issues into PRs
Alessio demos his setup: a hosted machine with agents preconfigured, running Symphony to monitor Linear as the source of truth. Tasks move through a state machine (To Do → In Progress → Human Review → Rework → Done) with Codex producing plans, acceptance criteria, and pull requests.
- •Using a VPS (“agent + server”) with pre-logged-in coding agents
- •Symphony concept: loop that converts Linear issues into coding runs
- •Linear as the state machine and system of record for work
- •Codex workpad includes plan, acceptance criteria, and validations
- •Human review happens in GitHub PR comments; rework loop is triggered from Linear
- 7:01 – 7:32
Running tasks from your phone: quick triage, new issues, and progress dashboards
Claire and Alessio clarify the workflow as a practical way to manage engineering work anywhere, especially from mobile. Alessio shows creating a Linear task on the fly, then monitoring runs via a Symphony dashboard—without reading every trace turn-by-turn.
- •Create tasks quickly (even mid-day) and move them to “To Do” to trigger agents
- •Phone-based management: adjust priorities and capture feedback anywhere
- •Dashboard view for concurrent runs across projects
- •Human review step relies on PR previews (e.g., Vercel) and comments
- •Goal: glanceable status rather than micromanaging agent traces
- 7:32 – 10:06
Cost visibility: token ledgers, estimating effort, and pricing software work
Alessio highlights a less-discussed challenge: understanding the cost of agent-written software. By tracking token usage per task, he can identify which work is unexpectedly expensive and improve specs, checks, and tooling to make future runs more efficient.
- •Token usage per task helps estimate build cost and ROI
- •Large variance in effort: small tasks vs. massive refactors/deploy fixes
- •Example of a high-token task tied to making an app deployable (storage/requests changes)
- •Ledger + history helps diagnose why tasks ballooned
- •Improving future efficiency via better descriptions, checks, and tools
- 10:06 – 13:16
Setting up Symphony in practice: reference implementation + adding better tools
Claire asks the practical setup question: what do you do with the open-source repo? Alessio explains he used the Elixir implementation and mainly customized workflow instructions and UI—then emphasizes that orchestration is only part of the battle; tools like visual testing help runs go longer without human intervention.
- •Used the Elixir Symphony reference implementation as the base
- •Key customization: workflow.md instructions and adding a UI layer
- •Default Symphony is a state monitor; token ledger/UI often need to be added
- •Kernel Labs work on tooling (e.g., Glimpse for screenshots, diffs, videos)
- •Core value shifts from orchestration to tool support for longer autonomous runs
- 13:16 – 18:04
Purging skills/markdown files: why “magic MD” can quietly break your agents
They discuss how small lines in skills/markdown files can strongly steer agent behavior—sometimes long after they stop being useful. Alessio advocates periodically pruning and diffing these files because models tend to add more rules rather than remove obsolete ones, creating confusion over time.
- •Over-reliance on a “magic skills file” is a common trap
- •Tiny instructions can permanently bias behavior (e.g., always using a worktree manager)
- •Models often add caveats instead of deleting old guidance, compounding complexity
- •Regularly review/diff/purge instruction files to keep behavior clean
- •Keep skills focused on constraints, commands, flags—not over-specifying decisions
- 18:04 – 19:10
Why Symphony helps: task history and context shaping (not new capabilities)
Claire asks if Symphony increases throughput or just feels nicer. Alessio argues the real win is having the complete history of a task—spec, plans, rework notes, and outcomes—in one searchable place, making it easier to shape context and improve future runs.
- •Primary benefit: full task history in one place (spec → workpads → rework)
- •Searchability and traceability beat scattered chat threads
- •Symphony doesn’t add new capabilities; it improves how you wield existing agents
- •Context shaping becomes the central skill for agent-driven development
- •Insights from failures inform workflow.md and future system prompts
- 19:10 – 24:16
Demo: Codex “goal shopping” for expensive Pokémon cards (PSA certs + eBay hunting)
Alessio demonstrates using Codex beyond coding: gathering PSA certificate numbers and scanning marketplaces to find underpriced high-value cards. He explains how skills encode batching and grading rules, and why automation matters most when real-time human pricing is the bottleneck.
- •Use case 1: collect PSA certificate numbers by browsing and extracting from images
- •Use case 2: hunt underpriced cards on eBay from a target list
- •Skills define batching limits to reduce detection/capture risk (e.g., 5 per batch)
- •Encode grading equivalencies (PSA vs BGS/CGC) to normalize comparisons
- •Operational payoff: reduce manual lookup time and improve trade-show pricing speed
- 24:16 – 28:22
AI for the physical world: heterogeneous data, books cataloging, and fish freezer inventory
They zoom out to the broader thesis: LLMs unlock automation in messy, heterogeneous, real-world environments where traditional software struggled. Claire shares a personal example of cataloging household books with vision AI, while Alessio returns to the fish-freezer inventory story and the leverage AI gives small operators.
- •LLMs handle heterogeneous, real-world data better than rigid classification pipelines
- •Claire’s example: photographing piles of books to catalog, categorize, locate, dedupe
- •AI enables “intersecting the human world” more efficiently than before
- •Small businesses can gain disproportionate leverage without massive economies of scale
- •Examples extend to other niches like vintage clothing and physical resale markets
- 28:22 – 35:54
Lightning round: AI for personal finance, book recommendations, and debugging prompts
In rapid-fire Q&A, Alessio describes using AI as a “safety net” for finances and inbox triage to reduce stress. He recommends books (The Monk and the Riddle; Dante’s Divine Comedy), shares an AS Roma aside, and offers tactics for when models go off the rails—switch providers, restart, decompose tasks, and speak longer prompts.
- •Personal finance as context offloading (connectors + planning after selling a house)
- •Inbox monitoring with AI to reduce anxiety about missing important messages
- •Book recs: The Monk and the Riddle; The Divine Comedy as a reminder of human capability
- •Prompt recovery tactics: try another model, restart conversation, break into smaller pieces
- •Use speech-to-text (“yappers API”) to add missing context when stuck
