The Skill Tree

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.

Episodes

  1. 3d ago

    Fill Your Context Window

    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 They're All Markdown Files Cleaning the Fridge: The Hero's Journey I Haven't Given It a Soul

  2. Jul 14

    I Haven't Given It a Soul

    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 They're All Markdown Files Cleaning the Fridge: The Hero's Journey

  3. Mar 31

    Cleaning the Fridge: The Hero's Journey

    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 They're All Markdown Files

  4. Mar 13

    They're All Markdown Files

    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.

Trailer

About

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.