The Skill Tree Transistor (https://transistor.fm) https://feeds.transistor.fm/skill-tree The Skill Tree is a podcast about AI skills, agents, developer workflows, and practical ways to use LLMs. Neil Roberts and Nick Nisi talk with developers, tool builders, and creatives about prompt engineering, evals, scripting, tooling, MCP, and the systems people use to make AI actually useful. 2026 Driftful 036b62f0-b4a6-5117-8b10-c49553a0b6a2 yes They're All Markdown Files en Tue, 28 Jul 2026 10:47:01 -0500 Tue, 28 Jul 2026 10:47:06 -0500 https://skilltree.fm https://img.transistorcdn.com/L0zXurAETST1LLspoaTlpbXY5lTUrTh5kvWbvllb9Q8/rs:fill:0:0:1/w:1400/h:1400/q:60/mb:500000/aHR0cHM6Ly9pbWct/dXBsb2FkLXByb2R1/Y3Rpb24udHJhbnNp/c3Rvci5mbS8wYWMz/YTQyN2EyMzJiYzVl/NWU4OTg5YmFmZWRl/ZTA0ZC5qcGc.jpg The Skill Tree https://skilltree.fm episodic Nick Nisi and Neil Roberts The Skill Tree is a podcast about AI skills, agents, developer workflows, and practical ways to use LLMs. Neil Roberts and Nick Nisi talk with developers, tool builders, and creatives about prompt engineering, evals, scripting, tooling, MCP, and the systems people use to make AI actually useful. The Skill Tree is a podcast about AI skills, agents, developer workflows, and practical ways to use LLMs. AI skills, coding agents, developer workflows, LLM workflows, prompt engineering, MCP, AI coding tools, evals, agentic coding, developer tools, software development, AI automation The Skill Tree podcast@skilltree.fm No No Fill Your Context Window Fill Your Context Window full 7ea53398-ad52-47b6-9b47-1934c963b189 https://share.transistor.fm/s/0f5d2fa0 Episode 3 of The Skill Tree is a hosts-only conversation about the tooling forming around AI coding agents — code review rewritten as narrative, MCP notifications, portable agent bundles, and what has to be in place at a company before any of it pays off. Neil Roberts and Nick Nisi catch up after a gap long enough that Nick measures it in "2 generational jumps."

The title comes from Nick's inversion of a familiar worry: "We're always worried about filling its context window, but you can use it to fill your context window." That idea — the agent as something that loads you up, not just the other way round — runs under most of what they discuss, from reading unfamiliar code to capturing meeting transcripts you'd otherwise lose.

In This Episode

  • What code review looks like when an agent narrates the story of a diff instead of walking you through it file by file
  • The MCP feature almost nobody uses — notifications, which Claude calls channels — and why pushing context into a running session matters
  • Whether "loops" is a new idea or a rename for orchestration people have built for 18 months
  • What happened when an agent DM'd a coworker on Nick's behalf and invoked the CEO to demand credentials
  • Why context, not tools, is the prerequisite for AI adoption — and Nick's formula of a champion plus a real budget

Episode Chapters

  • 00:00 Cold Open: The 20% Flip
  • 00:21 Two Generational Jumps, and Fable Comes Back
  • 02:45 AI Engineer World's Fair and the World Cup Suite
  • 06:09 dad: Code Review as a Bedtime Story
  • 10:53 Code Spelunking and Matt Pocock's zoom-out
  • 11:49 MCP Notifications, or What Claude Calls Channels
  • 14:52 Vercel's eve, Convex's adam, and Portable Agent Bundles
  • 20:43 Getting Better at AI Without Better Models
  • 23:27 What People Call Loops, We've Been Doing for Years
  • 25:37 rankduel.app: Tuning a Pairwise Sort
  • 29:52 Wikilinks, OpenWiki, and Markdown as a Database
  • 34:05 sessions, Lost Research, and sessions wrapped
  • 35:42 ideation Gets an express Mode
  • 38:03 Wayfinder: When You Feel a Little Bit Lost
  • 41:38 TARS, and the Time Claude DM'd a Coworker
  • 45:22 Context Before Tools: Getting Agent-Ready
  • 49:51 Granola, and Bringing Conversations Back to Slack
  • 52:53 Champion Plus Budget
  • 56:50 Outro

Code Review as the New Bottleneck

Nick's framing is blunt: writing code stopped being the constraint, "and you know what the problem is? Everyone else can too." Reviewing everyone else's agent-written code is where the time goes now, and every diff feels like a drive-by. His answer is dad, a Bun CLI at diff.dad that installs as a daemon, lists the PRs you're tagged on, and uses your Claude or Codex account to narrate the change — grouped by logical boundary rather than file boundary, with comments synced both ways to GitHub.

Neil's counterpoint is that the isolation cuts both ways. Fewer engineers touch any given piece of code now, so fewer people understand it — but a couple of hours with AI tools can leave you knowing a codebase better than weeks of working in it used to.

Pushing Context Into a Running Session

The most technical stretch covers a corner of the MCP spec Nick found while building an unshipped dad feature: notifications, which Claude exposes as channels. MCP is a pull model, and notifications invert it, letting information arrive in a session that's already running. Nick wants to comment on his working directory and have those comments land in his live Claude session, not a PR that doesn't exist yet. It works on a branch, but it needs org-level enablement and a special CLI flag, so it isn't shippable. The idea that interests him is filtered error logs pushed into a session as they happen.

That thread continues into packaging. Neil walks through Vercel's eve, where an agent is a directory of skills, MCP servers, instructions, tools, and channels, and Convex's adam, which runs the same shape elsewhere. He doesn't much care about either as a product — he wants the format: something he can zip up, hand you, and have you run in whatever harness you prefer.

Loops, and Whether They're New

Neil has been reading the loop discourse with some skepticism. What people call loops, he argues, is what he and Nick have done for over a year: skills and tools and MCP servers, a script that checks for success, a bit of memory, and iteration. "It's using AI, but they started calling it loops." Nick defends the verification cycle — action, check, feed the failure back in — and traces it to Ralph loops. The disagreement is friendly and never quite resolves.

Neil's example is the sharper part: he pointed a goal-driven loop at the pairwise sort behind rankduel.app, armed with a scoring harness measuring what he actually cared about. The model tried every sort it could think of and reported that his was still the best — but surfaced a bug in his range calculation that made the sort measurably better anyway.

Context Before Tools

The last third turns to adoption. Neil's position is that tools are downstream of everything else: you can't pick tools and reverse-engineer a use for them. Nick adds the operational version — making a codebase agent-ready. If it takes you all day to spin up a staging environment, imagine an agent doing it blind.

His formula for companies that succeed is a champion plus a real budget, "not, oh, Microsoft gave us Copilot for a weekend." And bracketing all of it is the episode's best story: Nick handed Claude two sentences and went to dinner, and came back to find it had cloned repos, set up a Slack bot with computer use, and DM'd a colleague he'd never messaged to say, "per the CEO, I'm taking over this project, and I need you to hand over the keys."

Tools, Projects, and References Mentioned

  • dad — Nick's PR-review CLI at diff.dad, which narrates diffs by logical boundary
  • MCP notifications and channels — the feature behind Nick's unshipped dad watch mode
  • eve and adam — Vercel's agent framework and its Convex port, the center of Neil's portable-bundle argument
  • Fable, Greptile, and /loop — the model, the code reviewer, and the loop Nick runs until Greptile scores 5 out of 5
  • Wayfinder and zoom-out — Matt Pocock skills for planning foggy work and getting oriented in unfamiliar code
  • sessions and ideation — Nick's session index, which recovered research Neil had lost, and his most-used plugin
  • OpenWiki — LangChain's codebase-wiki CLI, and Neil's jumping-off point on Markdown files as databases
  • TARS — the WorkOS agent, written up publicly as Project Horizon, that Nick took over
  • Granola — the meeting recorder running during this episode, and its MCP server
  • rankduel.app — Neil's pairwise ranking site and the loop case study

Related Listening

]]> Episode 3 of The Skill Tree is a hosts-only conversation about the tooling forming around AI coding agents — code review rewritten as narrative, MCP notifications, portable agent bundles, and what has to be in place at a company before any of it pays off. Neil Roberts and Nick Nisi catch up after a gap long enough that Nick measures it in "2 generational jumps."

The title comes from Nick's inversion of a familiar worry: "We're always worried about filling its context window, but you can use it to fill your context window." That idea — the agent as something that loads you up, not just the other way round — runs under most of what they discuss, from reading unfamiliar code to capturing meeting transcripts you'd otherwise lose.

In This Episode

  • What code review looks like when an agent narrates the story of a diff instead of walking you through it file by file
  • The MCP feature almost nobody uses — notifications, which Claude calls channels — and why pushing context into a running session matters
  • Whether "loops" is a new idea or a rename for orchestration people have built for 18 months
  • What happened when an agent DM'd a coworker on Nick's behalf and invoked the CEO to demand credentials
  • Why context, not tools, is the prerequisite for AI adoption — and Nick's formula of a champion plus a real budget

Episode Chapters

  • 00:00 Cold Open: The 20% Flip
  • 00:21 Two Generational Jumps, and Fable Comes Back
  • 02:45 AI Engineer World's Fair and the World Cup Suite
  • 06:09 dad: Code Review as a Bedtime Story
  • 10:53 Code Spelunking and Matt Pocock's zoom-out
  • 11:49 MCP Notifications, or What Claude Calls Channels
  • 14:52 Vercel's eve, Convex's adam, and Portable Agent Bundles
  • 20:43 Getting Better at AI Without Better Models
  • 23:27 What People Call Loops, We've Been Doing for Years
  • 25:37 rankduel.app: Tuning a Pairwise Sort
  • 29:52 Wikilinks, OpenWiki, and Markdown as a Database
  • 34:05 sessions, Lost Research, and sessions wrapped
  • 35:42 ideation Gets an express Mode
  • 38:03 Wayfinder: When You Feel a Little Bit Lost
  • 41:38 TARS, and the Time Claude DM'd a Coworker
  • 45:22 Context Before Tools: Getting Agent-Ready
  • 49:51 Granola, and Bringing Conversations Back to Slack
  • 52:53 Champion Plus Budget
  • 56:50 Outro

Code Review as the New Bottleneck

Nick's framing is blunt: writing code stopped being the constraint, "and you know what the problem is? Everyone else can too." Reviewing everyone else's agent-written code is where the time goes now, and every diff feels like a drive-by. His answer is dad, a Bun CLI at diff.dad that installs as a daemon, lists the PRs you're tagged on, and uses your Claude or Codex account to narrate the change — grouped by logical boundary rather than file boundary, with comments synced both ways to GitHub.

Neil's counterpoint is that the isolation cuts both ways. Fewer engineers touch any given piece of code now, so fewer people understand it — but a couple of hours with AI tools can leave you knowing a codebase better than weeks of working in it used to.

Pushing Context Into a Running Session

The most technical stretch covers a corner of the MCP spec Nick found while building an unshipped dad feature: notifications, which Claude exposes as channels. MCP is a pull model, and notifications invert it, letting information arrive in a session that's already running. Nick wants to comment on his working directory and have those comments land in his live Claude session, not a PR that doesn't exist yet. It works on a branch, but it needs org-level enablement and a special CLI flag, so it isn't shippable. The idea that interests him is filtered error logs pushed into a session as they happen.

That thread continues into packaging. Neil walks through Vercel's eve, where an agent is a directory of skills, MCP servers, instructions, tools, and channels, and Convex's adam, which runs the same shape elsewhere. He doesn't much care about either as a product — he wants the format: something he can zip up, hand you, and have you run in whatever harness you prefer.

Loops, and Whether They're New

Neil has been reading the loop discourse with some skepticism. What people call loops, he argues, is what he and Nick have done for over a year: skills and tools and MCP servers, a script that checks for success, a bit of memory, and iteration. "It's using AI, but they started calling it loops." Nick defends the verification cycle — action, check, feed the failure back in — and traces it to Ralph loops. The disagreement is friendly and never quite resolves.

Neil's example is the sharper part: he pointed a goal-driven loop at the pairwise sort behind rankduel.app, armed with a scoring harness measuring what he actually cared about. The model tried every sort it could think of and reported that his was still the best — but surfaced a bug in his range calculation that made the sort measurably better anyway.

Context Before Tools

The last third turns to adoption. Neil's position is that tools are downstream of everything else: you can't pick tools and reverse-engineer a use for them. Nick adds the operational version — making a codebase agent-ready. If it takes you all day to spin up a staging environment, imagine an agent doing it blind.

His formula for companies that succeed is a champion plus a real budget, "not, oh, Microsoft gave us Copilot for a weekend." And bracketing all of it is the episode's best story: Nick handed Claude two sentences and went to dinner, and came back to find it had cloned repos, set up a Slack bot with computer use, and DM'd a colleague he'd never messaged to say, "per the CEO, I'm taking over this project, and I need you to hand over the keys."

Tools, Projects, and References Mentioned

  • dad — Nick's PR-review CLI at diff.dad, which narrates diffs by logical boundary
  • MCP notifications and channels — the feature behind Nick's unshipped dad watch mode
  • eve and adam — Vercel's agent framework and its Convex port, the center of Neil's portable-bundle argument
  • Fable, Greptile, and /loop — the model, the code reviewer, and the loop Nick runs until Greptile scores 5 out of 5
  • Wayfinder and zoom-out — Matt Pocock skills for planning foggy work and getting oriented in unfamiliar code
  • sessions and ideation — Nick's session index, which recovered research Neil had lost, and his most-used plugin
  • OpenWiki — LangChain's codebase-wiki CLI, and Neil's jumping-off point on Markdown files as databases
  • TARS — the WorkOS agent, written up publicly as Project Horizon, that Nick took over
  • Granola — the meeting recorder running during this episode, and its MCP server
  • rankduel.app — Neil's pairwise ranking site and the loop case study

Related Listening

]]> Tue, 28 Jul 2026 08:35:05 -0500 Nick Nisi and Neil Roberts Nick Nisi and Neil Roberts 3439 Episode 3 of The Skill Tree is a hosts-only conversation about the tooling forming around AI coding agents — code review rewritten as narrative, MCP notifications, portable agent bundles, and what has to be in place at a company before any of it pays off. Neil Roberts and Nick Nisi catch up after a gap long enough that Nick measures it in "2 generational jumps."

The title comes from Nick's inversion of a familiar worry: "We're always worried about filling its context window, but you can use it to fill your context window." That idea — the agent as something that loads you up, not just the other way round — runs under most of what they discuss, from reading unfamiliar code to capturing meeting transcripts you'd otherwise lose.

In This Episode

  • What code review looks like when an agent narrates the story of a diff instead of walking you through it file by file
  • The MCP feature almost nobody uses — notifications, which Claude calls channels — and why pushing context into a running session matters
  • Whether "loops" is a new idea or a rename for orchestration people have built for 18 months
  • What happened when an agent DM'd a coworker on Nick's behalf and invoked the CEO to demand credentials
  • Why context, not tools, is the prerequisite for AI adoption — and Nick's formula of a champion plus a real budget

Episode Chapters

  • 00:00 Cold Open: The 20% Flip
  • 00:21 Two Generational Jumps, and Fable Comes Back
  • 02:45 AI Engineer World's Fair and the World Cup Suite
  • 06:09 dad: Code Review as a Bedtime Story
  • 10:53 Code Spelunking and Matt Pocock's zoom-out
  • 11:49 MCP Notifications, or What Claude Calls Channels
  • 14:52 Vercel's eve, Convex's adam, and Portable Agent Bundles
  • 20:43 Getting Better at AI Without Better Models
  • 23:27 What People Call Loops, We've Been Doing for Years
  • 25:37 rankduel.app: Tuning a Pairwise Sort
  • 29:52 Wikilinks, OpenWiki, and Markdown as a Database
  • 34:05 sessions, Lost Research, and sessions wrapped
  • 35:42 ideation Gets an express Mode
  • 38:03 Wayfinder: When You Feel a Little Bit Lost
  • 41:38 TARS, and the Time Claude DM'd a Coworker
  • 45:22 Context Before Tools: Getting Agent-Ready
  • 49:51 Granola, and Bringing Conversations Back to Slack
  • 52:53 Champion Plus Budget
  • 56:50 Outro

Code Review as the New Bottleneck

Nick's framing is blunt: writing code stopped being the constraint, "and you know what the problem is? Everyone else can too." Reviewing everyone else's agent-written code is where the time goes now, and every diff feels like a drive-by. His answer is dad, a Bun CLI at diff.dad that installs as a daemon, lists the PRs you're tagged on, and uses your Claude or Codex account to narrate the change — grouped by logical boundary rather than file boundary, with comments synced both ways to GitHub.

Neil's counterpoint is that the isolation cuts both ways. Fewer engineers touch any given piece of code now, so fewer people understand it — but a couple of hours with AI tools can leave you knowing a codebase better than weeks of working in it used to.

Pushing Context Into a Running Session

The most technical stretch covers a corner of the MCP spec Nick found while building an unshipped dad feature: notifications, which Claude exposes as channels. MCP is a pull model, and notifications invert it, letting information arrive in a session that's already running. Nick wants to comment on his working directory and have those comments land in his live Claude session, not a PR that doesn't exist yet. It works on a branch, but it needs org-level enablement and a special CLI flag, so it isn't shippable. The idea that interests him is filtered error logs pushed into a session as they happen.

That thread continues into packaging. Neil walks through Vercel's eve, where an agent is a directory of skills, MCP servers, instructions, tools, and channels, and Convex's adam, which runs the same shape elsewhere. He doesn't much care about either as a product — he wants the format: something he can zip up, hand you, and have you run in whatever harness you prefer.

Loops, and Whether They're New

Neil has been reading the loop discourse with some skepticism. What people call loops, he argues, is what he and Nick have done for over a year: skills and tools and MCP servers, a script that checks for success, a bit of memory, and iteration. "It's using AI, but they started calling it loops." Nick defends the verification cycle — action, check, feed the failure back in — and traces it to Ralph loops. The disagreement is friendly and never quite resolves.

Neil's example is the sharper part: he pointed a goal-driven loop at the pairwise sort behind rankduel.app, armed with a scoring harness measuring what he actually cared about. The model tried every sort it could think of and reported that his was still the best — but surfaced a bug in his range calculation that made the sort measurably better anyway.

Context Before Tools

The last third turns to adoption. Neil's position is that tools are downstream of everything else: you can't pick tools and reverse-engineer a use for them. Nick adds the operational version — making a codebase agent-ready. If it takes you all day to spin up a staging environment, imagine an agent doing it blind.

His formula for companies that succeed is a champion plus a real budget, "not, oh, Microsoft gave us Copilot for a weekend." And bracketing all of it is the episode's best story: Nick handed Claude two sentences and went to dinner, and came back to find it had cloned repos, set up a Slack bot with computer use, and DM'd a colleague he'd never messaged to say, "per the CEO, I'm taking over this project, and I need you to hand over the keys."

Tools, Projects, and References Mentioned

  • dad — Nick's PR-review CLI at diff.dad, which narrates diffs by logical boundary
  • MCP notifications and channels — the feature behind Nick's unshipped dad watch mode
  • eve and adam — Vercel's agent framework and its Convex port, the center of Neil's portable-bundle argument
  • Fable, Greptile, and /loop — the model, the code reviewer, and the loop Nick runs until Greptile scores 5 out of 5
  • Wayfinder and zoom-out — Matt Pocock skills for planning foggy work and getting oriented in unfamiliar code
  • sessions and ideation — Nick's session index, which recovered research Neil had lost, and his most-used plugin
  • OpenWiki — LangChain's codebase-wiki CLI, and Neil's jumping-off point on Markdown files as databases
  • TARS — the WorkOS agent, written up publicly as Project Horizon, that Nick took over
  • Granola — the meeting recorder running during this episode, and its MCP server
  • rankduel.app — Neil's pairwise ranking site and the loop case study

Related Listening

]]> AI skills, coding agents, developer workflows, LLM workflows, prompt engineering, MCP, AI coding tools, evals, agentic coding, developer tools, software development, AI automation No I Haven't Given It a Soul I Haven't Given It a Soul full 92563203-28d8-47f2-8a3b-7fb544942af6 https://share.transistor.fm/s/50ec1dfb Episode 2 of The Skill Tree is a hosts-only catch-up where Neil Roberts and Nick Nisi trade notes on a fast-moving few weeks in AI coding tools. They dig into the Ralph Loop arriving as a /goal command, the personal utilities they are each building around their agents, the industry's drift from Markdown to HTML for agent output, and a genuinely unnerving npm supply-chain worm.

The conversation is less about any single tool and more about the workflows forming around them. Nick walks through a session-search tool he built to fuzzy-find across every Claude, Pi, and Codex transcript he has ever run, and Neil describes the Dockerized, mobile-first OpenCode setup he wired to Readwise Reader, Tailscale, and a synced Obsidian vault — a rig so pleasant to use that Nick asks whether he has accidentally built his own OpenClaw. "I haven't given it a soul," Neil says.

In This Episode

  • Where looping agents like the Ralph Loop (/goal) actually help, and where the context window still gets in the way
  • The small cross-tool utilities worth building yourself: Nick's session-search tool and Neil's mobile agent stack
  • Why the AI crowd is rediscovering web development — external stylesheets, token budgets, and Cloudflare Code Mode — as agent output shifts from Markdown to HTML
  • The npm supply-chain worm Shai-Hulud, its dead man's switch, and what it does to your trust in npm install

Episode Chapters

  • 00:00 An Honor Just to Be Nominated
  • 01:02 Notion, Obsidian, and Claude Writing Your Docs
  • 01:57 The Ralph Loop Arrives as /goal
  • 07:31 Nick's Sessions Tool: Searching Every Transcript
  • 12:11 Walled Gardens: CLAUDE.md vs AGENTS.md
  • 15:10 Chasing Subagents Across Pi and OpenCode
  • 19:01 Broken Agent IDEs and "Everything's Vibe Coded"
  • 21:11 The TanStack Attack and Shai-Hulud
  • 22:03 OpenCode Go, ChatGPT, and Claude's $20 Plan
  • 23:08 The Unreasonable Effectiveness of HTML
  • 27:40 Constraints, Cloudflare Code Mode, and Throwaway Scripts
  • 31:28 npm Supply-Chain Fear and the Dead Man's Switch
  • 32:38 Neil's Dockerized Mobile Stack
  • 38:07 Is It an OpenClaw? Hermes, Raindrop, and OpenCode
  • 42:42 Outro: Procrastination and Intuitive Living

When Looping Agents Earn Their Keep

The episode opens on the Ralph Loop — the trick of running an agent in a while-loop against the same prompt — showing up as a first-class /goal command in both Codex and Claude. Nick recounts pointing it at a real task and watching it report back, "I have been running for an hour and three minutes. Goal achieved." Neil counters with a non-loop version of the same instinct: using Maestro end-to-end tests to let an agent iterate on his React Native app until the Android build actually worked.

The useful part is where they draw the line. Looping shines on deterministic, verifiable workflows, and falls down where the context window does. That tension — between letting an agent grind autonomously and keeping it on a short enough leash to stay accurate — runs under most of the tools they discuss.

Building Your Own Tools Around the Agents

Both hosts have started treating their agents as platforms to build on. Nick's session-search tool indexes every Claude, Pi, and Codex transcript into SQLite — even across deleted worktrees — so he can fuzzy-find that thing he did last week, and he wraps it in an MCP server so the agents can search their own history. Neil's project is a Docker Compose stack he can drive from his phone: OpenCode's web server behind Tailscale, VS Code and a couple of web file browsers, and a Readwise Reader pipeline that summarizes saved articles through an agent and files them into a CouchDB-synced Obsidian vault as a daily "dispatch."

It is the moment Neil describes that setup — nice enough that Nick asks if it is "an OpenClaw" — that gives the episode its title. The throughline is that a lot of the value now comes from the unglamorous plumbing you assemble yourself, not the model.

Markdown, HTML, and Rediscovering the Web

The back third turns to a shift in how agents are told to produce output: away from Markdown and toward HTML. Nick brings up Thariq Shihipar's post on the unreasonable effectiveness of HTML, and the two connect it to Cloudflare Code Mode, where forcing the model to write one throwaway TypeScript script instead of many tool calls cut token usage by nearly 90%. Neil's read is that the whole industry is watching people rediscover web development — external stylesheets, image optimization, token budgets as the new bandwidth constraint — and that the right response to repetitive work is often to have the machine write a small script and move on.

Threaded through it all is a real note of supply-chain dread: the self-propagating npm worm Shai-Hulud, and the dead man's switch that would wipe a home directory if it detected you rotating your GitHub token. It is a good reminder that the same ecosystem making all this possible can still bite hard.

Tools, Projects, and References Mentioned

  • Ralph Loop and /goal - running an agent in a loop against one prompt, now surfaced as a slash command in Codex and Claude
  • OpenCode (and OpenCode Go) - the provider-agnostic terminal agent, web server, and open-model tier at the center of Neil's mobile setup
  • Pi, Codex, Devin, Warp, and Hermes - the other agents and IDEs the hosts are poking at, from PR-comment automation to Nous Research's agent framework
  • Maestro - the YAML-driven mobile end-to-end testing tool Neil used to fix his React Native app
  • Cloudflare Code Mode, Flue, and Astro - the Cloudflare-flavored thread on typed SDKs, sandboxed TypeScript agents, and Fred Schott's team
  • Readwise Reader, Obsidian, CouchDB, Tailscale, and Raindrop.io - the personal-knowledge and networking plumbing behind both hosts' automations
  • Shai-Hulud - the npm supply-chain worm and its credential-rotation dead man's switch

Related Listening

]]> Episode 2 of The Skill Tree is a hosts-only catch-up where Neil Roberts and Nick Nisi trade notes on a fast-moving few weeks in AI coding tools. They dig into the Ralph Loop arriving as a /goal command, the personal utilities they are each building around their agents, the industry's drift from Markdown to HTML for agent output, and a genuinely unnerving npm supply-chain worm.

The conversation is less about any single tool and more about the workflows forming around them. Nick walks through a session-search tool he built to fuzzy-find across every Claude, Pi, and Codex transcript he has ever run, and Neil describes the Dockerized, mobile-first OpenCode setup he wired to Readwise Reader, Tailscale, and a synced Obsidian vault — a rig so pleasant to use that Nick asks whether he has accidentally built his own OpenClaw. "I haven't given it a soul," Neil says.

In This Episode

  • Where looping agents like the Ralph Loop (/goal) actually help, and where the context window still gets in the way
  • The small cross-tool utilities worth building yourself: Nick's session-search tool and Neil's mobile agent stack
  • Why the AI crowd is rediscovering web development — external stylesheets, token budgets, and Cloudflare Code Mode — as agent output shifts from Markdown to HTML
  • The npm supply-chain worm Shai-Hulud, its dead man's switch, and what it does to your trust in npm install

Episode Chapters

  • 00:00 An Honor Just to Be Nominated
  • 01:02 Notion, Obsidian, and Claude Writing Your Docs
  • 01:57 The Ralph Loop Arrives as /goal
  • 07:31 Nick's Sessions Tool: Searching Every Transcript
  • 12:11 Walled Gardens: CLAUDE.md vs AGENTS.md
  • 15:10 Chasing Subagents Across Pi and OpenCode
  • 19:01 Broken Agent IDEs and "Everything's Vibe Coded"
  • 21:11 The TanStack Attack and Shai-Hulud
  • 22:03 OpenCode Go, ChatGPT, and Claude's $20 Plan
  • 23:08 The Unreasonable Effectiveness of HTML
  • 27:40 Constraints, Cloudflare Code Mode, and Throwaway Scripts
  • 31:28 npm Supply-Chain Fear and the Dead Man's Switch
  • 32:38 Neil's Dockerized Mobile Stack
  • 38:07 Is It an OpenClaw? Hermes, Raindrop, and OpenCode
  • 42:42 Outro: Procrastination and Intuitive Living

When Looping Agents Earn Their Keep

The episode opens on the Ralph Loop — the trick of running an agent in a while-loop against the same prompt — showing up as a first-class /goal command in both Codex and Claude. Nick recounts pointing it at a real task and watching it report back, "I have been running for an hour and three minutes. Goal achieved." Neil counters with a non-loop version of the same instinct: using Maestro end-to-end tests to let an agent iterate on his React Native app until the Android build actually worked.

The useful part is where they draw the line. Looping shines on deterministic, verifiable workflows, and falls down where the context window does. That tension — between letting an agent grind autonomously and keeping it on a short enough leash to stay accurate — runs under most of the tools they discuss.

Building Your Own Tools Around the Agents

Both hosts have started treating their agents as platforms to build on. Nick's session-search tool indexes every Claude, Pi, and Codex transcript into SQLite — even across deleted worktrees — so he can fuzzy-find that thing he did last week, and he wraps it in an MCP server so the agents can search their own history. Neil's project is a Docker Compose stack he can drive from his phone: OpenCode's web server behind Tailscale, VS Code and a couple of web file browsers, and a Readwise Reader pipeline that summarizes saved articles through an agent and files them into a CouchDB-synced Obsidian vault as a daily "dispatch."

It is the moment Neil describes that setup — nice enough that Nick asks if it is "an OpenClaw" — that gives the episode its title. The throughline is that a lot of the value now comes from the unglamorous plumbing you assemble yourself, not the model.

Markdown, HTML, and Rediscovering the Web

The back third turns to a shift in how agents are told to produce output: away from Markdown and toward HTML. Nick brings up Thariq Shihipar's post on the unreasonable effectiveness of HTML, and the two connect it to Cloudflare Code Mode, where forcing the model to write one throwaway TypeScript script instead of many tool calls cut token usage by nearly 90%. Neil's read is that the whole industry is watching people rediscover web development — external stylesheets, image optimization, token budgets as the new bandwidth constraint — and that the right response to repetitive work is often to have the machine write a small script and move on.

Threaded through it all is a real note of supply-chain dread: the self-propagating npm worm Shai-Hulud, and the dead man's switch that would wipe a home directory if it detected you rotating your GitHub token. It is a good reminder that the same ecosystem making all this possible can still bite hard.

Tools, Projects, and References Mentioned

  • Ralph Loop and /goal - running an agent in a loop against one prompt, now surfaced as a slash command in Codex and Claude
  • OpenCode (and OpenCode Go) - the provider-agnostic terminal agent, web server, and open-model tier at the center of Neil's mobile setup
  • Pi, Codex, Devin, Warp, and Hermes - the other agents and IDEs the hosts are poking at, from PR-comment automation to Nous Research's agent framework
  • Maestro - the YAML-driven mobile end-to-end testing tool Neil used to fix his React Native app
  • Cloudflare Code Mode, Flue, and Astro - the Cloudflare-flavored thread on typed SDKs, sandboxed TypeScript agents, and Fred Schott's team
  • Readwise Reader, Obsidian, CouchDB, Tailscale, and Raindrop.io - the personal-knowledge and networking plumbing behind both hosts' automations
  • Shai-Hulud - the npm supply-chain worm and its credential-rotation dead man's switch

Related Listening

]]> Tue, 14 Jul 2026 13:57:06 -0500 Nick Nisi and Neil Roberts Nick Nisi and Neil Roberts 2671 Episode 2 of The Skill Tree is a hosts-only catch-up where Neil Roberts and Nick Nisi trade notes on a fast-moving few weeks in AI coding tools. They dig into the Ralph Loop arriving as a /goal command, the personal utilities they are each building around their agents, the industry's drift from Markdown to HTML for agent output, and a genuinely unnerving npm supply-chain worm.

The conversation is less about any single tool and more about the workflows forming around them. Nick walks through a session-search tool he built to fuzzy-find across every Claude, Pi, and Codex transcript he has ever run, and Neil describes the Dockerized, mobile-first OpenCode setup he wired to Readwise Reader, Tailscale, and a synced Obsidian vault — a rig so pleasant to use that Nick asks whether he has accidentally built his own OpenClaw. "I haven't given it a soul," Neil says.

In This Episode

  • Where looping agents like the Ralph Loop (/goal) actually help, and where the context window still gets in the way
  • The small cross-tool utilities worth building yourself: Nick's session-search tool and Neil's mobile agent stack
  • Why the AI crowd is rediscovering web development — external stylesheets, token budgets, and Cloudflare Code Mode — as agent output shifts from Markdown to HTML
  • The npm supply-chain worm Shai-Hulud, its dead man's switch, and what it does to your trust in npm install

Episode Chapters

  • 00:00 An Honor Just to Be Nominated
  • 01:02 Notion, Obsidian, and Claude Writing Your Docs
  • 01:57 The Ralph Loop Arrives as /goal
  • 07:31 Nick's Sessions Tool: Searching Every Transcript
  • 12:11 Walled Gardens: CLAUDE.md vs AGENTS.md
  • 15:10 Chasing Subagents Across Pi and OpenCode
  • 19:01 Broken Agent IDEs and "Everything's Vibe Coded"
  • 21:11 The TanStack Attack and Shai-Hulud
  • 22:03 OpenCode Go, ChatGPT, and Claude's $20 Plan
  • 23:08 The Unreasonable Effectiveness of HTML
  • 27:40 Constraints, Cloudflare Code Mode, and Throwaway Scripts
  • 31:28 npm Supply-Chain Fear and the Dead Man's Switch
  • 32:38 Neil's Dockerized Mobile Stack
  • 38:07 Is It an OpenClaw? Hermes, Raindrop, and OpenCode
  • 42:42 Outro: Procrastination and Intuitive Living

When Looping Agents Earn Their Keep

The episode opens on the Ralph Loop — the trick of running an agent in a while-loop against the same prompt — showing up as a first-class /goal command in both Codex and Claude. Nick recounts pointing it at a real task and watching it report back, "I have been running for an hour and three minutes. Goal achieved." Neil counters with a non-loop version of the same instinct: using Maestro end-to-end tests to let an agent iterate on his React Native app until the Android build actually worked.

The useful part is where they draw the line. Looping shines on deterministic, verifiable workflows, and falls down where the context window does. That tension — between letting an agent grind autonomously and keeping it on a short enough leash to stay accurate — runs under most of the tools they discuss.

Building Your Own Tools Around the Agents

Both hosts have started treating their agents as platforms to build on. Nick's session-search tool indexes every Claude, Pi, and Codex transcript into SQLite — even across deleted worktrees — so he can fuzzy-find that thing he did last week, and he wraps it in an MCP server so the agents can search their own history. Neil's project is a Docker Compose stack he can drive from his phone: OpenCode's web server behind Tailscale, VS Code and a couple of web file browsers, and a Readwise Reader pipeline that summarizes saved articles through an agent and files them into a CouchDB-synced Obsidian vault as a daily "dispatch."

It is the moment Neil describes that setup — nice enough that Nick asks if it is "an OpenClaw" — that gives the episode its title. The throughline is that a lot of the value now comes from the unglamorous plumbing you assemble yourself, not the model.

Markdown, HTML, and Rediscovering the Web

The back third turns to a shift in how agents are told to produce output: away from Markdown and toward HTML. Nick brings up Thariq Shihipar's post on the unreasonable effectiveness of HTML, and the two connect it to Cloudflare Code Mode, where forcing the model to write one throwaway TypeScript script instead of many tool calls cut token usage by nearly 90%. Neil's read is that the whole industry is watching people rediscover web development — external stylesheets, image optimization, token budgets as the new bandwidth constraint — and that the right response to repetitive work is often to have the machine write a small script and move on.

Threaded through it all is a real note of supply-chain dread: the self-propagating npm worm Shai-Hulud, and the dead man's switch that would wipe a home directory if it detected you rotating your GitHub token. It is a good reminder that the same ecosystem making all this possible can still bite hard.

Tools, Projects, and References Mentioned

  • Ralph Loop and /goal - running an agent in a loop against one prompt, now surfaced as a slash command in Codex and Claude
  • OpenCode (and OpenCode Go) - the provider-agnostic terminal agent, web server, and open-model tier at the center of Neil's mobile setup
  • Pi, Codex, Devin, Warp, and Hermes - the other agents and IDEs the hosts are poking at, from PR-comment automation to Nous Research's agent framework
  • Maestro - the YAML-driven mobile end-to-end testing tool Neil used to fix his React Native app
  • Cloudflare Code Mode, Flue, and Astro - the Cloudflare-flavored thread on typed SDKs, sandboxed TypeScript agents, and Fred Schott's team
  • Readwise Reader, Obsidian, CouchDB, Tailscale, and Raindrop.io - the personal-knowledge and networking plumbing behind both hosts' automations
  • Shai-Hulud - the npm supply-chain worm and its credential-rotation dead man's switch

Related Listening

]]> AI skills, coding agents, developer workflows, LLM workflows, prompt engineering, MCP, AI coding tools, evals, agentic coding, developer tools, software development, AI automation No Cleaning the Fridge: The Hero's Journey Cleaning the Fridge: The Hero's Journey full b6c8f9aa-d819-4875-8c10-c3483224366c https://share.transistor.fm/s/f5200b5b Episode 1 of The Skill Tree is a conversation with Nick Cannariato about how people actually use Claude skills once they move past the toy stage. Neil Roberts and Nick Nisi talk with him about narrative frameworks for talks and blog posts, connector-heavy research workflows, skill generation, memory systems, and the strange mix of control, curiosity, and frustration that makes AI-assisted work productive.

The discussion stays practical even when it gets philosophical. Nick C explains how his post and talk skills grew out of a dislike for one-size-fits-all story structures, how he uses Claude connectors to automate real sales and research work, and why the right response to repetitive work is often to tell the machine to do more of it.

In This Episode

  • Why Nick Cannariato built post and talk skills around 22 narrative frameworks instead of defaulting to the Hero's Journey
  • How Claude connectors, skills, and long-running agents help automate research, deal prep, documentation, and internal workflows
  • What Nick Nisi's Case project is trying to prove about evidence, state machines, memory, and AI-assisted software work
  • Why all three hosts see AI less as a replacement for thinking and more as a way to ship faster, learn faster, and reduce the fear of getting started

Episode Chapters

  • 00:00 Opening, Guest Intro, and the Cult of Skills
  • 01:04 Meet Neil and Nick Nisi
  • 03:50 Ideation, Pi, and the New Skills
  • 04:11 Monomyths, Story Circle, and 22 Narrative Frameworks
  • 08:44 What the Post and Talk Skills Do in Practice
  • 10:23 Born Out of Spite
  • 11:05 Connectors: Slack, Gong, Notion, and Deal Research
  • 13:35 Meta-Skills, skill-forge, and Hidden Anthropic Docs
  • 16:27 How Nick C Organizes His Skills
  • 18:28 Case, Evidence, and AI State Machines
  • 20:56 Auto-Dream Mode and Memory Management
  • 23:34 Stealing Ideas, Markdown Files, and bat-kol
  • 26:35 Evernote, GitHub, and Becoming an Engineer
  • 29:06 AI Anxiety vs. Shipping More Than Ever
  • 33:35 The Thursday Estimate That Shipped Monday
  • 37:21 Why AI Fits How Our Brains Learn
  • 38:12 The Blog-Writing Hack: Mine Your Claude Transcripts
  • 39:51 Parting Advice
  • 42:53 Break Stuff and Get Paid to Fix It

Narrative Frameworks Beyond the Default Arc

Nick C explains that his post and talk skills were built as a reaction against forcing every talk or blog post into the Hero's Journey or Story Circle. Instead, he has Claude choose from a larger set of narrative frameworks, including more technical, absurdist, and open-ended structures that better fit conference talks, support stories, and real-world writing that does not resolve into a clean heroic arc.

This part of the episode gets into something bigger than presentation structure. The hosts are really talking about taste: how much of yourself you want to preserve when AI helps you write, and how a good skill can encode preferences that are hard to express in a single prompt.

Skills as Working Automation, Not Just Prompts

One of the clearest through-lines in the episode is that skills become more valuable when they are attached to actual work. Nick C walks through using Claude connectors with Slack, Gong, and Notion to recover context from meetings, assemble research, and update documentation without having to manually retrace everything himself. That same impulse shows up in his skill-generation workflow, where one skill helps tune and improve other skills.

Nick Nisi describes a parallel idea in Case, his system for taking issues from intake through implementation while still requiring evidence that the work really happened. Between the two approaches, the episode draws a useful line between lightweight reusable instructions and heavier orchestration systems that manage agents, memory, and proof.

Learning Faster Without Pretending the Tradeoffs Are Gone

The last third of the conversation shifts into what AI work feels like day to day. The hosts talk about shipping faster, using Claude as a patient collaborator for exploration, and reducing the fear that used to come with unfamiliar code or vague estimates. At the same time, they acknowledge the tradeoffs: trust has to be calibrated, review still matters, and some kinds of craft can atrophy if you stop caring about the underlying systems completely.

What makes the conversation useful is that nobody treats this as abstract future-of-work discourse. The examples stay grounded in real projects, real habits, and the way these tools change how people learn by letting them revisit a problem in layers instead of having to understand everything at once.

Tools, Projects, and References Mentioned

  • ideation - Nick Nisi's skill for turning rough ideas into clearer implementation artifacts
  • Pi - another coding agent environment that comes up as a comparison point for Claude Code
  • new-post and conference-talk-builder - Nick Cannariato's skills for generating posts, talks, and narrative structure
  • Slidev and Rough Notation - tools behind Nick C's talk-generation workflow and presentation styling
  • Slack, Gong, and Notion - the connectors and systems that make Claude useful for real work beyond local coding
  • Case and Playwright - Nick Nisi's evidence-driven system for automated implementation and verification
  • skill-forge, octoflow, and bat-kol - examples of meta-skills, Git workflow hooks, and voice-tuning experiments

Nick Cannariato

Nick Cannariato is a software engineer at WorkOS with a background in support, product development, and technical writing. In this conversation he brings a strong point of view on automation, storytelling, and what happens when people who were never traditional software engineers suddenly have tools that let them build and ship anyway.

Related Listening

]]> Episode 1 of The Skill Tree is a conversation with Nick Cannariato about how people actually use Claude skills once they move past the toy stage. Neil Roberts and Nick Nisi talk with him about narrative frameworks for talks and blog posts, connector-heavy research workflows, skill generation, memory systems, and the strange mix of control, curiosity, and frustration that makes AI-assisted work productive.

The discussion stays practical even when it gets philosophical. Nick C explains how his post and talk skills grew out of a dislike for one-size-fits-all story structures, how he uses Claude connectors to automate real sales and research work, and why the right response to repetitive work is often to tell the machine to do more of it.

In This Episode

  • Why Nick Cannariato built post and talk skills around 22 narrative frameworks instead of defaulting to the Hero's Journey
  • How Claude connectors, skills, and long-running agents help automate research, deal prep, documentation, and internal workflows
  • What Nick Nisi's Case project is trying to prove about evidence, state machines, memory, and AI-assisted software work
  • Why all three hosts see AI less as a replacement for thinking and more as a way to ship faster, learn faster, and reduce the fear of getting started

Episode Chapters

  • 00:00 Opening, Guest Intro, and the Cult of Skills
  • 01:04 Meet Neil and Nick Nisi
  • 03:50 Ideation, Pi, and the New Skills
  • 04:11 Monomyths, Story Circle, and 22 Narrative Frameworks
  • 08:44 What the Post and Talk Skills Do in Practice
  • 10:23 Born Out of Spite
  • 11:05 Connectors: Slack, Gong, Notion, and Deal Research
  • 13:35 Meta-Skills, skill-forge, and Hidden Anthropic Docs
  • 16:27 How Nick C Organizes His Skills
  • 18:28 Case, Evidence, and AI State Machines
  • 20:56 Auto-Dream Mode and Memory Management
  • 23:34 Stealing Ideas, Markdown Files, and bat-kol
  • 26:35 Evernote, GitHub, and Becoming an Engineer
  • 29:06 AI Anxiety vs. Shipping More Than Ever
  • 33:35 The Thursday Estimate That Shipped Monday
  • 37:21 Why AI Fits How Our Brains Learn
  • 38:12 The Blog-Writing Hack: Mine Your Claude Transcripts
  • 39:51 Parting Advice
  • 42:53 Break Stuff and Get Paid to Fix It

Narrative Frameworks Beyond the Default Arc

Nick C explains that his post and talk skills were built as a reaction against forcing every talk or blog post into the Hero's Journey or Story Circle. Instead, he has Claude choose from a larger set of narrative frameworks, including more technical, absurdist, and open-ended structures that better fit conference talks, support stories, and real-world writing that does not resolve into a clean heroic arc.

This part of the episode gets into something bigger than presentation structure. The hosts are really talking about taste: how much of yourself you want to preserve when AI helps you write, and how a good skill can encode preferences that are hard to express in a single prompt.

Skills as Working Automation, Not Just Prompts

One of the clearest through-lines in the episode is that skills become more valuable when they are attached to actual work. Nick C walks through using Claude connectors with Slack, Gong, and Notion to recover context from meetings, assemble research, and update documentation without having to manually retrace everything himself. That same impulse shows up in his skill-generation workflow, where one skill helps tune and improve other skills.

Nick Nisi describes a parallel idea in Case, his system for taking issues from intake through implementation while still requiring evidence that the work really happened. Between the two approaches, the episode draws a useful line between lightweight reusable instructions and heavier orchestration systems that manage agents, memory, and proof.

Learning Faster Without Pretending the Tradeoffs Are Gone

The last third of the conversation shifts into what AI work feels like day to day. The hosts talk about shipping faster, using Claude as a patient collaborator for exploration, and reducing the fear that used to come with unfamiliar code or vague estimates. At the same time, they acknowledge the tradeoffs: trust has to be calibrated, review still matters, and some kinds of craft can atrophy if you stop caring about the underlying systems completely.

What makes the conversation useful is that nobody treats this as abstract future-of-work discourse. The examples stay grounded in real projects, real habits, and the way these tools change how people learn by letting them revisit a problem in layers instead of having to understand everything at once.

Tools, Projects, and References Mentioned

  • ideation - Nick Nisi's skill for turning rough ideas into clearer implementation artifacts
  • Pi - another coding agent environment that comes up as a comparison point for Claude Code
  • new-post and conference-talk-builder - Nick Cannariato's skills for generating posts, talks, and narrative structure
  • Slidev and Rough Notation - tools behind Nick C's talk-generation workflow and presentation styling
  • Slack, Gong, and Notion - the connectors and systems that make Claude useful for real work beyond local coding
  • Case and Playwright - Nick Nisi's evidence-driven system for automated implementation and verification
  • skill-forge, octoflow, and bat-kol - examples of meta-skills, Git workflow hooks, and voice-tuning experiments

Nick Cannariato

Nick Cannariato is a software engineer at WorkOS with a background in support, product development, and technical writing. In this conversation he brings a strong point of view on automation, storytelling, and what happens when people who were never traditional software engineers suddenly have tools that let them build and ship anyway.

Related Listening

]]> Tue, 31 Mar 2026 13:13:03 -0500 Neil Roberts, Nick Nisi Neil Roberts, Nick Nisi 2654 Episode 1 of The Skill Tree is a conversation with Nick Cannariato about how people actually use Claude skills once they move past the toy stage. Neil Roberts and Nick Nisi talk with him about narrative frameworks for talks and blog posts, connector-heavy research workflows, skill generation, memory systems, and the strange mix of control, curiosity, and frustration that makes AI-assisted work productive.

The discussion stays practical even when it gets philosophical. Nick C explains how his post and talk skills grew out of a dislike for one-size-fits-all story structures, how he uses Claude connectors to automate real sales and research work, and why the right response to repetitive work is often to tell the machine to do more of it.

In This Episode

  • Why Nick Cannariato built post and talk skills around 22 narrative frameworks instead of defaulting to the Hero's Journey
  • How Claude connectors, skills, and long-running agents help automate research, deal prep, documentation, and internal workflows
  • What Nick Nisi's Case project is trying to prove about evidence, state machines, memory, and AI-assisted software work
  • Why all three hosts see AI less as a replacement for thinking and more as a way to ship faster, learn faster, and reduce the fear of getting started

Episode Chapters

  • 00:00 Opening, Guest Intro, and the Cult of Skills
  • 01:04 Meet Neil and Nick Nisi
  • 03:50 Ideation, Pi, and the New Skills
  • 04:11 Monomyths, Story Circle, and 22 Narrative Frameworks
  • 08:44 What the Post and Talk Skills Do in Practice
  • 10:23 Born Out of Spite
  • 11:05 Connectors: Slack, Gong, Notion, and Deal Research
  • 13:35 Meta-Skills, skill-forge, and Hidden Anthropic Docs
  • 16:27 How Nick C Organizes His Skills
  • 18:28 Case, Evidence, and AI State Machines
  • 20:56 Auto-Dream Mode and Memory Management
  • 23:34 Stealing Ideas, Markdown Files, and bat-kol
  • 26:35 Evernote, GitHub, and Becoming an Engineer
  • 29:06 AI Anxiety vs. Shipping More Than Ever
  • 33:35 The Thursday Estimate That Shipped Monday
  • 37:21 Why AI Fits How Our Brains Learn
  • 38:12 The Blog-Writing Hack: Mine Your Claude Transcripts
  • 39:51 Parting Advice
  • 42:53 Break Stuff and Get Paid to Fix It

Narrative Frameworks Beyond the Default Arc

Nick C explains that his post and talk skills were built as a reaction against forcing every talk or blog post into the Hero's Journey or Story Circle. Instead, he has Claude choose from a larger set of narrative frameworks, including more technical, absurdist, and open-ended structures that better fit conference talks, support stories, and real-world writing that does not resolve into a clean heroic arc.

This part of the episode gets into something bigger than presentation structure. The hosts are really talking about taste: how much of yourself you want to preserve when AI helps you write, and how a good skill can encode preferences that are hard to express in a single prompt.

Skills as Working Automation, Not Just Prompts

One of the clearest through-lines in the episode is that skills become more valuable when they are attached to actual work. Nick C walks through using Claude connectors with Slack, Gong, and Notion to recover context from meetings, assemble research, and update documentation without having to manually retrace everything himself. That same impulse shows up in his skill-generation workflow, where one skill helps tune and improve other skills.

Nick Nisi describes a parallel idea in Case, his system for taking issues from intake through implementation while still requiring evidence that the work really happened. Between the two approaches, the episode draws a useful line between lightweight reusable instructions and heavier orchestration systems that manage agents, memory, and proof.

Learning Faster Without Pretending the Tradeoffs Are Gone

The last third of the conversation shifts into what AI work feels like day to day. The hosts talk about shipping faster, using Claude as a patient collaborator for exploration, and reducing the fear that used to come with unfamiliar code or vague estimates. At the same time, they acknowledge the tradeoffs: trust has to be calibrated, review still matters, and some kinds of craft can atrophy if you stop caring about the underlying systems completely.

What makes the conversation useful is that nobody treats this as abstract future-of-work discourse. The examples stay grounded in real projects, real habits, and the way these tools change how people learn by letting them revisit a problem in layers instead of having to understand everything at once.

Tools, Projects, and References Mentioned

  • ideation - Nick Nisi's skill for turning rough ideas into clearer implementation artifacts
  • Pi - another coding agent environment that comes up as a comparison point for Claude Code
  • new-post and conference-talk-builder - Nick Cannariato's skills for generating posts, talks, and narrative structure
  • Slidev and Rough Notation - tools behind Nick C's talk-generation workflow and presentation styling
  • Slack, Gong, and Notion - the connectors and systems that make Claude useful for real work beyond local coding
  • Case and Playwright - Nick Nisi's evidence-driven system for automated implementation and verification
  • skill-forge, octoflow, and bat-kol - examples of meta-skills, Git workflow hooks, and voice-tuning experiments

Nick Cannariato

Nick Cannariato is a software engineer at WorkOS with a background in support, product development, and technical writing. In this conversation he brings a strong point of view on automation, storytelling, and what happens when people who were never traditional software engineers suddenly have tools that let them build and ship anyway.

Related Listening

]]> AI skills, coding agents, developer workflows, LLM workflows, prompt engineering, MCP, AI coding tools, evals, agentic coding, developer tools, software development, AI automation Yes They're All Markdown Files They're All Markdown Files trailer 89d8627e-2181-494b-9712-381e5c37d647 https://share.transistor.fm/s/f7997d9f In this trailer episode of The Skill Tree, Neil Roberts and Nick Nisi talk about why they started the show and the kinds of AI workflow conversations they want to have. The discussion centers on skills as reusable Markdown-backed instructions, transcript-first publishing, and the tools they keep returning to in day-to-day work.

The format is intentionally loose. There is no formal intro or outro, and the episode drops straight into a conversation about ideation workflows, spec generation, evaluation, and the mix of tools shaping how the hosts think about agent-assisted development.

In This Episode

  • Why The Skill Tree exists and what kinds of conversations the show is meant to explore
  • How Neil and Nick think about AI skills as practical workflow building blocks
  • What makes a strong ideation and spec-generation workflow for agentic coding
  • Why transcripts, reference files, and structured Markdown can make audio content searchable and reusable

Episode Chapters

  • 00:00 Under the Skill Tree
  • 02:34 How Skills Clicked
  • 04:30 NebraskaJS and the Birth of Ideation
  • 15:40 DeepWiki as a Skill Generator
  • 19:01 Open Models, Cost, and Harnesses
  • 23:31 Guests, Segments, and the Show Format
  • 25:35 skilltree.fm, Podcast Metadata, and Skill Evals

Discussion Highlights

Starting with a loose trailer episode

Neil and Nick use this first episode to start publishing before every segment, workflow, and production habit is locked in. That makes the episode feel more like an initial conversation than a polished pilot, but it also gives a direct introduction to the show's focus: practical AI workflows, developer tooling, and how these systems hold up in real use.

Why skills matter even when they are "just Markdown files"

One of the recurring ideas in the episode is that the format is simple but the structure is useful. When instructions, references, and workflows are organized clearly, they become reliable inputs for both agents and humans. The conversation treats skills less like magic and more like reusable working instructions.

"They're all markdown files. What does this even do?"

That line captures a lot of the episode's framing. A big part of the discussion is about the gap between a plain file format and the workflows it can support when the structure is good enough.

Ideation as a bridge from rough ideas to implementation

Nick's ideation skill is one of the clearest examples in the episode of how a workflow can improve AI-assisted development. Instead of jumping straight to an answer, the skill asks clarifying questions, checks its understanding, builds a contract, and only then expands into specs or PRDs. That creates a better handoff between rough human intent and concrete implementation work.

Neil and Nick frame this as an interface problem as much as a prompting problem. Better systems come from better scaffolding: rubrics, progressive disclosure, execution phases, review loops, and artifacts that other tools can consume.

Tools and systems shaping the conversation

The episode moves across a wide range of tools, from day-to-day coding environments like Cursor to research and execution layers like DeepWiki, Context7, Mastra Code, Agent Zero, and pi.dev. NebraskaJS enters the story as a proving ground for showing workflows in public. Wispr Flow connects to the dictation-heavy, brain-dump style behind ideation. DSPy and Tessl push the conversation toward evaluation and what it means to know a generated workflow is actually good.

Tools, Projects, and References Mentioned

  • Cursor - the coding environment both hosts keep returning to for AI-assisted development
  • NebraskaJS - the meetup where workflow demos and the ideation origin story took shape
  • Wispr Flow - the dictation tool behind the freeform brain-dump style that inspired ideation
  • DeepWiki - a way to turn repository documentation into structured references and skill inputs
  • Oxlint and Oxfmt - examples of tools Nick was manually experimenting with while thinking about what still feels good to do by hand
  • Context7, Mastra Code, Agent Zero, and pi.dev - examples of agent tooling and execution harnesses that shape the discussion
  • DSPy and Tessl - part of the thread on evaluating skills, workflows, and generated systems

About The Hosts

Neil Roberts

Neil Roberts is a software engineer at SitePen active in the JavaScript community and podcasting. On The Skill Tree, he brings a strong interest in AI workflows, documentation-driven systems, and practical ways to make LLMs more useful.

Nick Nisi

Nick Nisi is a DX engineer at WorkOS focused on TypeScript, AI tooling, and podcasting. He brings a tinkerer mindset to the show, with a particular interest in skills, agent workflows, ideation systems, and developer tooling.

]]> In this trailer episode of The Skill Tree, Neil Roberts and Nick Nisi talk about why they started the show and the kinds of AI workflow conversations they want to have. The discussion centers on skills as reusable Markdown-backed instructions, transcript-first publishing, and the tools they keep returning to in day-to-day work.

The format is intentionally loose. There is no formal intro or outro, and the episode drops straight into a conversation about ideation workflows, spec generation, evaluation, and the mix of tools shaping how the hosts think about agent-assisted development.

In This Episode

  • Why The Skill Tree exists and what kinds of conversations the show is meant to explore
  • How Neil and Nick think about AI skills as practical workflow building blocks
  • What makes a strong ideation and spec-generation workflow for agentic coding
  • Why transcripts, reference files, and structured Markdown can make audio content searchable and reusable

Episode Chapters

  • 00:00 Under the Skill Tree
  • 02:34 How Skills Clicked
  • 04:30 NebraskaJS and the Birth of Ideation
  • 15:40 DeepWiki as a Skill Generator
  • 19:01 Open Models, Cost, and Harnesses
  • 23:31 Guests, Segments, and the Show Format
  • 25:35 skilltree.fm, Podcast Metadata, and Skill Evals

Discussion Highlights

Starting with a loose trailer episode

Neil and Nick use this first episode to start publishing before every segment, workflow, and production habit is locked in. That makes the episode feel more like an initial conversation than a polished pilot, but it also gives a direct introduction to the show's focus: practical AI workflows, developer tooling, and how these systems hold up in real use.

Why skills matter even when they are "just Markdown files"

One of the recurring ideas in the episode is that the format is simple but the structure is useful. When instructions, references, and workflows are organized clearly, they become reliable inputs for both agents and humans. The conversation treats skills less like magic and more like reusable working instructions.

"They're all markdown files. What does this even do?"

That line captures a lot of the episode's framing. A big part of the discussion is about the gap between a plain file format and the workflows it can support when the structure is good enough.

Ideation as a bridge from rough ideas to implementation

Nick's ideation skill is one of the clearest examples in the episode of how a workflow can improve AI-assisted development. Instead of jumping straight to an answer, the skill asks clarifying questions, checks its understanding, builds a contract, and only then expands into specs or PRDs. That creates a better handoff between rough human intent and concrete implementation work.

Neil and Nick frame this as an interface problem as much as a prompting problem. Better systems come from better scaffolding: rubrics, progressive disclosure, execution phases, review loops, and artifacts that other tools can consume.

Tools and systems shaping the conversation

The episode moves across a wide range of tools, from day-to-day coding environments like Cursor to research and execution layers like DeepWiki, Context7, Mastra Code, Agent Zero, and pi.dev. NebraskaJS enters the story as a proving ground for showing workflows in public. Wispr Flow connects to the dictation-heavy, brain-dump style behind ideation. DSPy and Tessl push the conversation toward evaluation and what it means to know a generated workflow is actually good.

Tools, Projects, and References Mentioned

  • Cursor - the coding environment both hosts keep returning to for AI-assisted development
  • NebraskaJS - the meetup where workflow demos and the ideation origin story took shape
  • Wispr Flow - the dictation tool behind the freeform brain-dump style that inspired ideation
  • DeepWiki - a way to turn repository documentation into structured references and skill inputs
  • Oxlint and Oxfmt - examples of tools Nick was manually experimenting with while thinking about what still feels good to do by hand
  • Context7, Mastra Code, Agent Zero, and pi.dev - examples of agent tooling and execution harnesses that shape the discussion
  • DSPy and Tessl - part of the thread on evaluating skills, workflows, and generated systems

About The Hosts

Neil Roberts

Neil Roberts is a software engineer at SitePen active in the JavaScript community and podcasting. On The Skill Tree, he brings a strong interest in AI workflows, documentation-driven systems, and practical ways to make LLMs more useful.

Nick Nisi

Nick Nisi is a DX engineer at WorkOS focused on TypeScript, AI tooling, and podcasting. He brings a tinkerer mindset to the show, with a particular interest in skills, agent workflows, ideation systems, and developer tooling.

]]> Fri, 13 Mar 2026 09:29:57 -0500 Nick Nisi and Neil Roberts Nick Nisi and Neil Roberts 1748 In this trailer episode of The Skill Tree, Neil Roberts and Nick Nisi talk about why they started the show and the kinds of AI workflow conversations they want to have. The discussion centers on skills as reusable Markdown-backed instructions, transcript-first publishing, and the tools they keep returning to in day-to-day work.

The format is intentionally loose. There is no formal intro or outro, and the episode drops straight into a conversation about ideation workflows, spec generation, evaluation, and the mix of tools shaping how the hosts think about agent-assisted development.

In This Episode

  • Why The Skill Tree exists and what kinds of conversations the show is meant to explore
  • How Neil and Nick think about AI skills as practical workflow building blocks
  • What makes a strong ideation and spec-generation workflow for agentic coding
  • Why transcripts, reference files, and structured Markdown can make audio content searchable and reusable

Episode Chapters

  • 00:00 Under the Skill Tree
  • 02:34 How Skills Clicked
  • 04:30 NebraskaJS and the Birth of Ideation
  • 15:40 DeepWiki as a Skill Generator
  • 19:01 Open Models, Cost, and Harnesses
  • 23:31 Guests, Segments, and the Show Format
  • 25:35 skilltree.fm, Podcast Metadata, and Skill Evals

Discussion Highlights

Starting with a loose trailer episode

Neil and Nick use this first episode to start publishing before every segment, workflow, and production habit is locked in. That makes the episode feel more like an initial conversation than a polished pilot, but it also gives a direct introduction to the show's focus: practical AI workflows, developer tooling, and how these systems hold up in real use.

Why skills matter even when they are "just Markdown files"

One of the recurring ideas in the episode is that the format is simple but the structure is useful. When instructions, references, and workflows are organized clearly, they become reliable inputs for both agents and humans. The conversation treats skills less like magic and more like reusable working instructions.

"They're all markdown files. What does this even do?"

That line captures a lot of the episode's framing. A big part of the discussion is about the gap between a plain file format and the workflows it can support when the structure is good enough.

Ideation as a bridge from rough ideas to implementation

Nick's ideation skill is one of the clearest examples in the episode of how a workflow can improve AI-assisted development. Instead of jumping straight to an answer, the skill asks clarifying questions, checks its understanding, builds a contract, and only then expands into specs or PRDs. That creates a better handoff between rough human intent and concrete implementation work.

Neil and Nick frame this as an interface problem as much as a prompting problem. Better systems come from better scaffolding: rubrics, progressive disclosure, execution phases, review loops, and artifacts that other tools can consume.

Tools and systems shaping the conversation

The episode moves across a wide range of tools, from day-to-day coding environments like Cursor to research and execution layers like DeepWiki, Context7, Mastra Code, Agent Zero, and pi.dev. NebraskaJS enters the story as a proving ground for showing workflows in public. Wispr Flow connects to the dictation-heavy, brain-dump style behind ideation. DSPy and Tessl push the conversation toward evaluation and what it means to know a generated workflow is actually good.

Tools, Projects, and References Mentioned

  • Cursor - the coding environment both hosts keep returning to for AI-assisted development
  • NebraskaJS - the meetup where workflow demos and the ideation origin story took shape
  • Wispr Flow - the dictation tool behind the freeform brain-dump style that inspired ideation
  • DeepWiki - a way to turn repository documentation into structured references and skill inputs
  • Oxlint and Oxfmt - examples of tools Nick was manually experimenting with while thinking about what still feels good to do by hand
  • Context7, Mastra Code, Agent Zero, and pi.dev - examples of agent tooling and execution harnesses that shape the discussion
  • DSPy and Tessl - part of the thread on evaluating skills, workflows, and generated systems

About The Hosts

Neil Roberts

Neil Roberts is a software engineer at SitePen active in the JavaScript community and podcasting. On The Skill Tree, he brings a strong interest in AI workflows, documentation-driven systems, and practical ways to make LLMs more useful.

Nick Nisi

Nick Nisi is a DX engineer at WorkOS focused on TypeScript, AI tooling, and podcasting. He brings a tinkerer mindset to the show, with a particular interest in skills, agent workflows, ideation systems, and developer tooling.

]]> AI skills, coding agents, developer workflows, LLM workflows, prompt engineering, MCP, AI coding tools, evals, agentic coding, developer tools, software development, AI automation No