SkillsTV Live

SkillsTV Live

By Chris ShankuTechnology
Download on the App Store

SkillsTV Live episodes

  • Your Employees Are Running Shadow AI. Now What?

    Chris and Sash spend this episode working through a problem most enterprise leaders already know exists but haven't acted on: employees running AI tools the company never approved. They define Shadow AI plainly - using a model or AI system your company hasn't sanctioned to do work - and draw a direct line from the old Shadow IT problem (pulling data into a personal Dropbox) to the new one (uploading confidential documents to a personal Perplexity or OpenAI free subscription with model training not disabled). The key difference they land on is that with Shadow AI, there's always a third party involved from the jump, and the exposure doesn't stay contained.

    Sash makes the stakes concrete: run OpenClaw on your home Mac, plug in your company email, and you now have a fully autonomous always-on agent with access to everything - and the people most likely to do this are executives, the exact employees carrying the most sensitive data. Chris connects this to his BI background - Shadow IT in Power BI meant bad analysis on a local Excel file, low stakes. Shadow AI means confidential strategy going into a free-tier model and potentially becoming training data for a competitor's next GPT.

    The back half of the episode is where it gets actionable. Sash's rule for agent governance: no agent runs in production without a harness that lets you trace it, period. Chris pushes the parallel to how enterprises managed the cloud migration - the same people/process/technology pillars (ITIL, NIST, ISO) apply here, just moving 10x faster. Both agree banning doesn't work - the more you restrict, the more people find workarounds - and that governed AI means giving employees the tools they actually need, with guardrails in place, not cutting off access and waiting for the breach. The episode closes with a preview of week four: skills as institutional knowledge, and how deploying consistent agent skills across a team is how you get predictable costs and consistent outputs.

    Key takeaways:

    • Define Shadow AI clearly for your org before you try to govern it: any AI model or system not approved by the company, used on company work, with a third party receiving your data.
    • The real risk isn't the casual browser user - it's the executive running an autonomous agent connected to their company email on a personal subscription.
    • Banning doesn't work. Employees who find AI useful will route around restrictions. Give them sanctioned tools with guardrails instead.
    • Every agent running in production needs a monitoring and evaluation harness that lets you trace what it's doing. No exceptions, no matter how small the agent.
    • Apply the frameworks you already know - ITIL, NIST, ISO, data classification, sensitivity labels - to AI governance. The technology is new; the governance pillars are not.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    21 min
  • Your AI Budget is on Fire (You Don't Know it Yet)

    This is the re-record of episode two of the AI for Enterprise series - the first take went out with Sash's audio muted, so Chris and Sash ran it back. The topic is the one landing in every CFO and CTO inbox right now: why AI token budgets are blowing up and what to actually do about it. The catalyst is real - Uber gave engineers $1,500 a month of API budget and the whole company burned its entire year's allocation in four months. The point Sash keeps returning to is that an AI budget cannot be a single line item. The money has to go across people, process, and technology - rethinking workflows and re-skilling teams, not just paying for tokens.

    The spine of the episode is a model for enterprise AI spend split into three workloads, each with a different cost curve. Chat is table stakes: 80-90% of an organization gets incremental productivity from browser-based assistants, and that cost is trending to zero (Microsoft M365 Copilot, free chat tiers). Coding carries the highest and most defensible spend, because software ROI is a solved measurement problem - faster features and shipped products tie straight to revenue, so the high token output is justifiable. Agentic is the fuzziest and most dangerous: agents are non-deterministic, run a lot of background work, and if you are not watching the meter one stuck long-running agent can burn the budget overnight. Sash's cautionary number is a real one - an agent that got stuck in a loop ran up a $35,000 API bill.

    The practical guidance is concrete. Start everyone on $20 plans, detect power users from real usage patterns, and use plan-plus-usage as a middle tier before jumping to the $100 5x plans. Build every production agent with an eval harness and a kill switch, and set hard token and time budgets before you deploy. For coding and agentic volume, take frontier-model risk seriously - if Opus or GPT gets turned off tomorrow, teams running production processes on it are stranded - so pair a frontier strategy with an open-source one: self-host a strong open model (Qwen 32B fits in 24GB, plus Kimi K2 and GLM) on your own hardware, controlling both cost and risk. This is the cloud-era dual-provider playbook applied to models. It closes on the phrase that names the show: own the harness, run a powerful open model, harness in the loop. Tools like Codex Bar (Peter Steinberger) for token monitoring and Paperclip for per-agent budgets and auto-kill are where the governance layer is starting to form.

    Key takeaways:

    • Split enterprise AI spend into three workloads before budgeting - chat, coding, agentic - because each has a completely different cost curve and risk profile.
    • Coding is the highest and most justifiable spend; its ROI is measurable because it ties directly to shipped features and revenue. Chat is trending toward zero; agentic is the fuzzy, dangerous one.
    • Do not deploy an agent without a hard token/time budget, an eval harness, and a kill switch - one stuck long-running agent ran up a $35,000 API bill.
    • Tier your plans by real usage: start everyone at $20, detect power users, and use plan-plus-usage as a middle step before the $100 5x plans.
    • Pair a frontier-model strategy with an open-source one. Self-hosting a strong open model (Qwen 32B, Kimi K2, GLM) on your own hardware controls cost and removes the risk of a frontier model being turned off.
    • Monitoring is the whole game - you cannot budget what you cannot see. Bring in token monitoring (Codex Bar) and a governance layer (Paperclip) with per-agent caps and auto-kill.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    24 min
  • I Built a Responsible AI Gate That Blocks My Own Builds

    Chris opens this episode - the first of a four-part AI for Enterprise series - with a challenge to the room: Responsible AI is the part of every AI presentation where people pull out their phones. Not anymore. The regulatory environment has shifted, and a $35 million EU AI Act fine has a way of making even the most skeptical CIO lean forward. Chris draws directly from his time at Microsoft, where he presented the company's OpenAI partnership to enterprise executives and got deep into how Microsoft embedded Responsible AI into every engineering group, reporting to Satya's ELT.

    The core of the episode is Chris walking through Microsoft's six Responsible AI principles - fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability - and showing how he has applied that same structure inside his own personal build system, TheGrove. The key moment is when he reveals that he runs a Responsible AI agent as a mandatory gate in his SDLC: after Red Team and CTO architecture review, Responsible AI must sign off before any feature ships. More pointedly, he has blocked builds from ever reaching a development environment because they failed to satisfy all six principles. He acknowledges the tension directly - a Claude agent evaluating a Claude-built plan is not an objective reviewer - which is precisely why the flag goes to him for human sign-off, not automatic rejection.

    Sash grounds the conversation in the practical cost argument: the cost of doing this right now is not close to the cost of a fine. Chris brings in two vendor-neutral reference points - the NIST AI Risk Management Framework as a non-Microsoft alternative, and Azure AI Content Safety as a low-cost front-door filter for prompt and response classification across hate, violence, jailbreak, and hallucination categories. The episode closes with a tease of what is coming: EP.014 on token maxing and EP.015 on shadow AI, with the series building toward a full enterprise AI governance picture.

    Key takeaways:

    • Responsible AI governance is cheaper to build in than to bolt on after a violation - the EU AI Act can fine organizations up to $35 million for major infractions.
    • Microsoft's six principles (fairness, reliability and safety, privacy and security, inclusiveness, transparency, accountability) are a practical starting checklist for any enterprise building AI systems.
    • Run Responsible AI review before build, not just after - Chris gates features at the planning stage and has stopped builds from reaching dev because they did not satisfy all six principles.
    • If you prefer a vendor-neutral framework, look at the NIST AI Risk Management Framework - same governance intent, no Microsoft alignment required.
    • Azure AI Content Safety is one of the cheapest Azure SKUs and acts as a configurable front-door filter for LLM inputs and outputs - covering hate speech, jailbreaking, prompt injection, and hallucination detection on a 0-7 severity scale.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    21 min
  • How to Build an Always-On AI Agent That Doesn't Break

    Sash drives this one, screen-sharing the always-on AI agent he runs in the cloud and showing how Claude Code became the tool that keeps it alive. His agent (Blaze) runs on a standard OpenClaw image inside a Hostinger Linux VPS, controlled over Telegram, and reachable only across a private Tailscale network so no one outside his own devices can touch it. The kicker: Sash had never used Linux. He never SSH'd into the box by hand or hand-edited a config. He asked Claude Code to connect over Tailscale, generate an SSH key, install OpenClaw, and wire it up. Chris runs the same pattern with a Hermes agent on a Mac, and the two setups landed on the identical stack independently - Hostinger, Telegram, Tailscale - which becomes the episode's running joke and its real point: this is just enterprise security and operations practice applied to personal AI agents.

    The heart of the demo is a live debugging session. Sash had been hitting transient failures where Blaze would go quiet mid-task and silently drop work with no feedback. He pointed Claude Code at the VPS and asked it to verify Blaze's health and hunt for transient errors over the last seven days. Claude Code read the logs and found the real cause: after Sash migrated Blaze off the Anthropic API (which was costing ~$25/day) onto an OpenAI Codex subscription over OAuth, a config parameter - missing assistant retries, defaulted to zero - meant the agent never retried after a stop. It also surfaced a second, invisible failure: Codex OAuth does not expose an embeddings model, so OpenClaw's memory-indexing system had been completely broken for three days and Sash would never have known without asking. The fix is a cheap OpenAI API key just for embeddings. Sash's plan: turn this health check into a weekly skill so Claude Code self-audits the agent on a schedule.

    The takeaway both hosts keep circling is the orchestrator/watchdog pattern - a primary agent (Claude Code) supervising other autonomous agents, the same way you'd never ask a single SQL table to monitor the health of its own database. That framing sets up the show's next arc: starting next week, a multi-episode "AI for Enterprise" series, opening with Responsible AI (Microsoft's RAI framework, NIST), then token spend and building institutional knowledge through shared skills.

    Key takeaways:

    • Don't run an always-on agent on your laptop. Put it on a cheap VPS (Hostinger, DigitalOcean), lock it behind a Tailscale private network, and reach it over SSH so no passwords sit in env files and nothing outside your own devices can connect.
    • You don't need to know Linux. Ask Claude Code to connect to the VPS, generate the SSH key, install OpenClaw/Hermes, and configure Telegram - it does the parts you don't know how to do.
    • Running OpenClaw/Hermes on an OpenAI Codex subscription over OAuth avoids per-call API bills (Sash's Anthropic API run was ~$25/day), but watch two gotchas: set missing assistant retries above zero, and add a cheap OpenAI API key for embeddings since Codex OAuth doesn't expose the embeddings model your agent's memory needs.
    • Build a watchdog. Autonomous agents fail silently outside their own scope (dropped Telegram channel, missing API key, broken memory index); have Claude Code read the logs, diagnose, and turn that health check into a weekly skill.
    • The orchestrator pattern - one supervising agent managing others - is just enterprise monitoring practice applied to AI. The health of a system is managed from outside the system.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    18 min
  • I Gave Fable 5 a 2-Day Job and It Actually Finished

    We called an audible. Fable 5 - Anthropic's first Mythos-class model the public can actually touch - dropped this week, so the planned episode went out the window. Sash drove. Instead of a launch-day reaction, he showed two days of real work: he handed Fable 5 a job he'd been deferring for weeks, a full 31-lesson curriculum review spread across roughly 40 markdown files, with instructions to reformat lesson timing, reconcile contradictions between lessons, and update the Claude Code configuration by researching current Anthropic docs. Opus 4.1 had choked on the same task earlier with context issues. Sash resumed the exact same Claude Code session, flipped the model from Opus to Fable, and let it run.

    What stood out was the autonomy. Unprompted, Fable created its own work-log file, spun up a review folder for its notes, confirmed the scope (31 lesson files, 5 project files), then asked a batch of strategic yes/no questions before doing anything. It ran ~26 minutes unattended, fired up six subagents to research and write in parallel, and stopped to ask follow-up questions only when it hit a real decision it shouldn't guess on - like which of two contradicting lessons to keep. Total execution was 29 minutes for work that took Sash two days to review, and he didn't have to change anything.

    The receipts: 665,000 output tokens (about 80% of Sash's daily 5x Max allowance), 137 file operations, 21 messages back to him, and only three tool errors across the whole run. The pricing catch matters: Fable is roughly 2x the cost of Opus 4.8, bundled into Pro/Max subscriptions only until June 22, after which it moves to usage credits (you pay API cost on top of your subscription). Chris pushed the honest question throughout - when does this actually pay off versus when is Opus still the right call?

    Key takeaways:

    • Use Fable 5 for long, complex, bounded jobs where you can describe the outcome and walk away - not for trivial chores like organizing a downloads folder. You will just burn tokens.
    • Plan first. Start with the outcome, have Fable reverse-engineer the plan, approve it, then let it execute. It is noticeably better than Opus at building a plan from a stated end state.
    • Higher effort settings (x-high / max) make Fable re-check its own work more, so accuracy increases on longer-running tasks instead of degrading. This is the opposite of watching Opus drift while holding 400K tokens in one context window.
    • Watch your usage. A single review pushed Sash to ~80% of his daily 5x Max limit; on a Pro plan it will eat your allowance fast. Budget Fable for your highest-value task on deck.
    • Resuming an existing Claude Code session and flipping the model (Opus -> Fable) preserves context - a clean way to escalate a task the daily driver stalled on.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    20 min
  • When Automation Fails: Lessons From The Trenches

    Chris drives EP.10, a direct sequel to last week's monitoring episode with Rene. He opens with a failure: he added a feature to his Life OS (TheGrove), it tested green, and three days later every automation had stopped. The one that stung was the 8am morning-journal prompt - the first automation he ever built and the thing the rest of the system sits on top of. The trigger was tiny: a change that moved a single file. Claude ran 671 unit tests, every one came back green, because the tests checked the code, not whether the real automations still fired. The failure was silent - no alert, he only noticed because the morning messages stopped arriving.

    The fix is a regression layer. Every time something breaks, Claude logs it to a regressions.md file inside TheGrove, and those entries get collected into a /smoke skill - smoke testing as a running ledger of everything that has ever broken, plus the key automations that must keep working. /smoke now runs as a subskill inside Chris's SDLC (called by his plan and goal workflows after unit tests, QA, and red-team pass), spinning parallel sub-agents to re-validate all 16 predicates. It has caught real breaks, and Chris's trust in the system has gone up as a result.

    The conversation widens with Sash into self-healing systems. Sash draws the analogy to Microsoft Exchange, which reached self-healing by roughly 2015 on plain deterministic code; AI needs the same safety net but is non-deterministic, so you should assume it will fail and build the catch-fix-document loop around it. They land on a reframe: the AI model is tech, but the agent belongs under people - you manage it like a capable teammate who still makes mistakes. Chris's north star is self-fixing: don't just tell me it broke, tell me you already fixed it. The episode closes teeing up EP.11 - Sash using Claude Code to manage and secure OpenClaw, agents managing agents.

    Key takeaways:

    • Passing unit tests can still hide a broken system. 671 green tests checked the code, not whether the real automations fired - test the outcomes you actually depend on, not just the units.
    • Turn every incident into a permanent check. Log each break to a regressions.md and collect them into one smoke-test skill so the same failure can never silently return.
    • Run smoke testing as part of your SDLC, not ad hoc. Call it after unit, QA, and red-team pass, before anything gets marked done.
    • Assume non-deterministic systems will fail and build the detect-fix-document loop around them. Aim for self-fixing, not just alerting.
    • Treat autonomous agents as people, not tech. More autonomy means a larger failure surface, so manage them with process and watchdogs.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    20 min
  • I Audited My AI's Code Coverage: The Results Were Terrifying

    Rene Charbonneau walked through his evolution from LibreChat to OpenClaw to Claude Code - and the $200/day Opus invoice that turned into a "welcome to AI" tuition payment. The trigger that pulled him in was building a household chat so his family could share AI context without forwarding screenshots. Once a non-developer saw his own commits land in a Git repo and ship across environments, he stopped treating AI as a tool and started treating it as a workflow problem.

    The core of the episode was a four-phase refactor loop he iterates on weekly: foundation (slash commands first, plus a secrets hook that pipes credentials from BitWarden straight into the environment so API keys never enter the chat log), measure (a TDD audit caught his pipeline running at 17% coverage versus the 80% he had specified), tune (PreToolUse/PostToolUse hooks enforce gates before commits land), sustain (a cron job ships three retro items a day at low blast radius). The piece a solo builder usually loses is the people leg of people/process/technology - Rene gets it back with a five-agent Opus council (CISO, CPO, CTO, co-founder + a synthesizer that prunes to what's critical now) that reviews every spec before the build agents touch it.

    Chris and Rene compared their independently-built SDLC pipelines and found near-identical phase shapes - scope, plan/design, implement, review, ship, retro - differing mostly in review style (Chris programmatic, Rene LLM-driven). Hot take from the guest: AI won't gut middle management, it will turn middle managers into "Bill Russells" - player-coaches who can finally build the system they used to delegate. Sash extended the analogy to shadow IT - if you don't give your high-agency people a Claude subscription and permission to experiment, they'll build it anyway, just somewhere you can't see. Chris closed by teasing EP.010 on watchdog and regression systems, and Rene left the audience with the one rule he's anchored on: validate every agent output against tangible artifacts (database rows, files), never against the agent's own text summary.

    Key takeaways:

    • Keep secrets out of chat logs - pipe credentials through a hook that injects from a vault into the environment, never into the prompt.
    • Audit TDD and coverage with a separate agent. Your build agent will overstate what it actually shipped; a spec audit catches it cheap.
    • Build a multi-role Opus council (CISO, CPO, CTO, co-founder, synthesizer) that reviews specs before build. Solo builders need the people leg, not just process and tech.
    • Trickle retrospective items through a daily cron - three at a time. Lower risk than batching them into a refactor sprint.
    • Validate AI output against hard artifacts (DB rows, files), never against the agent's own text summary.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    31 min
  • I Tested MCPs So You Don't Have To: Stability & Costs

    Sash drives this week, walking Chris through MCP (Model Context Protocol) - the standard Anthropic released in November 2024 that lets LLMs talk to external apps, data, and tools. Chris frames it as "the API for agents" and Sash confirms it: a shared language that agents speak to reach Gmail, Granola, n8n, anything with a server. They tour the Claude connector marketplace (Gmail, Calendar, G Drive, Granola), inspect a connector's tool list, and show the per-tool approval model that controls what an agent is allowed to do without a prompt.

    The conversation gets practical fast. Sash uses a third-party Google MCP for his Hermes agent because the community version does more than the official one, and a 21k-star n8n MCP that lets Claude build workflows without him touching n8n. He also surfaces the stability tradeoff - one of his custom MCPs is currently failing in /mcp - and the hidden cost that bit Chris: every connected MCP auto-loads its tool definitions into context, so stacking dozens of them can quietly burn your context window. That nudged Chris back toward straight APIs (like Exa for semantic search) for things he can scope tightly himself.

    They land on a heuristic: if a marketplace MCP exists and is stable, use it; if not, fall back to a scoped API. Chris floats the idea of an "OpenRouter for MCPs" - a proxy that routes between MCPs to keep context lean - and they note auth would be the hard part. Next week brings the show's first guest: Rene Charbonneau, on why your AI systems drift and how to keep evaluating them.

    Key takeaways:

    • Treat MCP as the API surface for agents - if a vendor or community MCP exists, try it before writing custom API plumbing.
    • Audit your MCP list. Every connected MCP auto-loads its tool definitions into context. Stacking n8n, Make, and a dozen connectors will silently eat your context window before your prompt even runs.
    • Use the per-tool approval gate in connectors. Mark read-only tools 'always allow' and keep write/delete on 'needs approval' so agents can move without you babysitting safe calls.
    • Look at community MCP repos before defaulting to official ones - Sash's Hermes uses a 3rd-party Google MCP that beats the official one, and the n8n community MCP has 21k stars.
    • When you need tight scope control or token discipline, drop to an API. Exa for semantic search and Duffel for travel booking are good examples - though Duffel now ships an MCP too, so the line keeps moving.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    19 min
  • My Agents Had a Convo at Midnight Without Me. Here's the Stack Behind It.

    Chris breaks from the usual Claude-centric format and walks through Hermes, an always-on autonomous agent runtime from Nous Research. The framing: Hermes is the body of his personal AI stack - lightweight, learning, always listening, primarily reached over iMessage via BlueBubbles. Claude Code is the brain - heavy systems work, infrastructure, long sessions in front of a terminal or VS Code. Each Hermes profile starts with a SOUL.md that defines voice, posture, and behavior, then layers on skills (reusable patterns Hermes can create on its own after the third repetition) and a built-in cron system.

    The interesting part is the multi-profile setup. One Apple ID, one BlueBubbles install, five distinct agents - Silas (Chris), Ivy (his girlfriend Amanda), Grover (the shared family agent in the group chat), Atticus (the Georgia divorce-law agent neither human talks to directly), and Neo (Tier 2 developer agent). BlueBubbles webhook routing picks the right profile based on which number is sending. Cross-context sharing between agents is gated through a Postgres events table with consent levels and a health-sensitive flag.

    The payoff is the real story: one night, sitting with his son playing Pokemon, Chris got an unprompted text from Silas saying "Amanda's evening journaling prompt broke and Ivy told me to talk to you." That kicked off a tour of AgentMail - the inbox-per-agent system Hermes profiles use to coordinate. Amanda's SOUL.md instructs Ivy: when something breaks, do not tell Amanda - tell Silas. Silas is Tier 1, Neo is Tier 2, Chris is Tier 3. The agents handled the failure between themselves with neither human in the loop until escalation was required. Chris closes on cost reality (Anthropic blocks the Claude Code subscription from external runtimes, so Hermes runs on Codex with GPT-5.4-mini) and a commitment to keep iterating toward the orchestrate model.

    Key takeaways:

    • Split your personal AI stack into a body (always-on, reachable on the surfaces you already use) and a brain (heavy session-based work). Don't try to make one tool do both.
    • Each agent profile gets a SOUL.md - voice, posture, behavior. The voice is the product. Let the person it serves co-write it.
    • One BlueBubbles install + one Apple ID + webhook routing can host multiple agents on iMessage. Sender number picks the profile.
    • Use an inbox-per-agent service (AgentMail or equivalent) for agent-to-agent coordination instead of inventing a new protocol. Email is a doorbell.
    • Define failure routes in the SOUL itself: when something breaks, escalate to peer X, then peer Y, then page the human. That tiered structure is just on-call rotation, but for agents.
    • Anthropic does not let the Claude Code subscription auth from external runtimes. If you want Hermes-style always-on with Claude models, you pay API rates. Codex on GPT-5.4-mini is the cheap workaround if you have a ChatGPT Plus or Pro subscription.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    19 min
  • I Built a 5-Step System to Automate My Workflow

    Sash walks through the Orchestrator Method - his five-principle framework for delegating real work to AI without losing the plot. The principles: define the end state, plan it with AI, deconstruct and delegate, stay in the loop, and build systems for reuse. None of it is technically novel - it is the same delegation muscle that any consultant, engineer, or manager already has - but Sash names it explicitly so you can run it as a checklist when you are wiring up agents instead of reinventing the wheel each time.

    The conversation moves between the meta (when to stay in the loop, when to step out) and the practical (a Sunday newsletter workflow Sash built with Nuro, a Google Ads skill he built with Claude for the laundry business he runs with his wife). Chris ties it back to his own Grove build - he started by modeling agents like a corporate org chart with a CTO and architect and found the management overhead was wasted, so he flattened it. The big shared insight is principle four: humans stay in the loop only until trust is earned. Chris's rule of thumb is 95% - if AI is right 95% of the time and he is not adding value in review, why is he still in the loop?

    The episode closes with a teaser for next week: Sash is bringing in Hermes Agent, an always-on AI Chris has been running for himself, his girlfriend, and the family. He logged in a few days ago to find his agents had been talking to each other without him.

    Key takeaways:

    • Use plan mode in Claude Code (Shift+Tab) before you let it write anything - it cannot touch files, so a misclick is harmless and the output is sharper.
    • If you do not know what good looks like for the end state, do not guess. Ask AI to draft the spec with you - 800-1,000 words, this geography, this time window - then start.
    • Pick a trust threshold for taking yourself out of the review loop. Sash and Chris both use 95%. Below it, stay in. Above it, step out and let the system run.
    • The third time you do something manually, turn it into a skill. Hermes Agent does this automatically; in Claude you have to remember to ask.
    • The orchestrator method is fractal - apply it to a single prompt, a single skill, an agent, or a multi-agent system. Same five steps, different scope.

    Watch the video version on YouTube · Full show notes, transcript + takeaways

    20 min

About SkillsTV Live

From the publisher's feed

Learn AI skills every week on SkillsTV Live, a live show that demos Claude Skills, agent skills, and MCP with real tools - no slides, no hype. Hosted by Chris Shanku and Sash Mohapatra. Upgrading…