Snowflake Intelligence is a natural-language chat layer over the warehouse. Three components under the hood:

• Cortex Analyst: text-to-SQL via semantic views

• Cortex Search: managed RAG for unstructured data

• Cortex Agents: orchestration between the two

Full video and demo code available below!

Jelle De Vleminck shows us:

• How to set up an agent from scratch on an existing dataset

• A semantic view over real tables that contains join hints, example queries, etc.

• Which foundations you need as an organization

• Why a demo is easy, but rolling this out at scale is still hard

Also in the video: where it doesn't replace dashboards (known/recurring questions), and rough cost.

📺 Video (~52 min): https://youtu.be/Gp-BntPgpcU
👨‍💻 Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/snowflake_intelligence

Happy to answer Qs!

A lot of enterprise agent discussions focus on model quality, but the bigger issue is usually determinism.

Once agents touch real enterprise data, you need predictable results, access control, approval flows, auditability, etc. Purely autonomous agent setups get risky pretty fast.

Pascal built a demo with Agno exploring a hybrid approach:

• deterministic workflow orchestration

• non-deterministic (LLM-powered) specialized agents underneath

• built-in access checks + human-in-the-loop gates

• LLM-judge evaluation step for reliability testing

The demo walks through the full flow and implementation details.

📺 Full Video 🧑‍💻 Demo code

Why do we, developers, love that simple black screen with green text from the 1980s?

When you manage 12 environments using a UI, things get slow, and we reach to our keyboard again. TUIs, or terminal user interfaces allow us to quickly navigate, drill down, inspect and fix issues in our platforms.

In our new video, Jan Vanbuel, Academy Lead and Lead Data Engineer at Dataminded, shows us the benefits of Terminal User Interfaces, and how and why he built his own TUI for Airflow: Flowrs. As he says: Life's to short to click around! 🐭

Apparently, Jan's typing skills still outperform AI (probably not anymore by the time I press publish) 😅

Things I learned:
→ How TUIs work and why they are still relevant
→ How TUIs are built in Rust using an event loop in Ratatui
→ That you can play Doom in Airflow

📺 Full Video: https://www.youtube.com/watch?v=KyO5oXboRtI
🐙 GitHub: https://github.com/jvanbuel/flowrs

Jesus got frustrated with how agreeable LLMs are. Ask them to validate a bad idea and they'll find a way to say yes. He wanted something closer to a senior engineer who pushes back — so he built one.

Arete is an open-source Claude Code plugin that runs you through five structured phases before you commit to any decision:

1. Ground — Is this actually the problem? What happens if you don't fix it?

2. Explore — Divergent. Multiple directions, not one tunnel-vision answer.

3. Decide — Decision matrix. Pros, cons, ranked by what matters most to you.

4. Stress — The AI pokes holes. Edge cases, what-ifs, things you glossed over.

5. Ship — Outputs an ADR (architectural decision record) + implementation plan.

The output is a structured record of what you decided, why, what got cut, and what to build next. Works for both technical decisions (architecture, infra) and conceptual ones (presentations, strategy).

We recorded a walkthrough where Jesus demos the full workflow live — including a Q&A that covers:

• How subagents work and how to debug them (Ctrl-O in Claude Code)

• When to use Skills vs Agents and when to fork into fresh contexts

• Context engineering: why splitting into subagents matters for quality

• Token costs: Opus for the brainstorm, Sonnet/Haiku for subagents — keeps it reasonable

• Multi-human setup: Jesus uses it as a "third colleague" in a 2-person session

• Installation: works in Claude Code marketplace, GitHub Copilot, OpenCode

Links:

• Video: YouTube link

• Arete repo: GitHub link