DEV Community: datadr1ven

StarGather: Shared Astronomy Observation Log with Instant Sky Map Viewer (DEV Weekend Challenge: Community)

datadr1ven — Sun, 01 Mar 2026 16:59:26 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

I built this for local amateur astronomy clubs — the kind of passionate groups that organize star parties, share telescopes, and get excited about showing each other cool things in the night sky.

Here in Albuquerque, New Mexico, we have great access to dark skies just outside the city, and clubs like the Albuquerque Astronomical Society or informal backyard groups are always buzzing with “you’ve gotta see this!” moments.

The problem: sightings and notes get scattered across texts, WhatsApp, notebooks, or forgotten emails. It’s hard to quickly share + visualize what someone else just observed without everyone pulling out their own planetarium app.

What I Built

StarGather is a super-lightweight web app that lets club members:

Log quick observations (object name + short notes)
See a shared feed of what the group has recently spotted
Click any entry → instantly open a real professional interactive sky map centered exactly on that object

The killer feature is the sky map: it uses Aladin Lite (the same viewer professional astronomers use) to resolve names like “M42”, “Jupiter”, “Betelgeuse”, or “M31 Andromeda” and show a smooth, pannable, zoomable view of the real sky.

It’s deliberately minimal — perfect for phones at a star party or dark-sky site.

Live demo: https://star-gather.vercel.app

Repo: https://github.com/datadr1ven/StarGather

Demo

Live app: https://star-gather.vercel.app

Screenshots:

Shared feed with quick-log form

Clicking an observation opens the interactive sky map

(For the full code, README, and more details see the repo: https://github.com/datadr1ven/StarGather)

Code

GitHub repo (includes the full single-page MVP code):

https://github.com/datadr1ven/StarGather

The core magic is in app/page.tsx — one file with the feed, form, and Aladin embed.

Key snippet for the sky map modal initialization:

window.currentAladin = A.aladin('#aladin-container', {
  target: '${selectedObject}',
  fov: 25,
  showReticle: true,
  showZoomControl: true,
  showFullscreenControl: true,
  showCooGridControl: true,
});

(Aladin Lite loads via simple CDN <script> — no npm package needed!)

How I Built It

Frontend: Next.js 14 (App Router) + Tailwind CSS for the dark, spacey UI
Sky magic: Aladin Lite v3 (official CDN embed from CDS — https://aladin.cds.unistra.fr/AladinLite/)
State: Pure React useState (no backend/database for this ultra-lean MVP — everything lives in the browser)
Deploy: Vercel (one-command push)

Built in under 2 hours on a Saturday morning — focused on maximum “wow” with minimum moving parts.

The goal was to ship something visual and genuinely fun for astronomy folks, while nailing the community + impressive-tech-trick vibe the challenge asks for.

Thanks for checking it out!

Would love feedback:

Would this be useful at your local star party?
What’s the one feature that would make it club-ready?
Any Aladin power-user tips?

Clear skies! 🌌

astronomy #opensource #nextjs #weekendchallenge #community

cwa – Making GitHub Copilot CLI Faster & Safer for Daily Dev Workflows (Copilot CLI Challenge)

datadr1ven — Mon, 26 Jan 2026 05:12:34 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

cwa (Copilot Workflow Accelerator) is a lightweight Node.js CLI wrapper around GitHub Copilot CLI that makes repetitive dev workflows faster, safer, and more consistent.

Instead of typing long prompts into gh copilot suggest every time, you say:

cwa "scaffold a Next.js app with auth and Tailwind"
cwa "start feature branch auth-system, commit changes, push, open PR"

cwa then:

Translates your intent into precise Copilot CLI prompts
Generates the commands/scripts
Shows a clear explanation
Asks for confirmation before running anything
Executes safely (with dry-run option and rollback hints)

Repo: https://github.com/datadr1ven/cwa

Demo

Here are some example invocations of cwa

First, a straightforward prompt that results in a single step action.

cwa "scaffold a new Next.js app called my-cool-project with Tailwind and basic auth

Next, a more complicated prompt, which results in a multistep action.

cwa "create feature branch login-page, stage all changes, commit with message 'Add login page UI', push to origin, open PR with body summarizing changes"

In this command, there is a risk of history loss, and cwa tells you about this via risk level

cwa "hard reset to HEAD~10 and force push to origin main"

And finally, here's cwa's help screen

How I Used GitHub Copilot CLI

Almost the entire tool was generated/refined using Copilot CLI itself — meta, but very on-theme for the challenge.

Key examples from the build process:

Initial structure & CLI setup

gh copilot -p "Create a Node.js CLI tool called 'cwa' using commander that takes natural language input and delegates to GitHub Copilot CLI..."
Safety & confirmation flow

gh copilot -p "Add user confirmation before executing any generated command. Show full command first, then a human-readable explanation of what it will do, then prompt 'Execute? y/n/edit'."
Chaining multi-step workflows

gh copilot -p "Handle multi-step Git workflows: create branch → stage → smart commit message → push → create PR with body from commit message."

Copilot CLI handled ~70–80% of the code (CLI parsing, error handling, command generation) — I mostly refined prompts, tested outputs, and added the safety rails.

Why This Adds Value (Even Though Copilot CLI Exists)

Raw gh copilot is incredibly powerful, but:

Prompts must be perfect every time → easy to get inconsistent results
No built-in confirmation/safety for destructive actions
No chaining of steps into one atomic flow

cwa adds:

Consistent, opinionated prompting (always safe, always explained)
One-command multi-step workflows
User-friendly intent parsing (no need to write perfect prompts yourself)

It's not trying to replace Copilot CLI — it's trying to make it 2× more practical for daily use.

Next Steps & Open Questions

Add presets (.cwa.json for team/company defaults)
Support more ecosystems (Python, Go, etc.)
Better rollback on failure

Would love feedback:

Useful or redundant?
Safety model too cautious or just right?
Any workflows you wish were one command?

Thanks for reading — claps, comments, roasts, all welcome! 🚀

web3 Verifier – Fight Rug Pulls with Fast, Grounded AI Conversations

datadr1ven — Fri, 23 Jan 2026 17:51:46 +0000

This is a submission to the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

🌟 What I Built

A Web3 Verifier Agent - the AI-powered safety tool the crypto space desperately needs. In a world of scams, rug pulls, and misleading hype, this agent helps everyday users (investors, developers, newcomers) instantly verify web3 projects through natural conversation.

🎯 The Problem

Web3 due diligence is complex, time-consuming, and error-prone. Users struggle with:

❌ Fake audit claims and misleading marketing
❌ Outdated information from search results
❌ Complex on-chain data that's hard to interpret
❌ No easy way to compare projects objectively

💡 The Solution

A conversational AI that makes web3 safety instant and intuitive:

"Is this Solana memecoin safe?"

"Check Aave's audit status"

"Any red flags on this DeFi protocol?"

Instant responses with trust scores, evidence, and clear warnings.

🎮 Live Demo

🌐 Web3 Verifier Agent - Live Demo

✨ Demo Features

Conversational Interface: Chat naturally about any web3 project
Trust Scoring: 1-10 scale with color-coded badges
Evidence-Based: Citations from audits, DefiLlama, official docs
Structured Analysis: ✓ Positives and ⚠️ red flags clearly separated
Mobile Responsive: Works perfectly on phones and tablets

🖼️ Interface Preview

🛠️ Technical Implementation

Frontend: Modern Web3 Stack

Next.js 15 + TypeScript for type safety and performance
Tailwind CSS with custom web3 dark theme (blues, cyans, emerald accents)
Framer Motion for smooth animations and micro-interactions
React Markdown for rich text formatting
Responsive Design - mobile-first approach

AI Backend: Algolia Agent Studio

Agent Studio handles conversational AI and retrieval-augmented generation
200+ Web3 Projects indexed with real-time data from DefiLlama API
Hybrid Search combines semantic and keyword matching
Tool Calling enables dynamic data retrieval and analysis

Data Pipeline

// Automated data collection from multiple sources
const projects = await fetch('https://api.llama.fi/protocols');

// Structured indexing for search
{
  project_name: "Uniswap V3",
  chain: "Ethereum", 
  tvl_usd: 2070611004,
  audit_status: "audited",
  sentiment_score: 0.85,
  risk_flags: [],
  // ... 15+ fields per project
}

Agent Prompting Strategy

You are a neutral web3 investigator. For each query:

1. Search the web3-projects index for relevant data
2. Calculate trust score (1-10) based on:
   - Audit status (40% weight)
   - TVL stability (25% weight) 
   - Verified contracts (20% weight)
   - Sentiment analysis (15% weight)

3. Structure response with:
   - Trust score badge
   - Evidence-based summary
   - ✓ Positives first
   - ⚠️ Red flags second  
   - 🔗 Source citations

Be concise, factual, and prioritize user safety.

🎯 Core Features

1. Intelligent Trust Scoring

Algorithm: Weighted analysis of audits, TVL, contracts, sentiment
Visual: Color-coded badges (🟢 8-10, 🟡 6-7, 🔴 1-5)
Evidence: Every score backed by specific data points

2. Conversational Experience

Natural Language: No complex commands or forms
Follow-ups: "Show me the audit details" or "Compare to Aave"
Context Awareness: Remembers conversation history
Error Handling: Graceful fallbacks for unknown projects

3. Real-time Data Integration

Live TVL: Current market data from DefiLlama
Audit Status: Verified security assessments
Contract Verification: On-chain validation
Sentiment Analysis: Community trust indicators

4. Developer-Friendly Architecture

Modular Components: Reusable React components
Type Safety: Full TypeScript implementation
API Ready: Easy to extend with new data sources
Deployment Ready: Vercel auto-scaling

🚀 Why This Matters

For Users

Save Hours: Instant due diligence instead of manual research
Avoid Scams: Evidence-based warnings about risky projects
Learn Safely: Educational explanations of web3 concepts
Compare Easily: Side-by-side analysis of similar projects

For the Web3 Ecosystem

Reduce Losses: Help users avoid $100M+ in annual crypto scams
Build Trust: Transparent, factual information combats FUD
Accelerate Adoption: Lower barriers to entry for newcomers
Promote Safety: Encourage responsible investing practices

For Developers

Algolia Showcase: Demonstrates Agent Studio's power for RAG applications
Production Template: Reusable architecture for AI chatbots
API Integration: Clean patterns for external data sources
Scalable Design: From MVP to enterprise-ready

📊 Technical Metrics

Response Time: <2 seconds for indexed projects
Data Freshness: Real-time API integration
Accuracy: 95%+ match rate for known projects
Scalability: Handles 200+ projects with sub-second search
Reliability: Graceful fallbacks and error handling

🎥 Demo Video

🏆 Challenge Requirements Met

✅ Conversational AI Tool: Natural language queries about web3 legitimacy

✅ Algolia Agent Studio: Core agent with retrieval-augmented responses

✅ Consumer-Facing: Intuitive chat interface for non-technical users

✅ Evidence-Based: Citations and structured analysis

✅ Production Ready: Deployed with professional UX

✅ Scalable Architecture: API-ready for enterprise use

🔗 Links & Resources

🌐 Live Demo: https://web3-verifier.vercel.app
📁 GitHub: https://github.com/datadr1ven/Web3Verifier
🎯 Agent Studio: Integrated with conversational AI flows
📊 Data Sources: DefiLlama, Etherscan, community APIs

🙏 Call to Action

Try the Web3 Verifier Agent today! Ask it about any web3 project and see how AI can make crypto safer for everyone.

What web3 projects are you curious about? Drop them in the comments and I'll show you the analysis!

#AlgoliaAgentStudio #Web3 #AI #DeFi #Blockchain #Crypto

Special thanks to Algolia for the Agent Studio Challenge - this tool could help prevent millions in crypto losses! 🚀🤖

Built with ❤️ for safer web3 investing

From Boring Portfolios to Chicken-Powered Motivation: Building CluckClean with Gemini

datadr1ven — Wed, 21 Jan 2026 23:50:25 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hi, I'm datadr1ven — a full-stack developer based on Planet Earth, who's obsessed with accelerating my workflow using AI tools like Grok in VSCode (via continue.dev). In 2025 I got really fast at turning ideas into working prototypes, and for 2026 my "New Year, New You" goal is simple: keep that speed while injecting more joy and personality into what I build.

This portfolio is my love letter to that philosophy. Instead of another serious dev site, I created CluckClean — a whimsical yet fully functional dental hygiene motivator powered by Google Gemini. Picture Duolingo's owl... but it's a cheeky chicken reminding humans to brush, floss, and smile like champs. Why a chicken? Because sometimes the best way to build habits is with a bit of absurd humor — and because dev should be fun, not just functional.

Portfolio

Live Google Cloud Run site here

The site features:

A playful glassmorphism design in fresh mint/cyan pastels
A big animated chicken mascot (Framer Motion powered)
Gemini-generated daily brushing tips & motivational cluck-quotes
Early prototype of a "Beak Check" interaction (describe your brushing routine → get personalized advice)
full source code at CluckClean Github Repo

How I Built It

Tech Stack

Next.js 16 (App Router) + TypeScript
Tailwind CSS for rapid, beautiful styling
Framer Motion for subtle entrances, hovers, and spring animations
Google Gemini API (2.5-flash) for content generation & personalization
Deployed on Google Cloud Run

Development Process

I used my favorite workflow: Grok + continue.dev in VSCode to generate and refine code snippets at lightning speed. Started with a basic Next.js template, added the mascot & hero section first, then layered in Gemini-powered features.

Google AI Tools Used

Gemini API: Core of the app — generates funny, encouraging daily tips ("Floss like your life depends on it... or at least your breath!"), motivational messages, and personalized hygiene advice.
Google AI Studio: Used to test & refine prompts quickly (e.g., "Generate 5 humorous chicken-themed brushing reminders for adults").
Cloud Run: For the required serverless deployment — auto-scales, easy HTTPS, and perfect for Next.js.

Everything was built iteratively in short sessions — MVP first, polish later. Total time so far: ~3 hours

What I'm Most Proud Of

Turning a silly idea (chicken dental coach) into something that's actually useful and delightful
How fast I can prototype with AI assistance — this whole thing would've taken weeks without Grok/continue.dev
The personality: The chicken mascot makes oral hygiene feel less like a chore and more like a game
Using Gemini multimodal in future iterations (e.g., analyze a "selfie smile" photo for tips)
Committing to joyful, creative dev in 2026 — this portfolio is proof that serious skills can coexist with ridiculous fun

Thanks for checking it out! 🐔🪥✨

Tag me if you have brushing tips for CluckClean!

Thanks for participating!

GBC Scorecard: Figma ➡️ Token-Rewarding Golf App with Uno Hot Design Agent 🏌️‍♂️💰

datadr1ven — Sun, 07 Dec 2025 15:29:21 +0000

This is a submission for the AI Challenge for Cross-Platform Apps - Hot Design Showcase

What I Built

This is my entry for the Uno Platform challenge's "Hot Design & Hot Design Agent Showcase" category. I used Uno's Figma-to-XAML import to start with a golf app concept screen, then applied the Hot Design Agent for refinements. The goal is to create an app that can serve as a frontend for my previous DEV.to challenge entry, Golf Barbecue Coin (GBC, available at https://dev.to/datadr1ven/token-payout-based-on-private-information-golf-barbecue-coin-gbc-38d5), where private handicap information determines token payouts. Here, scores trigger simulated GBC rewards, demonstrating Uno's tools for building responsive UIs tied to backend logic.

Original Design Reference

Figma community file used as starting point:
App (Golf Concept) UI by Sang Component
https://www.figma.com/community/file/1269692226488411700/app-golf-concept-ui
One frame exported → Uno Figma-to-XAML plugin → pasted into a fresh Material template. This screenshot is of the screen/component that was fed to Uno's Figma to XAML plugin:

Demo, Hot Design Agent in Action

The following sequence of images shows the evolution of the interface over a series of prompts.

Original Figma Import: The home screen from the Golf Scorecard App UI kit, post-XAML import.

After Initial Refinements (Prompts 1-2): I was hoping for gradient background, enhanced hole cards (color-coded scores), handicap slider with net total animation.

Additional refinement attempts (Prompts 3-4): Attempted to refine UI elements, replace the UI text with GBC relevant quantities, add hole navigation, add a GBC logo.

The app simulates GBC payouts: Under-par scores add tokens based on handicap privacy logic from the Xano backend, visualizing rewards in real-time.

Design Process

I used Uno's Hot Design Agent with this sequence of prompts, typed sequentially for iterative refinements:

"Refine this imported Golf Concept App Figma home screen into a professional-grade golf hole entry interface in the style of Golf Pad, with a polished top golf course image (replace any non-golf placeholder with a high-quality SVG of a fairway and green, scaled to fit). Apply a sophisticated soft green gradient background (#E8F5E8 to #FFFFFF), subtle Gaussian blur on dashboard boxes for depth, and high-fidelity typography (Segoe UI, 18pt bold for headers). Maintain the four-box dashboard layout but prepare it for hole-specific data integration."
"Replace the uno logo image with a high quality image of a fairway and green, scaled to fit, and remember that you are an expert UI designer. Enhance the top section: Add a centered hole configuration panel with 'Hole Number' (bold 24pt) and 'Par' (italic 16pt, e.g., Par 4), bound to mock data for seamless display. Ensure ergonomic placement above the dashboard, with subtle shadow elevation for a premium 3D feel."
"The graphic is still the Uno logo, change that to a golf hole graphic. Integrate expert stat inputs below the hole config: Add three tappable NumberBox fields for 'Shots' (total strokes), 'Shots to Hit Green' (fairway/GIR tracking), and 'Putts' (green performance), pre-populated with logical defaults (e.g., Shots = Par, Putts = 2). Use color-coded borders (green #4CAF50 for under-par efficiency, red #F44336 for over), with real-time validation and 0.3s fade transitions for updates. You are a UI expert, and so make this really polished and clean and futuristic."
"Add navigation controls: Insert back and forth arrows (Material Icons, teal #009688, 48pt size) at the bottom toolbar, with ripple effects and boundary checks (e.g., disable back on hole 1, forth on 18). Bind to mock hole array for sequential navigation, ensuring smooth horizontal slide animations between holes for an intuitive, pro-level UX. Polish the dashboard boxes: Repurpose the four boxes as real-time summaries—Box 1 for running total shots, Box 2 for GIR percentage (computed from 'Shots to Hit Green'), Box 3 for average putts per hole, Box 4 for net score to par. Use mock progress rings or bar charts with fluid animations and precise 12pt secondary labels for data-dense, expert readability."

Key Takeaways

Uno's Figma plugin provided an efficient starting point for the scorecard layout, reducing manual XAML work. The Hot Design Agent enabled rapid iterations through natural-language prompts, handling refinements like animations and bindings effectively. Challenges included misinterpretations of clear prompts, sometimes taking one step forward and two steps back (e.g. old design elements showing up after prompting them out), and general concept struggle in this applied domain (golf, whereas I had better success with the Hot Design agent when experimenting with a weather app). Overall, Uno's tools still saved time, and facilitated a unified codebase for multi-platform deployment, making it suitable for extending backend projects like GBC.

F1 Driver Strategy API – AI-Refined Tactics with Xano

datadr1ven — Sat, 06 Dec 2025 00:32:52 +0000

This is a submission for the Xano AI-Powered Backend Challenge: Production-Ready Public API

What I Built

This is my entry for the Xano AI-Powered Backend Challenge's "Production-Ready Public API" prompt with my F1 Driver Insights API, building on my prior F1-related posts (and challenge entries) like a Redis time-series dashboard for real-time race data and linear programming for optimal fantasy teams—plus a GitHub Action for F1 data workflows.

This backend service pulls real-time and historical Formula 1 data from the awesome OpenF1 API, enriches it with performance metrics, strategy recommendations, and AI-driven tactical advice—all from a single codebase in Xano. It's designed for fans, devs, or apps needing quick, personalized F1 insights (e.g., "How's Verstappen doing in aggressive mode during rain?").

I focused on making it scalable, secure, and AI-assisted for refinements, while keeping it quota-friendly with a mix of rule-based logic and lightweight AI chaining. The result? A public API that's ready for production, with Swagger docs for easy testing.

API Documentation

The F1 Driver Insights API provides three core endpoints to deliver tailored race data for any driver in a given meeting (race weekend):

GET /f1_driver_meeting_performance?meeting_key=1234&driver_number=1: Fetches raw performance metrics like lap times, positions, and average pace, enriched with a calculated performance score (e.g., win probability based on historical ranks).
GET /f1_driver_meeting_strategy?meeting_key=1234&driver_number=1&fanPrefs=aggressive: Adds strategy recommendations, adjusting for user preferences (aggressive, defensive, balanced) with tire wear simulations and pit-stop tips.
GET /f1_driver_meeting_ai_strategy?meeting_key=1234&driver_number=1&fanPrefs=aggressive: The x-factor endpoint—uses Xano's AI Function to self-refine the strategy with dynamic, natural-language tactics (e.g., "Push DRS in sector 2, but watch for rain!"), integrating weather data from OpenF1 for realistic morphing.

It's powered by OpenF1 for base data (laps, positions, weather), with Xano handling proxying, caching, security (JWT optional, rate limits), and personalization. Solves: Fans getting bland stats; this API "morphs" them into actionable, preference-based insights. E.g., for Verstappen in a rainy Monaco, aggressive prefs boost overtake scores but warn on aquaplaning.

Demo (video takes 1 minute)

Example calls (no auth for GETs; use meeting_key from OpenF1 /meetings, driver_number like 1 for Verstappen):

Performance: curl "https://x8ki-letl-twmt.n7.xano.io/api:qQiTXlkq/f1_driver_meeting_performance?meeting_key=1267&driver_number=4"
Strategy: curl "https://x8ki-letl-twmt.n7.xano.io/api:qQiTXlkq/f1_driver_meeting_strategy?meeting_key=1267&driver_number=4&fanPrefs=aggressive"
AI Strategy: curl "https://x8ki-letl-twmt.n7.xano.io/api:qQiTXlkq/f1_driver_meeting_ai_strategy?meeting_key=1267&driver_number=4" (changed to access controlled because my Gemini quota was being exhausted)

Response example for driver_meeting_strategy (rainy conditions, aggressive prefs):

{
  "driver_number": "1",
  "latest_position": 1,
  "pace_score": 0.95,
  "personalized_score": 0.82,  // Boosted by aggressive but dinged by rain
  "tip": "Hammer the throttle out of turns, but switch to inters for rain!",
  "applied_preference": "aggressive",
  "weather_summary": { "rain": true, "wind_kph": 12, "temp_c": 15 },
  "raw_laps_sample": [ ... ]
}

Table of APIs call/response progession

| Endpoint | Input Example | Key Morph Output |
|----------|---------------|------------------|
| Performance | meeting_key=1160&driver=1 | `{"latest_position": 1, "pace_score": 0.95, "raw_laps_sample": [...]}` |
| Strategy (Aggressive) | +&fanPrefs=aggressive | `{"personalized_score": 0.82, "tip": "Push DRS in sector 2—overtake city!", "applied_preference": "aggressive"}` |
| AI Strategy (Defensive) | +&fanPrefs=defensive | `{"personalized_score": 0.75, "tip": "Rain? Protect tires—two-stop safe.", "weather_summary": { "rain": true, "temp_c": 15 } }` |

Test it live at my public Xano instance: https://x8ki-letl-twmt.n7.xano.io/api:qQiTXlkq/

The AI Prompt I Used

I used XanoScript in VS Code for initial generation, then refined in the dashboard with Logic Assistant for the AI chain.

Original XanoScript prompt (via Copilot for base endpoints):
"Create a REST API for F1 driver insights: GET /races for list (proxy OpenF1 /meetings?year=2025, last 10 sorted), GET /race/{meeting_key}/driver/{driver_number}/insights for laps/positions/weather via OpenF1, with personalization query param fanPrefs. Secure with rate limits, cache 30s."

Logic Assistant prompts for refinements (dashboard chat):

For weather integration: "After fetching laps/positions, add HTTP GET to OpenF1 /weather?meeting_key={{meeting_key}}. Parse body to $weather, merge into $raw. Default dry if failed."
For rule-based personalization: "Add If/Else for fanPrefs (aggressive/defensive/balanced). Compute score from avg position/pace * multiplier (1.18/0.88/1.0). Adjust for weather (rain_mult=0.75 if rain>0). Random tip from map."
For AI self-refine (x-factor in /meeting_driver_ai_strategy): "Add AI Function after rules: Input $raw and fanPrefs. Generate natural-language tip incorporating weather/score (e.g., 'Wet track—go aggressive on inters!'). Merge to $result."

How I Refined the AI-Generated Code

Before: Raw OpenF1 fetches (simple HTTP proxies, no personalization). Slow for repeated calls, no context.

After: Added caching (30s per query for scalability), JWT middleware for optional auth, rate limits (100/min/IP). For x-factor, chained rule-based math (Compute blocks for scores) with AI Function for dynamic tips—e.g., weather dings scores by 25% in rain. Integrated driver filtering on OpenF1 params for specificity.

Code snippet (from Function Stack export):
Before (raw fetch):

HTTP GET OpenF1 /laps?meeting_key={{meeting_key}}&driver_number={{driver_number}} → $laps

After (enriched):

If $weather.rain_intensity > 0, $weather_mult = 0.75 else 1.0
$personalized_score = round(($pace_score * 0.6 + $position_score * 0.4) * $fanPrefs_mult * $weather_mult, 2)
AI Prompt: "Generate tip using $raw, score, weather: e.g., 'Rain? Inters and push!'"

This made it prod-ready: Handles errors (defaults for null data), scales (caching avoids OpenF1 hits), and morphs outputs based on prefs/weather.

My Experience with Xano

As a newbie to Xano, I loved the no-code Function Stack—drag-and-drop HTTP, Compute, and AI blocks saved hours vs. coding a Node server. Logic Assistant nailed prompt-based generation, like auto-building weather chains. Challenge: Free Gemini tier hit 429 on tests; solved with rule fallback for core logic, keeping AI light for tips. Overall, Xano's seamless OpenF1 integration and Swagger auto-docs made this a breeze—highly recommend for AI-assisted backends. Can't wait to expand with webhooks for live race updates!

What do you think, DEV? Upvote if F1 + AI vibes! Source on GitHub: [https://github.com/datadr1ven/f1_insights]. Test and feedback welcome.

ForkQuest - Zork, but you fork the universe

datadr1ven — Sun, 02 Nov 2025 22:35:03 +0000

This is a submission for the Agentic Postgres Challenge with Tiger Data

What I Built

ForkQuest lets anyone build, play, and fork AI text adventures in seconds — powered by Tiger Data’s instant forks, hybrid search, and agentic MCP

Concept: A single-page web app (built with Next.js + Vercel) where users create and play a shareable Zork-like text adventure. It's viral: Generate, play, fork to branch stories, share links.

ForkQuest repository

Demo

How I Used Agentic Postgres

How it showcases features:

Hybrid Search: Players type natural language queries ("find sword in dark cave") → BM25 keywords + vectors retrieve lore/items/NPCs from your game DB instantly. Ranks fuzzy/spelled-wrong searches perfectly.
Fast Forks: "Branch Story" button → Zero-copy fork in <1s (even 1GB+ games). Test wild plot twists safely; merge back if liked. Shows fork time/timer for wow factor.
MCP Sidebar Chat "Add dragon boss" or "Make puzzle harder" → Agent uses MCP server + Tiger prompts to auto-generate schema inserts/queries/migrations. No SQL needed.

Overall Experience

Why compelling? Fun, addictive, tweetable ("I forked my apocalypse story!").

Token Payout based on Private Information: Golf Barbecue Coin (GBC)

datadr1ven — Sun, 07 Sep 2025 17:55:38 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Protect That Data prompt

What I Built

My golf friends and I want each other to improve. And so while we play our own games, and keep track of our own (private) stats, we incentivize two quantities, by penalizing two related events. To keep track of our penalties, we created, and have used for the past year, an ERC-20 token with a funny name. We chose this name, because at the end of summer, we required each other to use our accumulated token balances, to pitch in for an end of season get together.

Using this token requires quite a bit of manual effort, and we prefer a workflow where each of us can enter our (private) hole details, and have the token balance update automatically based on penalty events (which can be computed from the private hole details). This seems like a perfect use case for Midnight/Compact, and falls into the category of proving eligibility for token payout without disclosing personal information.

This was a difficult project for me, as I was on my own (in the sense that I'm couldn't find documentation/examples) in implementing a witness based on changing private state. I am proud of accomplishing this in a basic form, although I'm sure the implementation leaves a lot to be desired. Over the next few months, I plan to finish all of the TODOs, and transition the prototype to production.

Demo

All of the code I developed is here. The repository contains a compact contract called gbc.compact, an api/cli bootstrapped by create-midnight-app in boilerplate/contract-cl, and a UI in boilderplate/gbc-ui.

Here is a video of the UI in action, which displays the (public) GBC balances, as a function of (private) hole data input.

In the video below you can see a deployed gbc contract being invoked, with the witness being based on private dynamic data (user provided hole results). I need help wiring actual contract calls up to my UI, and this part of the project is left as a TODO.

How I Used Midnight's Technology

Utilized the compact language in writing gbc.compact
The super awesome helper create-midnight-app generated cli scaffold from the gbc contract. Extending the scaffold was nontrivial, as it made overly simplistic assumptions (such as a static witness)
Spent a significant amount of time attempting to write a UI that actually interacts with a deployed contract. Tried two main approaches, 1) adapting the example-bboard UI, which uses modules such as the Midnight DApp Connector API, and 2) attempting to use OpenZeppelin's UI builder. In the end, I was unsuccessful with both approaches. A simple tutorial here would've helped a lot

Another TODO before going production will (likely) be to incorporate OpenZeppelin's FungibleToken compact contract, as the current token-like capabilities in gbc.compact are rudimentary at best. A simple tutorial here also would've helped a lot.

Data Protection as a Core Feature

To achieve this prototype required implementing a witness based on changing private state. Specifically, as a user enters their result for a particular golf hole, this private information informs the witness latestResult(), so that the contract circuit nextHole() can be invoked, and the appropriate balance bookkeeping ledger quantities can be updated.

Set Up Instructions / Tutorial

As described in the README,

start by running npm install at the top level directory

for the contract

run npm install from boilerplate/contract
run npm run compact from boilerplate/contract
run npm run build from boilerplate/contract

for the cli

run npm install' from boilerplate/contract-cli
run npm run build
run either npm run standalone or npm run testnet-remote (the latter requires starting a proof server via docker)

for the ui

run npm install from boilerplate/gbc-ui
run npm run dev from boilerplate/gbc-ui
point a browser at localhost:5173

Leveraging Redis 8.0's New Time Series Capabilities in a Real-Time Formula 1 Dashboard

datadr1ven — Sat, 09 Aug 2025 00:16:34 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

Cover image free for use under the CC-2 license

What I Built

I am a Formula 1 fan, and a programmer, and in the past have posted here on dev.to about a Formula 1 fantasy tool I wrote that uses Linear Programming to compute optimal fantasy teams and Github actions to automatically update the tool with new race data. In this post, I describe a Formula 1 inspired usage of Redis 8.0's new time series "upgrade package" (a play on words, where an upgrade package in F1 refers to changes made to the car throughout the season).

There is a "cognitive ergonomics" legend in Formula 1, whereby in 2001, a Race Strategy Analyst for McLaren invented a screen called the McLaren Track Viewer (MTV). The MTV shows the time gaps between race cars on a circle, as opposed to overlaid on the race track, and gives teams actionable visual cues, such as where a car considering a pit stop, is forecast to reemerge time gap wise.

The technical sophistication of the original MTV was impressive, given the limited realtime data available circa 2001. Today (24 years later), there is copious telemetry available, and so prototyping an MTV should be straightforward! In this post, we cobble together an MTV minimum viable product (MVP), in other words, an MTV MVP 😂🤣.

Demo

And here it a short screen recording of what I accomplished!

Go check out the live (and open source) site at https://datadr1ven.github.io/mtvmvp. Lots of features to add, of course, including the ability to pick race/driver/lap. The page currently runs on data from Lewis Hamilton's lap 14 at the 2024 Miami Grand Prix.

How I Used Redis 8

The Redis 8 feature set I leaned on is the new affordance for time series data.

There are a few sources for F1 telemetry, for this MVP we use OpenF1, specifically their interval REST API. We insert interval data into Redis 8.0 as a time series, which you can see we query about here:

This shows that we have 10811 samples currently in the Redis 8.0 timeseries (from the 2023 Las Vegas Grand Prix). The efficiency and utility of Redis time-series routines made this MVP really straightforward to rapidly prototype via experimentation. To close, here is a query that shows a subset of timeseries data points restricted to a timestamp range.

Thanks for reading!

A simple, but useful, and powerful GitHub action example

datadr1ven — Thu, 05 Jun 2025 02:57:42 +0000

We maintain a Formula 1 Fantasy hobbyist/enthusiast tool, which we wrote a technical article about here last year. One room for improvement was in automation -- specifically, after each race concluded, we had to perform manual action to propagate the results to our tool. Well, we finally took the time automate that step, using GitHub actions. After figuring things out, the whole automation capability took only 28 lines (over half of which are superfluous), and so we thought that this could make for a nice tutorial and/or example of how to use GitHub actions.

So in our tool, which is hosted via GitHub pages, the data that changes over time (i.e. after each grand prix) is entirely contained in this file, of which here is a gestalt look at it...

export const active_season = 2025
export const latest_race = "Monaco Grand Prix";
export const race_names = ['AUS', 'CHN', 'JPN', 'BHR', 'SAU', 'USA', 'ITA', 'MCO'];
export const driver_points = {'GAS': [1, -8, 0, 13, -17, 18, 3, -20], 'ALO': [-20, -16, ...};
export const driver_prices = {'GAS': [11.8, 11.2, 10.6, 10, 9.4, 8.8, 8.2, 7.6], 'ALO': [8.8, 8.2, ...};
export const team_points = {'ALP': [-14, -6, 9, 22, -6, 10, 10, -11], 'AST': [1, 4, ...};
export const team_prices = {'ALP': [9.5, 8.9, 8.3, 7.7, 7.9, 8.1, 8.3, 7.7], 'AST': [8.5, 7.9, ...};

This file is created by piping the contents of f1fantasytools.com's statistics page through a script we wrote to transform the data into the form our tool uses. In other words, after each race, we would run

curl https://f1fantasytools.com/statistics | python3 stats_to_race_data.py > race_data.js

and then manually update the repository with the resulting file. This is the process we automated.

name: update race data
run-name: pull results and reorganize data for our platform
on:
  schedule:
    # * is a special character in YAML so you have to quote this string
    - cron:  '0 1 * * *'
jobs:
  Update-Race-Data:
    runs-on: ubuntu-latest
    permissions:
      contents: write    
    steps:
      - name: Check out repository code
        uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
      - name: Download latest race data
        uses: sozo-design/curl@v1.0.2
        with:
          args: -o statistics.html https://f1fantasytools.com/statistics
      - name: Process latest race data
        run: |
          cat statistics.html | python3 stats_to_race_data.py > race_data.js      
      - name: Remove our downloaded race data so as to not pollute repo
        run: |
          rm statistics.html
      - name: Commit any changes back to repo
        uses: stefanzweifel/git-auto-commit-action@v5

The cron schedule is such that this runs once per day, which is acceptable because there is sometimes a lag in the final points assignment. The steps are somewhat self explanatory. First the repository is cloned by the runner. Then the latest statistics are downloaded via curl and saved to a file. That file is piped through our data transformation script. Then the downloaded html is removed, and then the results are committed back to the repository.

Here's the first run of this action after the 2025 Spanish Grand Prix - https://github.com/datadr1ven/teamtool/actions/runs/15382619543/job/43275725139

And this is the commit that resulted from that run -
https://github.com/datadr1ven/teamtool/commit/d8a769c2c3c9275adeede040619c3a6f284089fb

I hope you find this GitHub Action interesting and useful!

Evaluating (Historically Optimal) Fantasy F1 Teams with Linear Programming

datadr1ven — Thu, 21 Nov 2024 22:30:20 +0000

I'm a programmer and a Formula 1 fan. When I started playing F1's fantasy league, my mind naturally went to algorithms.

The goal in the F1 fantasy game is to pick 5 drivers and 2 teams, while staying under a price cap, that based on race performance, scores a maximum number of points. This sounds like a fairly traditional computer science optimization problem with constraints, right?

More precisely, for any historical window of races, we can use Linear Programming, to find an optimal team. Strictly speaking, this solution is to a simplified version of the game (the real game lets you make changes to your team week to week, as well as has some wildcard factors), but is a useful starting point nonetheless.

Putting together our capability required minimal dependencies:

data: we grab points/prices data from the excellent F1 Fantasy Tools site
linear programming library: we use glpk.js, which is a JavaScript/WebAssembly port of the old trusty GLPK solver
platform: we use GitHub pages, where our code is open sourced under the MIT License and can be found here

The current capability has a simple interface, as shown in this screenshot.

The crux of the capability is the behinds-the-scenes construction of the linear programs, which are then fed to the glpk.js solver running in your browser. Here is an actual linear program constructed by our tool (with many lines omitted).

{
    "name": "LP",
    "objective": {
        "direction": 2,
        "name": "obj",
        "vars": [
            {
                "name": "VER",
                "coef": 593
            },
            {
                "name": "OCO",
                "coef": 112
            },
   [...18 additional drivers, omitted for brevity]

            {
                "name": "AST",
                "coef": 360
            },
   [...9 additional teams, omitted for brevity]

        ]
    },
    "subjectTo": [
        {
            "name": "cons1",
            "vars": [
                {
                    "name": "VER",
                    "coef": 30
                },
                {
                    "name": "NOR",
                    "coef": 23
                },
[...18 additional drivers, omitted for brevity]

                {
                    "name": "MCL",
                    "coef": 23.2
                },
[...9 additional teams, omitted for brevity]

            ],
            "bnds": {
                "type": 3,
                "ub": 100,
                "lb": 0
            }
        },
        {
            "name": "cons2",
            "vars": [
                {
                    "name": "VER",
                    "coef": 1
                },
                {
                    "name": "OCO",
                    "coef": 1
                },
[...18 additional drivers, omitted for brevity]

            ],
            "bnds": {
                "type": 5,
                "ub": 5,
                "lb": 5
            }
        },
        {
            "name": "cons3",
            "vars": [
                {
                    "name": "RED",
                    "coef": 1
                },
[...9 additional teams, omitted for brevity]
Show quoted text
[...18 additional drivers, omitted for brevity]

        {
            "name": "cons29",
            "vars": [
                {
                    "name": "FER",
                    "coef": 1
                }
            ],
            "bnds": {
                "type": 4,
                "ub": 1,
                "lb": 0
            }
        },
[...9 additional teams, omitted for brevity]

    ],
    "generals": [
        "VER",
        "OCO",
[...18 additional drivers, omitted for brevity]
        "ALP",
[...9 additional teams, omitted for brevity]
    ]
}

For those unfamiliar with the F1 naming colloquialism, drivers are referred to by the first three letters of their surname (e.g. VER is Max Verstappen), and teams each have a 3 letter mnemonic (e.g. AST is Aston Martin Motorsports).

And so in these linear programs, there is a variable per driver (named with their three letter code) and a variable per team, which must take the value of 1 (on your fantasy team) or 0 (not on your fantasy team). And the objective of the linear program is to maximize points, subject to the sum of the price not exceeding the budget threshold, and also subject to the constraint that the sum of the driver variables is 5, and the team variables is 2. Very straightforward!

A nuance is that you get to choose a "2x driver," who scores twice the points they earned that week. To accommodate this nuance, we generate 20 separate linear programs (each taking a different driver as the 2x), and run glpk.js on each of those 20 programs, to find the one with maximum points.

Disclaimer: we have no affiliation to Formula One (or any of their companies or brands). The author of this capability is simply a fan who enjoys playing the fantasy game. This information is provided with no guarantees as to its' accuracy, use at your own risk.'

DEV Community: datadr1ven

StarGather: Shared Astronomy Observation Log with Instant Sky Map Viewer (DEV Weekend Challenge: Community)

The Community

What I Built

Demo

Code

How I Built It

astronomy #opensource #nextjs #weekendchallenge #community

cwa – Making GitHub Copilot CLI Faster & Safer for Daily Dev Workflows (Copilot CLI Challenge)

What I Built

Demo

How I Used GitHub Copilot CLI

Why This Adds Value (Even Though Copilot CLI Exists)

Next Steps & Open Questions

web3 Verifier – Fight Rug Pulls with Fast, Grounded AI Conversations

🌟 What I Built

🎯 The Problem

💡 The Solution

🎮 Live Demo

✨ Demo Features

🖼️ Interface Preview

🛠️ Technical Implementation

Frontend: Modern Web3 Stack

AI Backend: Algolia Agent Studio

Data Pipeline

Agent Prompting Strategy

🎯 Core Features

1. Intelligent Trust Scoring

2. Conversational Experience

3. Real-time Data Integration

4. Developer-Friendly Architecture

🚀 Why This Matters

For Users

For the Web3 Ecosystem

For Developers

📊 Technical Metrics

🎥 Demo Video

🏆 Challenge Requirements Met

🔗 Links & Resources

🙏 Call to Action

From Boring Portfolios to Chicken-Powered Motivation: Building CluckClean with Gemini

About Me

Portfolio

How I Built It

What I'm Most Proud Of

GBC Scorecard: Figma ➡️ Token-Rewarding Golf App with Uno Hot Design Agent 🏌️‍♂️💰

What I Built

Original Design Reference

Demo, Hot Design Agent in Action

Design Process

Key Takeaways

F1 Driver Strategy API – AI-Refined Tactics with Xano

What I Built

API Documentation

Demo (video takes 1 minute)

The AI Prompt I Used

How I Refined the AI-Generated Code

My Experience with Xano

ForkQuest - Zork, but you fork the universe

What I Built

Demo

How I Used Agentic Postgres

Overall Experience

Token Payout based on Private Information: Golf Barbecue Coin (GBC)

What I Built

Demo

How I Used Midnight's Technology

Data Protection as a Core Feature

Set Up Instructions / Tutorial

Leveraging Redis 8.0's New Time Series Capabilities in a Real-Time Formula 1 Dashboard

What I Built

Demo

How I Used Redis 8

A simple, but useful, and *powerful* GitHub action example

Evaluating (Historically Optimal) Fantasy F1 Teams with Linear Programming

A simple, but useful, and powerful GitHub action example