DEV Community: Marco Dodaro

From Zero to AWTRIX App in 30 Minutes: Vibe Coding with Home Assistant, Yahoo Finance and a LED Matrix

Marco Dodaro — Thu, 05 Feb 2026 16:48:37 +0000

💡 There's something very satisfying about seeing your code literally light up on an LED matrix in your living room. ✨

This little project started as a "what if" and turned into a working AWTRIX 3 app in about 30 minutes, built live with AI as a coding buddy ("vibe coding" style).
The goal: show live Yahoo Finance stock data on an AWTRIX 3, with colors and icons that react to the market in real time, all driven by Home Assistant blueprints. 📈

🚀 What we built

In half an hour, the setup ended up as:

A Home Assistant blueprint that:
- Reads stock data from the Yahoo Finance integration
- Formats text like AAPL 190.25€ (+1.32%)
- Picks an icon and color based on percentage change
- Pushes everything to AWTRIX 3 via MQTT as a custom app
A small ecosystem around it:
- GitHub repo: ha-awtrix-yahoofinance-stock
- Blueprint YAML
- README with one‑click import for Home Assistant
- MIT license

Check out the repo:

Yahoo Finance stock app: 👉 https://github.com/Raythekool/ha-awtrix-yahoofinance-stock

🧱 The stack

The tech is intentionally simple:

Home Assistant blueprints (no custom component needed)
Yahoo Finance integration for live stock data
MQTT to talk to AWTRIX 3
AWTRIX 3 as the LED matrix display (compatible with devices like Ulanzi TC001)

The core logic is basically:

Read sensor.yahoofinance_*
Grab regularMarketChangePercent
Decide:
- If change > threshold → green + "up" icon 📈
- If change < −threshold → red + "down" icon 📉
- Else → white + neutral icon ⚪
Publish a JSON payload to awtrix_device/custom/stock_app_name

But instead of hand‑crafting everything from scratch, the AI handled:

Turning an ad‑hoc script into a clean, reusable blueprint
Adding options for:
- Threshold
- Lifetime
- Repeat count
- Scroll speed
- Currency symbol
Generating a full README and import badge for Home Assistant
Creating a new GitHub repo and wiring the files correctly

🎧 Vibe coding: pairing with AI instead of building alone

The interesting part wasn't the complexity (there isn't much), but the workflow:

Start from a tiny working script:
- "Here's my stock display script for AWTRIX."
Ask the AI to:
- Turn it into a blueprint
- Make it configurable
- Generalize it to multiple devices
- Add icon‑upload automation
Let the AI:
- Generate the YAML
- Wire topics for multiple AWTRIX devices
- Add sensible defaults
- Produce proper documentation in English

That back‑and‑forth is what made it feel like vibe coding: you keep the vision and constraints, the AI does the boilerplate, refactors, and docs while you stay in flow. 🧠🤝💻

🛠 How to try it yourself

Rough steps (see the repo for details):

Install AWTRIX 3 on your device and connect it to MQTT.
Install the Yahoo Finance integration in Home Assistant.
Import the blueprint via the My Home Assistant button in the README: awtrix_stock_display.yaml from https://github.com/Raythekool/ha-awtrix-yahoofinance-stock
Create an automation from the blueprint:
- Pick your stock sensor (e.g. sensor.yahoofinance_aapl)
- Choose an app name (e.g. stock_aapl)
- Tweak threshold, repeat, scroll speed, etc.
Watch your AWTRIX display live stock data with reactive colors and icons. 🌈

💭 Why this matters

This wasn't about reinventing finance dashboards. It was about:

Turning a "small quality‑of‑life idea" into a polished integration quickly
Using AI as a companion to:
- Avoid YAML fatigue
- Keep things DRY and reusable
- Ship with proper docs and structure from day one
Making Home Assistant + AWTRIX 3 feel more like a creative canvas than a config chore 🎨

If you've been sitting on a tiny Home Assistant idea that "isn't worth the time", pairing with an AI and aiming for a 30‑minute build is surprisingly effective. Start from a script, extract the pattern into a blueprint, wrap it in a repo—and suddenly you have something you can share with the rest of the community. ✨

📝 TL;DR

Built a complete Home Assistant blueprint for displaying Yahoo Finance stocks on AWTRIX 3 LED matrix in ~30 minutes using AI-assisted "vibe coding". The blueprint reads stock data, formats it with dynamic colors (green/red/white) and icons based on market changes, and pushes to AWTRIX via MQTT. Fully configurable (threshold, currency, scroll speed) with one-click import for Home Assistant.

Repo: https://github.com/Raythekool/ha-awtrix-yahoofinance-stock

Takeaway: Small home automation ideas become shippable projects incredibly fast when you pair with AI for the boilerplate, YAML, and documentation work. 🚀

Building a Smart Case Categorization System in Dynamics 365 with AI-Driven Development

Marco Dodaro — Thu, 11 Dec 2025 10:27:29 +0000

How a development team leveraged AI-driven prompts, structured documentation, and automated testing to build an enterprise-grade hierarchical case management system through continuous test-and-fix automation

💼 Introduction

Picture this: you're asked to build a D365 Customer Service demo with an intelligent case management solution that needs to handle complex hierarchical categorization across multiple business units, maintain enterprise-grade performance, and deliver a stellar user experience. Oh, and you have the usual impossibly tight deadlines. Sound familiar?

Instead of diving into traditional development hell, our team decided to experiment with something pretty wild - a sophisticated case categorization system built using AI-assisted development patterns that completely flipped our usual approach on its head.

The magic happens with hierarchical dropdown filtering plus AI-powered auto-suggestions, but here's the kicker - everything was built using "vibe coding." Yep, we're talking about using natural language prompts and well-structured instruction docs to let AI handle the heavy lifting of complex technical implementations.

The result? We delivered rock-solid enterprise functionality through continuous automated test-and-fix cycles that kept production quality high while cutting development time by 70%. Not too shabby!

🎯 The Business Challenge

Let's be honest - enterprise case management is a beast. Organizations need smart case routing that can juggle complex hierarchical categorization across different business units while keeping data quality pristine and users happy.

Key Requirements:

• Hierarchical filtering - Business Unit → Service Category → Issue Type cascading
• Data quality assurance - Validation across 300+ possible combinations
• Scalable architecture - Support for complex organizational structures
• User experience - Intuitive interface with sub-second response times

🤖 AI-Driven Development Approach

Here's where things get interesting. The team's game-changing approach revolved around "vibe coding" - essentially having conversations with AI using well-crafted instruction frameworks and natural language prompts to tackle complex technical implementations.

Instead of the usual coding grind, we built detailed instruction docs that work like architectural blueprints and AI cheat sheets rolled into one. These specialized instruction frameworks (basically markdown files) cover everything from data model patterns to JavaScript integration strategies - giving AI a really good playbook for prompt-driven development.

The result? Lightning-fast iteration cycles with enterprise-grade quality that transforms technical documentation from boring static reference material into dynamic development superpowers.

📋 Architecture Through Documentation

Here's the cool part - the architecture uses three-tier hierarchical filtering, all designed through documentation frameworks that work for both humans and AI. Pretty clever, right?

The system architecture breaks down like this:

Data Layer: Global option sets with 300+ hierarchical combinations (yeah, it's a lot!) managed through structured schemas
Business Logic: JavaScript frameworks that handle all the cascade logic and AI-powered auto-population magic
User Interface: Responsive forms with smart field enablement and validation that actually makes sense
Testing Infrastructure: Automated validation with continuous improvement cycles (because who has time for manual testing?)
Documentation System: Living instruction frameworks that evolve with your requirements - they're never static!

⚙️ Development Workflow

Okay, this is where the magic really happens. The development process completely flipped traditional enterprise software development on its head through AI-assisted requirement analysis and implementation - basically creating a smooth highway from business needs to working solutions.

Phase 1: Requirements Analysis and Data Model Design
The team kicked things off by having a conversation with AI about the business requirements - no fancy documentation needed, just natural language descriptions. The AI dug into the hierarchical case categorization needs and churned out comprehensive YAML specifications that included:
• Entity structures with proper relationships and cascading hierarchies
• Field definitions with appropriate data types and validation rules
• Option set configurations for the three-tier filtering system
• Implementation ready to introduce patterns for AI-powered auto-suggestion capabilities

Phase 2: Dataverse Implementation with PACX and AppMaker
With the AI-generated specs in hand, the team got to work implementing the data model in Dataverse - and here's where the tools really shine:
• PACX CLI Extended handled all the heavy lifting - creating tables, columns, and relationships straight from the YAML specs, all managed by AI Agent through documented command patterns
• AppMaker MCP Server worked its magic by auto-generating enterprise-grade forms and views with proper field layouts and responsive designs
• Set up those global option sets with 300+ hierarchical combinations for the cascading dropdown system (trust me, you don't want to do this manually)

Phase 3: AI-Generated Business Logic
Now for the fun part - with the data structure ready, the developers simply asked AI to generate the JavaScript business logic:

# AI-guided schema creation following instruction patterns
Create hierarchical option sets with:
- Level 1: Business units (9 options, numeric values 100000000-100000008)
- Level 2: Service categories (40+ options mapped to L1)
- Level 3: Issue types (200+ options mapped to L2)
Follow naming convention: ava_fieldnamecode pattern

• Built form configurations through prompt-driven development (basically just describing what you want in plain English), resulting in something like:

// AI-generated cascade logic following instruction frameworks
function onBusinessUnitChange(executionContext) {
    var formContext = executionContext.getFormContext();
    var selectedUnit = formContext.getAttribute("ava_level1code").getValue();

    // Clear and repopulate dependent dropdowns
    var categoryControl = formContext.getControl("ava_level2code");
    filterOptions(categoryControl, selectedUnit);
}

Phase 4: Comprehensive Testing and Continuous Improvement
Time for the real test - literally. We brought in Playwright to create comprehensive test suites that put the entire system through its paces:
• Automated testing of all 300+ hierarchical combinations and cascade behaviors (because manually testing that would take forever)
• AI suggestion functionality testing across various business scenarios
• Test-Fix-Test Cycles: Here's the game-changer - when Playwright found issues, the AI agent acted autonomously to analyze problems, generate fixes, implement solutions, and re-test automatically. No more late nights debugging!

This iterative workflow let the team deliver rock-solid enterprise functionality with a strong reduction in development time while keeping quality standards sky-high through continuous automated validation. Without AI, we'd probably still be debugging the first dropdown!

🧪 Automated Testing Through AI

Here's where things get really cool. The Playwright-based testing strategy completely transformed quality assurance by using intelligent automation that spots issues and kicks off immediate resolution cycles.

Test-Fix-Deploy Automation:
The real breakthrough was those continuous test-and-fix cycles. Picture this: when automated testing finds issues, the system jumps into action:
• Analyzes problems using instruction frameworks for context (like having an AI debugging buddy)
• Generates fixes through AI-driven code analysis and correction
• Implements solutions following established patterns and quality standards
• Validates results through comprehensive re-testing of affected functionality

Real-Time Browser Testing:

// AI-generated test scenarios following instruction patterns
test('hierarchy cascade functionality', async ({ page }) => {
  await page.selectOption('[data-id="level1"]', '100000000');

  // Verify L2 population with AI-validated assertions
  const l2Options = await page.locator('[data-id="level2"] option').count();
  expect(l2Options).toBeGreaterThan(1);

  // Test AI suggestion trigger
  await page.check('[data-id="ai_suggestion"]');
  await expect(page.locator('.notification')).toContainText('categorized');
});

Performance Results:
• Issue resolution: Minutes instead of hours through automated fix cycles
• Test coverage: 10+ business scenarios with automated validation

🛠️ Tools and Technologies

Let's talk about the tools that made this magic happen. The implementation used a killer combination of specialized tools that made AI-driven development actually work:

Core Development Tools:
• PACX CLI Extended - Your Swiss Army knife for Dataverse operations, table creation, and relationship management that became our foundation for lightning-fast schema creation and deployment through documented command patterns
• AppMaker MCP Server - The secret sauce for automated form and view generation in Dynamics 365 that powered AI-driven form design and validation while keeping everything enterprise-ready
• Playwright - End-to-end testing framework that handles automated browser testing and validation like a champ, managing comprehensive test automation with smart failure detection and resolution cycles

These tools became the backbone of our AI-assisted development workflow, creating seamless integration between natural language prompts and technical implementation while keeping enterprise-grade quality standards intact.

🎯 TL;DR

AI-driven D365 development with instruction frameworks + automated test-fix cycles = faster delivery of enterprise-grade hierarchical case management.

Technical Stack: PACX CLI + AppMaker MCP + Playwright + structured prompts → Complex 300+ option cascading dropdowns with AI auto-categorization

Key Win: Natural language prompts → Production-ready JavaScript business logic → Automated quality assurance cycles

Bottom Line: Prompt-driven development patterns enable enterprise scalability while maintaining code quality through continuous automated validation.

Ready to dive into AI-assisted development? Start building those instruction frameworks and see how natural language can become your secret development superpower! 🚀

Have you tried AI-driven development in your projects? We'd love to hear about your wins, fails, and "wait, that actually worked?" moments in the comments below!