Skip to content
Sign in
Artwork for Technology Explorations in Data & AI
TechnologyEducationHow To

Technology Explorations in Data & AI

Dataminded

Deep dives and practical demos on the technologies shaping modern data and AI development. Join the Dataminded team as we explore, unbox, and critically review the latest tools, from building AI agents and RAG systems to optimizing cloud costs and accelerating data pipelines. We cut through the hype to show you what actually works in real data engineering practice, complete with demo code!

Play
Open in
  • 15 episodes
  • Avg 26 min
  • English

Episodes 15

NewestOldestLongest
All15Unplayed15In progress0Played0
  • S2 · E14
    May 19 · 42 min

    Metric Views in Databricks: The Missing Layer for AI Agents

    AI is only as good as the layer underneath it. That layer in Databricks is called a Metric View: a semantic model that defines your measures, your joins, and the rules for how data fits together. In this episode, Stefan walks through the full stack end-to-end on a real LEGO dataset: building Metric Views in Databricks, generating them with dbt, deploying through Databricks Asset Bundles, and finally exposing it all through a Genie Space that business users can chat with. Along the way we get into some deeper questions: what the limits of metric views look like, how access control works, what BI "shifting left" actually means for engineering teams, and how you organize this in data products. If you saw our Snowflake Intelligence episode, this is the Databricks counterpart. The Snowflake episode can be found here: https://www.youtube.com/watch?v=Gp-BntPgpcU Resources: - Demo code: https://github.com/datamindedbe/demo-technology-exploration - [episode-specific links here] Creators & Guests Jonny Daenen - Host Stefan Van Raemdonck - Guest --- Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb (00:00) - Chapter 1 (00:00) - Intro (00:50) - Meet Stefan (01:43) - Demo: talking to your LEGO data (07:17) - Why semantic layers? Data products explained (11:20) - What's in a metric view? (14:15) - Creating Metric Views in Databricks (16:29) - The LEGO data model (18:17) - Data Products & Metric Views in Databricks (22:07) - Are we limited to predefined measures? (23:16) - Building: native Databricks SQL bundles (29:12) - Building: dbt (31:16) - Maintenance and BI shifting left (33:59) - Deploying dbt on Databricks (35:29) - Creating the Genie Space (38:24) - Access Control and Permissions in Data Queries (39:28) - Writing SQL on top of Metric Views (40:10) - Takeaways and favorite Lego --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E13
    May 7 · 52 min

    Snowflake Intelligence: The End of Dashboards?

    Your dashboards only answer the questions you thought of last quarter. Every new question is a ticket, a dependency, or a gut call. Snowflake Intelligence wants to fix that -- a chat interface on top of governed enterprise data that turns plain English into SQL, runs it, and gives you a chart back. No analysts involved. Jelle builds the full setup live: semantic view, verified queries, Cortex Agent, access control. They get honest about what this actually requires -- data quality, governance, and whether Snowflake is worth the cost. Resources: - Snowflake Intelligence docs: https://docs.snowflake.com/en/user-guide/snowflake-intelligence - Demo code: https://github.com/datamindedbe/demo-technology-exploration Creators & Guests Jonny Daenen - Host Jelle De Vleminck - Guest --- Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
  • S2 · E12
    April 23 · 22 min

    AI Workflows in Agno: Building Deterministic Agents

    Enterprise data is full of sensitive information: different teams, different access rights, different rules. When you ask an AI agent a simple question and get "access denied," it's not a permissions bug. It's a design problem. Pascal has been exploring how to tackle this using Agno, an agent framework built around deterministic workflows. Instead of letting a single agent roam freely across your data, Agno lets you build specialized agents, each with its own access rules and instructions. Workflows orchestrate these agents with guardrails that keep humans in the loop when it matters. In this episode, Pascal Knapen, CTO at Dataminded, demos the full flow: from a natural language question, through an access check, to a verified answer. We explore how skills differ from workflows, how Agno handles dynamic agent creation and deployment, and how LLM-based evaluations act as a quality judge for agent responses. Additional Resources: Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/agno-workflows Creators & Guests Pascal Knapen - Guest Jonny Daenen - Host --- Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb (00:00) - Intro: AI agents and enterprise data (01:50) - Two ways to give AI access to your data (03:23) - Skills vs Workflows (04:45) - Demo: AI with controlled data access (07:45) - The workflow is deterministic - the agents aren't (09:13) - Demo: evaluations & reliability (11:00) - Code walkthrough with Agno (17:45) - Why Agno? An honest take (19:46) - Identity & exposing as an API (20:24) - Takeaways --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E11
    April 8 · 23 min

    Managing Airflow at Scale using the Flowrs TUI

    Jan opens 12 browser tabs every morning to check overnight pipelines. Log in, check, close. Twelve times. So he built a terminal app instead. Flowrs is a TUI for Apache Airflow written in Rust. Navigate all your environments from the keyboard, drill into failed tasks, tail live logs, bulk-mark runs -- no browser, no mouse. In this episode Jan demos it live, walks through the architecture of a TUI (event loop, state, render), compares the main frameworks (Ratatui, Bubble Tea, Textual), and gives his honest take on whether agents will eventually replace tools like this. "Go forth and mulTUIply. Life is too short to click around." Resources: - Install Flowrs: brew install flowrs - GitHub: https://github.com/janbvanbuel/flowrs --- Creators & Guests Jonny Daenen - Host Jan Vanbuel - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb (00:00) - Introduction (01:17) - What is Flowrs & Airflow? (03:27) - Demo: Flowrs in action (10:18) - The evolution of CLIs and TUIs (13:07) - Why not just use agents? (14:25) - TUI frameworks: Bubble Tea, Textual, Ratatui (15:21) - What's up with the Rust hype? (16:51) - Building the Flowrs UI (19:20) - How to install Flowrs yourself (22:34) - Takeaways & what's next --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E10
    March 10 · 32 min

    Building an AI Agent with Subagents and Skills

    Every time you ask AI for help, it agrees. Fast, confident, and it never tells you your plan has holes. That's the problem Arete is built to fix. Jesus built a brainstorm agent on Claude Code skills that guides you through five phases -- Ground, Explore, Decide, Stress, Ship -- before you commit to anything. The output is an architectural decision record and an implementation plan you actually own. In this episode he demos it live, shows how parallel subagents work without polluting your main context, and answers the honest questions: tokens burned, vendor lock-in, debugging subagents, and whether this works with a team. Resources: - Install Arete: https://github.com/jesgarram/arete - Demo code: https://github.com/datamindedbe/demo-technology-exploration --- Creators & Guests Jonny Daenen - Host Jesús García Ramírez - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb (00:00) - Intro & meeting Arete (01:38) - The 5-step brainstorm workflow (04:05) - Meta: This video was made with an AI skill (06:02) - The demo: ground, explore, decide, stress, ship (14:56) - Example results: ADR and Plan (17:23) - Subagents and context engineering (21:12) - Demo: the Researcher Agent (22:48) - Practical concerns: vendor, files, big projects (25:30) - How many tokens does it burn? (26:51) - Control, agents vs skills, multi-human (29:44) - How to install Arete (30:44) - Wrap-up --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E9
    February 24 · 25 min

    From Prompts to Agents: AI Agent Skills in Claude Code

    AI agents get messy fast once you move beyond simple prompts. Context windows fill up with noise, agents start reasoning in loops, and suddenly you're dealing with brittle behavior and hallucinations. Jesus walks through how Claude Code skills fix this -- packaging repeatable workflows into modular components that load only when needed. He demos two real examples: an Explain Code skill and a PR Review skill that forks context, limits tool permissions, and uses CLI commands to analyze pull requests. Resources: - Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/agent_skills - Anthropic docs: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview - Skills standard: https://agentskills.io - Curious about MCP? https://youtu.be/fIr55-koOJQ --- Creators & Guests Jonny Daenen - Host Jesús García Ramírez - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb (00:00) - Introduction (01:28) - Demo: Skills in Claude Code (05:57) - How agents work: from prompts to context engineering (08:19) - What are Skills? (vs MCP, RAG, Commands) (10:33) - Building your own Skill (15:20) - Skills vs MCPs (16:29) - What about hallucinations? (17:07) - Specs and Anthropic's Skill Guide (19:28) - Skillception: a skill to create skills (20:34) - Is MCP history? (22:50) - Sharing skills & wrap-up --- Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E8
    February 2 · 25 min

    Azure Log Analytics Costs Are Out of Control - Here's How We Cut Them by 60%

    Azure Log Analytics costs often take up 20% or more of a cloud bill, even though most teams only check logs when something breaks. Azure's default analytics logs are powerful, but they're also expensive and often unnecessary for day-to-day log inspection. Switching application logs to Basic Logs can reduce Log Analytics costs by up to 60%. In this episode, Niels walks us through a real customer case where logging costs dropped by thousands per year. They explain the difference between Analytics, Basic, and Auxiliary logs, show when Basic Logs are sufficient, and discuss practical setups using Azure Container Insights and FluentBit. This includes building a custom FluentBit plugin in Go as well as real-world gotchas like missing short-lived pods and why dynamic credentials matter. Creators & Guests Jonny Daenen - Host Niels Claeys - Guest Resources: Custom FluentBit plugin: https://github.com/nclaeys/fluent-bit-go-azure Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Chapters: (00:00) - Intro: why optimize Azure log costs? (03:10) - What kind of logs are we dealing with? (06:13) - Plan types & the cost difference (09:59) - FluentBit vs Azure Container Insights (13:33) - How FluentBit works in K8S (16:41) - Can you lose log data? (17:36) - A custom plugin for Azure Workload Identity (21:05) - Why not use Azure Container Insights? (22:35) - Do all clients benefit? (23:41) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S2 · E7
    January 21 · 22 min

    AI Code Reviews with CodeRabbit and Sourcery

    Code reviews are often considered a pain, resulting in quick approvals and bugs reaching production. CodeRabbit and Sourcery aim to solve this by letting an AI agent review your changes early on. In this episode, data & platform engineer Hannes De Smet shows Jonny what he learned after exploring several AI Code Reviewers. Hannes demos both tools on a real code change, allowing a critical look at the quality of the suggestions, as well as the user experience. It turns out that, depending on the context, both could use some improvements. Resources: CodeRabbit: https://www.coderabbit.ai Sourcery: https://www.sourcery.ai/ Multi-workspace AI video: https://www.youtube.com/watch?v=E_kOAvmeTJ0 Note: This video is not sponsored or affiliated with CodeRabbit or Sourcery. Creators & Guests Jonny Daenen - Host Hannes De Smet - Guest Resources: Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Chapters: (00:00) - Intro: why AI code reviews? (02:53) - AI Reviewer 1: CodeRabbit (10:32) - What CodeRabbit catches (and misses) (12:18) - When AI comments become noise (80% disregard) (13:27) - Catching a PII issue (15:15) - AI Reviewer 2: Sourcery (19:14) - Cost & comparison (19:59) - What's the future of AI code reviews? (20:41) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E6
    Dec 23, 2025 · 19 min

    Cross-Project AI Code Assistance using Cursor Workspaces

    Emil shows how to let his Cursor AI access and manipulate multiple projects at the same time. He does this by leveraging the Cursor Workspace feature, which enables you to link multiple repositories together. His demo shows how to increase application resources, which also needs a Terraform change in a second project. Along the way, we discover how important human involvement still is... You'll learn how to: Set up Cursor workspaces with multiple projects Let your agent access and manipulate multiple codebases Leverage best practices from previous projects Be mindful that human involvement is still important Resources: VSCode Workspace feature: https://code.visualstudio.com/docs/editing/workspaces/workspaces Cursor Rules docs: https://cursor.com/docs/context/rules MCP 101: https://www.youtube.com/watch?v=fIr55-koOJQ Postgres MCP in Cursor: https://www.youtube.com/watch?v=tbrR21I3jJI Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Creators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters: (00:00) - Intro & setting up a Cursor Workspace (03:21) - Demo: upgrading application memory (06:46) - Did we cheat? (08:16) - When are Workspaces most useful? (09:37) - Out with monorepos for data products? (10:15) - Best practices + read-only repos (12:17) - Learning & exploring codebases (13:24) - How Emil solved a production incident (14:40) - The future of monorepos? (15:54) - How this works with Cursor Rules (17:21) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E5
    Dec 8, 2025 · 20 min

    Build a RAG-based Agent with MindsDB

    In this Technical Exploration, Jonny and Tarik show how to build a fully functioning RAG-based AI agent using MindsDB, turning internal data from Postgres, Slack, or Google Drive into a queryable knowledge base powered by semantic search. You'll see how to: Convert internal documents into a semantic knowledge base Make Google Drive & Slack data queryable in minutes Build a custom AI Agent on top of your knowledge bases Run MindsDB locally with Docker Use SQL to configure agents, connectors, and knowledge bases Expose your agent through a simple API for app integration We also touch on: Chunking & embedding strategies Local vs. cloud LLMs How MindsDB compares to full ETL approaches Resources: Demo code: https://github.com/datamindedbe/demo-technology-exploration/ Previous episode (PyAirbyte): https://youtu.be/eLUQrSqP-ns Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Note: This video is not sponsored or affiliated with MindsDB. Creators & Guests Jonny Daenen - Host Tarik Jamoulle - Guest Chapters: (00:00) - Intro: What is MindsDB? (02:03) - Scope and dataset (03:08) - Quick tour: connectors & UI (06:34) - Components: Source, Knowledge Base & Agent (06:55) - Agent demo + how MindsDB queries data (08:36) - The code: getting MindsDB running (11:27) - Q&A: embedding times & creating your agent (14:03) - A Slack agent in 5 minutes (17:19) - Multi-knowledge-base agents (18:23) - Q: Integrating with SDK & MCP (19:31) - Takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E4
    Nov 18, 2025 · 17 min

    Data Ingestion using PyAirbyte

    Move your Google Drive documents straight into Postgres using Python and PyAirbyte. In this Technical Explorations episode, Jonny and Tarik from Dataminded show how they ingest internal meeting transcripts (Facts at Breakfast, Learning Over Lunch) from Google Drive into a relational table, ready for querying and AI use cases. You'll see how to: Configure PyAirbyte to read from a Google Drive folder Authenticate with a Google service account (JSON key) Convert Airbyte output into a clean pandas DataFrame Load the processed data into a Postgres table Discuss performance limits, API rate limits, and batching Reflect on when PyAirbyte is great for PoCs vs. production setups We also touch on: How many connectors Airbyte offers and what PyAirbyte can reuse Trade-offs of code-first ingestion vs. point-and-click UI Ideas for the next step: using MindsDB and LLMs to query this knowledge base Resources: Demo code: https://github.com/datamindedbe/demo-technology-exploration/ Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Creators & Guests Jonny Daenen - Host Tarik Jamoulle - Guest Chapters: (00:00) - Intro (01:18) - What is Airbyte? (and 600+ connectors) (04:11) - Demo: Google Drive → Postgres (09:22) - Q: How do you get the table structure? (10:43) - Scale & format limits (many files, PDFs, images) (12:45) - Setting up Google Drive: auth & permissions (14:44) - Running it in production: Airflow + Docker (15:15) - Next up: MindsDB + verdict Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E3
    Nov 3, 2025 · 21 min

    Accelerate Data Engineering using MCP Tools

    Emil Krause & Jonny Daenen explore how to accelerate dbt development by integrating MCP (Model Context Protocol) with Postgres and Cursor. Emil demonstrates how to solve a database bug by allowing AI agents to interact directly with databases. They discuss the setup of a database MCP server, demonstrate its capabilities in troubleshooting data inconsistencies, and highlight the importance of understanding data even when using advanced tools. The conversation also touches on the potential pitfalls of using such tools and the need for technical expertise in leveraging them effectively. Resources: Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/postgres_mcp MCP 101: https://www.youtube.com/watch?v=fIr55-koOJQ Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Creators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters: (00:00) - Introduction: MCP + Postgres (02:20) - Demo: debugging salary percentiles (06:29) - Creating and testing dbt models (07:11) - Benefits and dangers of AI assistance (09:42) - Setting up Postgres MCP in Cursor (12:57) - Challenges & pitfalls (14:54) - MCP vs semantic models (17:16) - Other dev tasks (18:39) - Claude Desktop vs Cursor (19:59) - Summary Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • Oct 23, 2025 · 14 min

    AWS Outage: When The Cloud Fails...

    In this special episode on the AWS outage, Stijn De Haes explains what happened during the AWS October 2025 Outage. He then zooms in on the limited effect it had on Dataminded and its product Conveyor. Finally, Stijn gives 4 tips on how to protect yourself from this kind of outage. Resources: Blog post: https://hubs.li/Q03PQKrR0 Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Creators & Guests Jonny Daenen - Host Stijn De Haes - Guest Chapters: (00:00) - Intro (00:33) - What happened in the AWS outage? (05:04) - How the outage affected Dataminded (08:31) - 4 mitigations to protect yourself (11:53) - Tabletop exercises for preparedness (13:51) - Summary Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E2
    Oct 21, 2025 · 34 min

    MCP 101: The Model Context Protocol for AI Agents

    In this conversation, Jonny Daenen and Pierre Crochelet explore the Model Context Protocol (MCP), a framework that enhances AI assistants by allowing them to perform various tasks through tools, resources, and prompts. They discuss the architecture of MCP, how to build an MCP server, and the developer flow for creating tools. The conversation also touches on the compatibility of MCP with different AI agents and the user experience, highlighting both the potential and limitations of the protocol. Resources: Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/claude_mcp MCP servers: https://github.com/modelcontextprotocol/servers MCP directory: https://mcp.so/ Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Creators & Guests Jonny Daenen - Host Pierre Crochelet - Guest Chapters: (00:00) - Introduction (01:03) - Demo: Claude Desktop & MCP (04:43) - What is the Model Context Protocol? (07:09) - Tools, Resources & Prompts (08:20) - The protocol: Host-Client-Server (11:05) - Building your own MCP server (16:46) - Prompts, resources & tool functionality (19:45) - Developer flow & the Inspector (23:31) - Function limitations & return types (26:34) - Testing the tool & integrating other agents (28:46) - Community MCP servers & current limitations (32:11) - Summary & next steps Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
  • S1 · E1
    Oct 13, 2025 · 20 min

    Whisper & SuperWhisper: 3x Faster Prompting with Speech-to-text?

    Emil Krause and Jonny Daenen explore the claim that speech-to-text makes you three times as fast. Emil shows the functionalities and benefits of SuperWhisper and Whisper Assistant, two innovative speech-to-text tools designed to enhance productivity. They discuss the installation process, user experience, and the accuracy of these tools. Emil shares insights on how these tools can streamline workflows, particularly for those who frequently interact with AI, and emphasizes the importance of context in dictation. It turns out that SuperWhisper gives much better accuracy when it comes to technical terms. Resources: Whisper Assistant: https://marketplace.visualstudio.com/items?itemName=MartinOpenSky.whisper-assistant SuperWhisper: https://superwhisper.com/ Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb Note: This video is not sponsored or affiliated with Whisper Assistant or SuperWhisper. Creators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters: (00:00) - Intro: Whisper Assistant vs SuperWhisper (03:17) - Demo: Whisper Assistant (07:27) - Demo: SuperWhisper (10:24) - File tagging (12:01) - Personal take: which one for you? (14:17) - Installation & setup (17:09) - Final thoughts & recommendations Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype. Music by Aleksandr Karabanov from Pixabay

    • Transcript
    • Chapters
Showing 1–15 of 15 episodes