🏡 Real Estate AI Agent: Auckland House Finder using Runner H

Hasitha Palihena — Mon, 30 Jun 2025 01:11:13 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

I want you to: 1. Search Task * Go to google.com and search for houses for sale in the Auckland region, New Zealand. * Apply the following filters: * Price: Under NZD \$700,000 * Bedrooms: At least 3 bedrooms * Area: Must be in a safe neighbourhood * Preference for properties: * Close to Auckland CBD * Near public transport * Good potential for price appreciation in the future * Suitable for long-term living 2. Extract & Record Data For each matching property, extract and record the following details into a Google Sheet: * Property address * Price * Number of bedrooms * Property description * Safety indicators (if available) * Proximity to CBD and public transport * Any information about market growth potential * Listing URL 3. Open Home Automation * If the property has any open home scheduled: * Add the open home event to Google Calendar with: * Property address * Date and time of the open home * Link to the listing 4. Slack Notification * Check Google Calendar daily. * For each open home scheduled for the next day, send a reminder message in Slack with: * Property address * Open home date and time * Link to listing * Any special notes

The Problem It Solves

Manually filtering through real estate listings and coordinating open home visits is time-consuming. My automation solves this by:

Automatically finding homes that match budget and lifestyle needs
Logging detailed listings into a spreadsheet for comparison
Scheduling open homes into your calendar
Sending Slack reminders before viewings

Demo

👉 (Youtube Link : - https://www.youtube.com/watch?v=RfBTkWaMz3A&ab_channel=DevOpsandAI)

A Google Sheet with property details
Google Calendar with open home events
Slack message showing the open home reminder

How I Used Runner H

I used Runner H to chain multiple actions into a seamless workflow:

Web Search Agent

Query Google for houses in the Auckland region under \$700K with 3+ bedrooms, good public transport access, and long-term investment potential.

Data Extraction & Logging

Extract key details: address, price, bedrooms, description, and proximity to CBD/transport.
Add the extracted data to a Google Sheet for easy viewing and tracking.

Open Home Scheduling

If open homes are listed, the agent schedules them directly into Google Calendar.

Slack Integration

The day before an open home, a Slack message is sent with the details and link to the listing.

How to Replicate My Workflow

Clone or build a Runner H workflow with:

A search & scrape agent
Google Sheets write access
Google Calendar integration
Slack webhook or direct message support

Use the following task prompt (adaptable):

“Find houses for sale under \$700,000 in Auckland, NZ with at least 3 bedrooms in safe areas. Prefer proximity to CBD and public transport. Record results to a Google Sheet, add open homes to Google Calendar, and notify via Slack one day before.”

Authorize access to Sheets, Calendar, and Slack through Runner H connectors.

Use Case & Impact

🏘️ Ideal Users:

First-time homebuyers
Real estate agents
Property investors looking for growth areas

🚀 Impact:

Saves hours of manual searching
Reduces missed open homes
Provides a centralized, up-to-date log of viable listings

📣 Social Love

Shared on Twitter/X: https://x.com/hasithapalihena/status/1939496245162397997

How I Built a Multiplayer AWS Trivia Game Using AI (And You Can Too!)

Hasitha Palihena — Sun, 29 Jun 2025 21:00:46 +0000

From zero to hero: My journey building a complete multiplayer game with Amazon Q CLI in just 2 Days!

The Spark That Started Everything

Picture this: you're scrolling through AWS community forums when you stumble upon the AWS Community Challenge: Build Games with Amazon Q CLI. As a developer who's always looking for the next exciting project, I thought, "Why not build something that actually helps people while showcasing what AI can do?"

That's how my AWS Trivia Game adventure began. What started as a simple idea turned into a journey that completely changed how I think about AI-assisted development.

Why AWS Trivia? The Problem I Wanted to Solve

Let's be honest – studying for AWS certifications can be mind-numbingly boring. You're reading through endless documentation, trying to memorize service names and features. I've been there, and I know you have too.

I wanted to create something that would make learning AWS actually fun. Here's what drove my decision:

The Learning Problem: AWS knowledge is crucial for cloud professionals, but traditional study methods are dry and forgettable.

The Community Gap: There weren't many interactive tools that made AWS learning engaging and social.

The Technical Challenge: Building a real-time multiplayer game would push both my skills and AI assistance to their limits.

The Vision: Create something that could grow from a simple terminal game to a full-featured web application with animations, sound effects, and mobile support.

What I Actually Built (Spoiler: It's Pretty Cool)

The final product exceeded my wildest expectations:

Multiple ways to play: Web browser, terminal, and desktop GUI
Real-time multiplayer: Up to 10 players can compete simultaneously
Mobile-friendly: QR codes for easy mobile access
Engaging UX: Animations, sound effects, and responsive design
Flexible deployment: Works on everything from static hosting to full servers

The AI Revolution: How Smart Prompting Changed Everything

Here's where things get interesting. Working with Amazon Q CLI taught me that AI assistance is only as good as your communication with it. Let me share the prompting techniques that transformed my development process.

Before and After: The Prompting Transformation

My Old Approach (didn't work well):

"Help me fix this networking bug"

My New Approach (game-changer):

I'm building a multiplayer trivia game with Socket.IO. Players connect successfully, but they're receiving questions at different times – some get them 2-3 seconds after others. Here's my current server code [code snippet]. I need all players in a game session to receive questions simultaneously for fair gameplay. What's the best way to synchronize this?

Why the second approach works better:

Specific technology stack mentioned (Socket.IO)
Clear problem description with symptoms
Desired outcome explicitly stated
Relevant code context provided

The "Building Blocks" Approach

Instead of asking AI to build everything at once, I learned to break things down:

Phase 1: "Create a basic Flask server that handles Socket.IO connections"
Phase 2: "Add room management for game sessions"
Phase 3: "Implement synchronized question broadcasting"
Phase 4: "Add real-time scoring and leaderboards"

This approach led to better, more maintainable code.

The Power of Constraints

I discovered that being specific about limitations actually improved the solutions:

Create a web interface for the trivia game that:
- Works perfectly on mobile devices
- Functions without JavaScript (progressive enhancement)
- Supports 10 concurrent players without lag
- Includes accessibility features for screen readers
- Has offline mode for single-player practice

Architecture-First Thinking

Before diving into code, I learned to ask for architectural guidance:

I want to build a trivia game supporting both real-time multiplayer and static single-player modes. What architecture would let me:
1. Deploy multiplayer version to cloud platforms
2. Maintain consistent user experience

Real Problems, AI Solutions: The Technical Deep Dive

Let me share some of the most impressive moments where AI solved complex challenges that would have taken me hours or days to figure out.

Challenge #1: Perfect Timing in Multiplayer Games

The Problem: In multiplayer trivia, fairness is everything. If some players get questions even a second before others, the game becomes unfair.

The AI Solution: Amazon Q suggested a server-side synchronization approach that I never would have thought of:

@socketio.on('start_game')
def handle_start_game():
    room = session.get('room')
    if room and room in games:
        game = games[room]
        if len(game['players']) >= 2:
            # Tell everyone the game is starting
            socketio.emit('game_starting', {'countdown': 3}, room=room)

            # Use precise timing to ensure fairness
            def start_questions():
                time.sleep(3)  # Countdown period
                send_next_question(room)

            threading.Thread(target=start_questions).start()

What impressed me: The AI immediately recognized this as a distributed systems problem and provided a solution accounting for network latency.

Challenge #2: One Codebase, Multiple Platforms

The Problem: I wanted the game to work on web browsers, terminal applications, and desktop GUIs without maintaining separate codebases.

The AI Solution: A brilliant abstraction layer approach:

class GameClient:
    def __init__(self, interface_type):
        self.interface = self._create_interface(interface_type)

    def _create_interface(self, interface_type):
        interfaces = {
            'web': WebInterface(),
            'terminal': TerminalInterface(),
            'gui': GUIInterface()
        }
        return interfaces.get(interface_type, TerminalInterface())

    def display_question(self, question_data):
        self.interface.render_question(question_data)

    def show_results(self, results):
        self.interface.render_results(results)

The insight: Instead of building three separate apps, create one game engine with swappable interfaces.

Challenge #3: Handling the Unexpected

The Problem: What happens when players disconnect mid-game? You can't just crash the game for everyone else.

The AI Solution: A robust state management system that keeps the game running smoothly:

class GameState:
    def __init__(self):
        self.players = {}
        self.disconnected_players = {}
        self.current_question = 0
        self.question_start_time = None

    def handle_disconnect(self, player_id):
        if player_id in self.players:
            # Save their progress
            self.disconnected_players[player_id] = self.players[player_id]
            del self.players[player_id]

            # Keep the game going if possible
            if len(self.players) >= 1:
                self.notify_others_of_disconnect(player_id)
            else:
                self.pause_game()

    def handle_reconnect(self, player_id, socket_id):
        if player_id in self.disconnected_players:
            # Welcome them back with their score intact
            player_data = self.disconnected_players[player_id]
            player_data['socket_id'] = socket_id
            self.players[player_id] = player_data
            del self.disconnected_players[player_id]

            # Bring them up to speed
            self.sync_player_state(player_id)

The Time-Saving Miracles: When AI Handles the Boring Stuff

Some of the biggest wins came from AI handling tasks I dreaded doing manually.

Automated Testing Suite (Saved 6+ Hours)

Instead of writing test cases one by one, I simply asked:

"Generate comprehensive tests for my multiplayer trivia game, including edge cases for connections, disconnections, timing, and scoring"

Result: A complete test suite with 25+ scenarios:

import unittest
import threading
import time

class TestMultiplayerGame(unittest.TestCase):
    def setUp(self):
        self.game_server = GameServer()
        self.test_players = ['Alice', 'Bob', 'Charlie']

    def test_simultaneous_connections(self):
        """What happens when everyone joins at once?"""
        threads = []
        results = []

        def connect_player(nickname):
            result = self.game_server.add_player(nickname)
            results.append(result)

        # Simulate the rush hour scenario
        for player in self.test_players:
            thread = threading.Thread(target=connect_player, args=(player,))
            threads.append(thread)
            thread.start()

        for thread in threads:
            thread.join()

        # Everyone should get in successfully
        self.assertEqual(len(results), 3)
        self.assertTrue(all(r['success'] for r in results))

    def test_question_timing_fairness(self):
        """Ensure fair play - everyone gets questions simultaneously"""
        for player in self.test_players:
            self.game_server.add_player(player)

        start_time = time.time()
        self.game_server.start_game()

        # Check delivery timing
        delivery_times = self.game_server.get_question_delivery_times()
        timing_difference = max(delivery_times) - min(delivery_times)

        # Must be within 100ms for fairness
        self.assertLess(timing_difference, 0.1)

The Creative Surprises: When AI Thinks Outside the Box

Some of the coolest features came from AI suggesting solutions I never would have considered.

Adaptive Difficulty System

My Challenge: Keeping games fun for both AWS beginners and experts.

AI's Smart Solution: Dynamic difficulty adjustment based on player performance:

class QuestionManager:
    def __init__(self):
        self.questions = self.load_questions()
        self.difficulty_weights = {'easy': 0.4, 'medium': 0.4, 'hard': 0.2}

    def adjust_difficulty(self, player_scores):
        """Make the game harder or easier based on how everyone's doing"""
        avg_score = sum(player_scores.values()) / len(player_scores)

        if avg_score > 0.8:  # Everyone's crushing it
            self.difficulty_weights = {'easy': 0.2, 'medium': 0.4, 'hard': 0.4}
        elif avg_score < 0.4:  # Everyone's struggling
            self.difficulty_weights = {'easy': 0.6, 'medium': 0.3, 'hard': 0.1}
        else:  # Just right
            self.difficulty_weights = {'easy': 0.4, 'medium': 0.4, 'hard': 0.2}

    def select_next_question(self, used_questions, player_scores):
        self.adjust_difficulty(player_scores)

        available = [q for q in self.questions if q['id'] not in used_questions]

        # Weight questions by current difficulty preference
        weighted_questions = []
        for difficulty, weight in self.difficulty_weights.items():
            difficulty_questions = [q for q in available if q['difficulty'] == difficulty]
            weighted_questions.extend(difficulty_questions * int(weight * 10))

        return random.choice(weighted_questions) if weighted_questions else None

The Numbers Don't Lie: Real Impact, Real Time Savings

Let me be completely transparent about the results:

What I Built:

3 different client interfaces (web, terminal, desktop)
Multiple deployment options (static, server, local)
Advanced features (animations, sounds, QR codes, performance monitoring)
Production-ready architecture (multiplayer, graceful degradation, cross-platform)
Comprehensive testing and documentation

Time Investment:

With AI assistance: ~40 hours over 2 weeks
Estimated without AI: 120+ hours (3x longer)

The 3x speedup came from:

Dramatically reduced research time
Fewer debugging sessions (AI code often worked first try)
Automated boilerplate generation
Comprehensive testing created automatically
Cross-platform compatibility handled seamlessly

Lessons Learned: The Real Secrets of AI-Assisted Development

After this intensive project, here are the insights that will change how you work with AI:

1. AI is an Architecture Genius

Amazon Q consistently provided well-structured, scalable code following established patterns. It doesn't just solve immediate problems – it thinks about maintainability and future growth.

2. Collaboration Beats Dictation

The best results came from iterative conversations, not one-shot requests. Think of AI as a senior developer pair programming with you.

3. Context is Your Superpower

The more background information I provided about project goals, constraints, and existing code, the better the suggestions became. Detailed prompts yield detailed solutions.

4. AI Excels at the Tedious Tasks

Configuration files, test suites, documentation, compatibility code – the important but time-consuming work that developers often postpone. AI handles these exceptionally well.

5. Creative Solutions Emerge from Open Questions

Some of the most impressive solutions came when I presented challenges without prescribing approaches. AI often suggested creative solutions I wouldn't have considered.

The Future is Collaborative: What This Means for Developers

This project convinced me that AI-assisted development isn't about replacing programmers – it's about amplifying human creativity and ambition. With AI handling routine tasks, we can focus on:

User experience and design
Creative problem-solving
Architecture and system design
Business logic and domain expertise

The AWS Trivia Game started as a simple educational tool and became a showcase of what's possible when human creativity meets AI capability.

Ready to Try It Yourself?

The complete AWS Trivia Game is open source and waiting for you to explore:

🎮 Play the Game: Experience the web version with animations and sound effects
🔍 Explore the Code: See AI-assisted development in action
🤝 Contribute: Add questions, features, or improvements
🚀 Build Your Own: Use this as inspiration for your next AI-powered project

Whether you're a seasoned developer or just starting out, this project demonstrates that with the right approach to AI assistance, you can build bigger, better applications faster than ever before.

What's Your Next AI-Powered Project?

The future of development is collaborative – between humans and AI. This trivia game is just the beginning of what's possible when we combine human creativity with AI capability.

Are you ready to transform your development process? Start with a clear problem you want to solve, learn effective prompting techniques, and don't be afraid to think bigger than you normally would. AI assistance might just surprise you with what becomes possible.

🎯 Try the AWS Trivia Game: Live Demo
📚 Explore the Code: GitHub Repository
👨‍💻 Connect with the Developer: Hasitha Dulanjana
🏆 Original Challenge: AWS Community Challenge

DEV Community: Hasitha Palihena