Applied Wizardry

The outsized returns from AI come from revenue growth, not cost-cutting—yet 99% of businesses outside the tech bubble have barely started exploring it. Michael Batko, former Startmate CEO and now founder of Hourglass AI, joins Yaniv to discuss how he helps companies of 20-100 people with no engineering team build bespoke AI systems. The conversation covers the company 'AI brain' built from structured Markdown files, the skills-based collaboration model that prevents teams from rebuilding the same tools, and why behaviour change is the hardest part of any AI transformation. For engineers and founders, the episode is a practical look at what actually works when AI building is cheap but maintenance and adoption remain hard.

• Custom software for N-of-1 use cases is now viable because AI has collapsed build speed and cost, making bespoke solutions economical for SMBs that could never afford them before.
• The two hardest bottlenecks in AI adoption are behaviour change and systematic thinking about processes—technology is the easy part.
• Hourglass AI builds a 'company AI brain' as a structured Markdown file tree ingested from inboxes, CRMs and documents, refreshed daily, with access controls ring-fenced by person.
• Skills are maintained separately from knowledge: one person builds a workflow skill, an admin approves updates, and the whole team uses it, preventing inconsistent duplicate tools.
• The highest-ROI automations are post-meeting follow-up emails, inbox management with full company context, and finding revenue triggers like DA approvals for timely outreach.
• Michael's personal terminal setup opens Claude Code projects with a single keystroke, continuing conversations across his own brain, client brains and work folders.
• Most people's AI experience remains a chat box Q&A; the mindset shift comes when they see something built or done agentically rather than just answered.

• 00:00 Revenue vs Cost Cutting
• 02:43 Hourglass AI Model
• 04:23 Speed and Customisation
• 07:49 The Real Bottlenecks
• 10:09 Discovery and Specs
• 14:37 Building vs Maintaining
• 19:45 Company AI Brain
• 21:57 Skills and Collaboration
• 29:46 Batko's Terminal Setup
• 44:46 Claude Lords and Champions
• 49:29 Speed of Change
• 52:20 Agents and Wallets

• Hourglass AI: https://thehourglass.ai
• Startmate: https://startmate.com
• Granola: https://www.granola.ai
• Claude: https://claude.ai
• Apify: https://apify.com
• Supabase: https://supabase.com
• NitroSend: https://nitrosend.com
• Obsidian: https://obsidian.md
• Data for SEO: https://dataforseo.com

Michael Batko is the founder of Hourglass AI, which helps companies implement AI to improve productivity, and was previously CEO of Startmate, Australia's largest accelerator, for eight years.

This episode is presented by SparkLaunch and Dam Secure.

• SparkLaunch (https://sparklaunch.io/wizardry): Applied Wizardry listeners get an extra 20% off.
• Dam Secure (https://damsecure.ai/wizardry): Applied Wizardry listeners get their first month free.

• Justin McArthur, Executive Producer and Video Editor: https://www.linkedin.com/in/justin-mcarthur/
• Steph Hefferan, Editor: https://www.linkedin.com/in/steph-heff/

The frontier models that refuse to help you hack your own software are, paradoxically, making you less safe—while open weights models like DeepSeek Flash V4.1 will comply, cost a tenth as much as GPT-6, and find more vulnerabilities in the process. Patrick Collins and Simon Harloff from Dam Secure join Yaniv to explain why agent-built code needs typed languages, why PR gating has flipped from taboo to essential, and how compliance frameworks like SOC 2 are lagging years behind actual threats. They name specific red teaming tools, model providers, and infrastructure choices, and lay out a three-stage security factory that slots into automated software pipelines without slowing human engineers down.

• Open weights models like DeepSeek will comply with requests to find exploits that frontier models refuse, making them essential for defence even as they raise attacker capability.
• DeepSeek Flash V4.1 outperforms GPT-6 on Dam Secure's benchmark of 80 repositories at roughly one-tenth the cost, though it generates more false positives that need filtering.
• Switching from JavaScript or PHP to TypeScript—or any typed language—dramatically improves both LLM reasoning quality and security posture, with teams now auto-migrating codebases via agents running 40–100 hours unattended.
• Modern threat models require always-on automated red teaming rather than annual pen tests; specialist vendors include Harmony Intelligence, Shinobi, and Expo, with PromptFu for LLM-specific attacks.
• The best defensive setup chains tools together: linting guardrails during implementation, security review at PR time, and active exploitation attempts against findings via red teaming software.
• PR gating is now accepted because it blocks agents, not humans, and auto-approval of low-risk PRs is emerging—but compliance auditors still require human batch review every one to two weeks.
• Citizen coders using tools like Lovable or Base44 should treat output as prototype-only and have a skilled engineer review before production; unauthenticated routes and missing RLS policies are common failures.

• 00:00 Opening: Fight Fire with Fire
• 03:09 Open Source Vulnerabilities Accelerating
• 04:20 Burn the Bug Backlog
• 06:49 Typed Languages, No Exceptions
• 08:14 Infrastructure Choices
• 12:02 Always-On Red Teaming
• 16:08 The DeepSeek Advantage
• 19:15 Quantization and Provider Quality
• 26:12 Cutting Noise with Verification
• 29:36 Security in the Software Factory
• 34:12 PR Gating and Auto-Approval
• 37:42 Compliance vs Real Security
• 42:15 Actionable Advice by Role

• DeepSeek: https://www.deepseek.com
• Vercel: https://vercel.com
• Cloudflare: https://www.cloudflare.com
• Supabase: https://supabase.com
• Railway: https://railway.app
• OpenRouter: https://openrouter.ai
• Harmony Intelligence: https://harmonyintelligence.com
• Expo: https://expo.dev
• PromptFu: https://promptfu.com
• Lovable: https://lovable.dev
• GitHub: https://github.com

Patrick Collins and Simon Harloff are the founders of Dam Secure, a code security platform for AI-first engineering teams that builds adversarial agents to find vulnerabilities and runs model evaluations across 80 repositories to determine which LLMs are best at security review.

This episode is presented by SparkLaunch and Dam Secure.

• SparkLaunch (https://sparklaunch.io/wizardry): Applied Wizardry listeners get an extra 20% off.
• Dam Secure (https://damsecure.ai/wizardry): Applied Wizardry listeners get their first month free.

• Justin McArthur, Executive Producer and Video Editor: https://www.linkedin.com/in/justin-mcarthur/
• Steph Hefferan, Editor: https://www.linkedin.com/in/steph-heff/

The traditional GitHub-style pull request review is a waste of opportunity cost for most code changes in the agentic era. Yet simply removing it without a replacement invites complexity death spirals and unbounded product behaviour that agents cannot unwind. James McGill and Haziq Nordin join Yaniv to argue that engineers should stop reading diffs line-by-line and instead scan for architectural complexity, shift accountability to spec quality, and build new verification patchworks of end-to-end tests, fuzzing, and product review. The conversation is for any engineer or founder trying to extract real leverage from AI coding tools rather than bottlenecking them with cargo-cult process.

• Line-by-line diff review is dead for most changes; the value now lies in catching complexity death spirals that agents propagate across prompts.
• Data mutability, not code mutability, is the hard constraint—stateless frontend changes need far less scrutiny than anything touching persistent state.
• The engineer's role is shifting from writing code to steering agents, writing specs, and verifying behaviour through tests rather than inspecting implementation.
• Accountability structures must change too: if organisations remain blame-distribution systems, they will hedge to maximum review and forfeit AI leverage.
• Compliance inertia (SOC 2, ISO) still mandates 'thorough review', creating first-mover risk for teams redefining what review means.
• Codebase malleability is higher than ever, but unbounded complexity accumulates as context for future prompts and eventually collapses agent reliability.

• 00:00 The dead and the messy
• 02:50 Projector reviews to GitHub
• 04:53 What code review was for
• 06:31 Complexity as the last reason to read diffs
• 09:43 Code malleability, data hardness
• 15:13 Code review as accountability mechanism
• 18:12 Product review over code review
• 25:01 LLMs as spec compilers
• 32:10 Verification patchwork
• 36:02 Accountability and leverage
• 43:33 Where to find James and Haziq

• GitHub: https://github.com
• Enhance Labs: https://www.enhancelabs.com
• Actuals: https://www.actuals.ai

James McGill is a founding engineer at Actuals, building AI-native finance tools; Haziq Nordin is founder and CTO at Enhance Labs, working on product guardrails for agent-generated code.

This episode is presented by SparkLaunch and Dam Secure.

• SparkLaunch (https://sparklaunch.io/wizardry): Applied Wizardry listeners get an extra 20% off.
• Dam Secure (https://damsecure.ai/wizardry): Applied Wizardry listeners get their first month free.

• Justin McArthur, Executive Producer and Video Editor: https://www.linkedin.com/in/justin-mcarthur/
• Steph Hefferan, Editor: https://www.linkedin.com/in/steph-heff/

Peter Walker, Head of Insights at OpenRouter and previously at Carta, sees how about 120,000 US organisations use AI models every day. He expected their usage to spread across models. Instead, the typical organisation now uses about 12 models a month, with one daily driver taking most of the tokens and specialists around it. He and Yaniv get into why, in his view, the same model can get opposite reviews depending on who serves it, how cache rates quietly set the bill for agent workloads, why writing quality pushed Yaniv from Claude loyalty to using OpenAI too, and whether open-weight models are falling further behind the frontier. For engineers and founders deciding which models to run in production, it is a map of what actually decides what you get and what you pay.

• The inference provider layer, not just the model layer, now has 100 to 200+ competitors, and provider choice directly determines effective cost, latency, and data sovereignty.
• Cache hit rate is the dominant cost lever for agentic workloads: a cache miss can cost 50-100x more per token, and median agentic cache rates have climbed from ~50% to ~85% in 2026.
• Most organisations use a 'hub and spoke' model architecture with one 'daily driver' taking the majority of tokens and spend, plus specialised models for departments like customer support or sales.
• Zero data retention claims vary in trustworthiness by jurisdiction and provider size; some stealth models on OpenRouter are free specifically because they are not ZDR.
• The gap between frontier and open-weight models is widening in raw capability but narrowing in perceived value, as daily tasks saturate below frontier intelligence.
• Reasoning-only models and jagged intelligence are driving demand for fast decision models like Jev and OpenAI's decision model for latency-critical paths.

• 00:00 The New Complexity
• 03:29 Provider Layer Competition
• 05:31 Choosing a Provider
• 08:04 Data Retention Realities
• 12:01 Model Portfolios
• 14:45 Latency and Reasoning
• 17:51 Cache Economics
• 22:57 Cost-Performance Sweet Spot
• 25:46 What Comes Next
• 28:35 Open Weight vs Frontier
• 31:24 Specialisation and Product
• 33:36 Where to Follow Peter

• OpenRouter: https://openrouter.ai
• OpenRouter Data: https://openrouter.ai/data
• DeepSeek: https://www.deepseek.com
• Anthropic: https://www.anthropic.com
• OpenAI: https://openai.com
• Google AI: https://ai.google
• Cerebras: https://www.cerebras.net
• CoreWeave: https://www.coreweave.com
• ElevenLabs: https://elevenlabs.io
• Artificial Analysis: https://artificialanalysis.ai
• Groq: https://groq.com

Peter Walker is Head of Insights at OpenRouter, where he analyses how models and inference providers are used across the platform. He previously led insights at Carta.

This episode is presented by SparkLaunch and Dam Secure.

• SparkLaunch (https://sparklaunch.io/wizardry): Applied Wizardry listeners get an extra 20% off.
• Dam Secure (https://damsecure.ai/wizardry): Applied Wizardry listeners get their first month free.

• Justin McArthur, Executive Producer and Video Editor: https://www.linkedin.com/in/justin-mcarthur/
• Steph Hefferan, Editor: https://www.linkedin.com/in/steph-heff/

Dave Slutzkin, co-founder of Antiburn, joins Yaniv to break down what actually drives token costs in agentic development and how to bring them down. They cover how caching differs between Anthropic and OpenAI, when to reach for which model and thinking mode, and why the habit of compaction matters more than any other optimisation. If you're spending real money on AI-assisted development, you'll come away with concrete tactics for cutting token burn without cutting capability.

• Context window depth is the dominant driver of token cost; compacting actively at 200,000-300,000 tokens matters more than any other single action.
• Cache expiry behaviour differs materially between providers: Anthropic's cache expires at exactly 1 hour, OpenAI's Codex cache is best-effort and often drops in 5-20 minutes, but OpenAI subscriptions do not charge for cache writes while Anthropic subscriptions effectively do through quota.
• Using a frontier model with a simple prompt to delegate to cheaper subagents is a practical pattern that balances capability and cost without requiring complex harness engineering.
• High thinking modes often produce worse results than medium or low because models overthink, invent requirements, and fix unrelated bugs; the benchmark sweet spot is typically medium.
• Skills files, MCPs, auto-memories, and system prompts silently bloat context windows; regular clean-up every month or two reduces both cost and quality degradation.
• Fast mode costs 2.5x per token but can improve output quality through tighter interaction loops; it is best used deliberately rather than left on by default.

• 00:00 The Token Burn Problem
• 02:34 Three Stages of Adoption
• 06:25 Model Choices Multiplying
• 10:36 The Cardinal Mistake: Depth
• 17:35 Worst-Case Usage Patterns
• 21:35 Picking Models by Feel
• 29:45 Thinking Modes and Overthinking
• 34:45 Fast Mode Trade-offs
• 48:08 Caching: Anthropic vs OpenAI
• 51:51 Context Window Ceiling
• 55:54 Cleaning Up Context Bloat
• 56:08 Where to Find Dave

• Antiburn: https://antiburn.com
• Anthropic Claude: https://www.anthropic.com
• OpenAI Codex: https://openai.com/codex
• Harvey: https://www.harvey.ai
• Legora: https://legora.com

Co-founder of Antiburn, a company that helps developers understand and optimise their token spend for AI-assisted coding.

This episode is presented by SparkLaunch and Dam Secure.

• SparkLaunch (https://sparklaunch.io/wizardry): Applied Wizardry listeners get an extra 20% off.
• Dam Secure (https://damsecure.ai/wizardry): Applied Wizardry listeners get their first month free.

• Justin McArthur, Executive Producer and Video Editor: https://www.linkedin.com/in/justin-mcarthur/
• Steph Hefferan, Editor: https://www.linkedin.com/in/steph-heff/