DEV Community: Batila Amulya

I built a macro tracker powered by AI + attitude

Batila Amulya — Fri, 22 May 2026 11:10:58 +0000

I built a macro tracker powered by AI + attitude. 🏋️

Plan your macros in the morning. Check in once at night. Let Milo cheer you on or let Evil Vilo roast you.

🚀 Live demo: https://web-production-5c594.up.railway.app/
📦 GitHub: https://github.com/Amulya631/MacroDay

The Problem
Most nutrition apps are reactive.
You eat something, you log it, you feel guilty later. The friction of logging every meal throughout the day is exactly why people abandon these apps within a week — and the people who care most about macros (gym-goers chasing protein and fiber targets) are the ones who need a simple system, not a data-entry job.
Old Way ❌MacroDay ✦ Log every meal, all daySet an intention in the morningReact to what you already ateMake smarter decisions all dayGuilt at 10pm when you're 40g short Confirm at night — no surprises

The Solution: Planning-First, Not Logging-First
Two touchpoints a day:

Morning — Tell MacroDay what you're planning to eat. Get instant AI-powered macro analysis across all five macros (calories, protein, fiber, carbs, and fats). Add snacks to close gaps and watch the rings update live.
Night. Confirm what you actually ate. Followed your plan? Quick tick-box list. Day went sideways? Enter your actual meals.

You set an intention in the morning, which means better decisions all day, not just guilt at the end.

Features

🎯 5 animated SVG macro rings — real-time visual feedback for all five macros
🧠 AI-powered analysis — Claude Haiku reads your meal descriptions and calculates macros, gaps, and smart snack suggestions
⚡ Live snack updates — add a suggested snack and all five rings update instantly
🎙️ Voice input — mic button on every meal field (Chrome, Web Speech API)
🕐 Time-aware routing — the right screen for the time of day, automatically
📋 Night check-in — Path A (tick-box) or Path B (full re-entry), with edge case handling
📊 End-of-day summary — actual vs. target macro rings with celebration or encouragement
🔄 Day rollover — history written to localStorage, today resets automatically
😇😈 Milo vs. Evil Vilo — choose your mascot. One is warm and proud of you. The other will not be kind about your fiber intake.

The Mascot System (a first-class feature)
The mascot is not an afterthought. At profile setup, you pick your flavor. Both characters appear on every emotional moment — morning results, skipped meals, end-of-day summary, sleep screen.
Milo (Good) 😇

"Great job planning ahead your protein is solid, and you've got room for a great snack tonight!"

Evil Vilo 😈

"Embarrassing. You logged 'some chicken' and expect me to calculate your macros? Try again."

Both are built from the same data — just radically different personalities. Vilo is a ragebait villain who will genuinely not be kind about your fiber intake.

Tech Stack
LayerTechNotesBackendPython · FastAPIServes frontend + APIFrontendVanilla HTML/CSS/JSNo framework neededAIClaude Haiku (claude-haiku-4-5-20251001)Single endpointStorageBrowser localStorageZero infraVoiceWeb Speech APIChrome onlyDeploymentRailway1 Procfile, 1 env var
Single-service architecture — FastAPI serves both the static frontend and the /api/analyze endpoint from the same origin. No CORS complexity, no separate frontend deployment.

How the AI Works
All macro analysis runs through a single endpoint:
POST /api/analyze
The request includes:

Meal descriptions (free text — "200g chicken breast, 150g rice")
Daily macro targets from the user's profile
Mode ("morning" or "night")
Mascot preference ("milo" or "vilo")

Claude returns structured JSON:

json{
  "macros": {
    "calories": 1480,
    "protein": 112,
    "fiber": 18,
    "carbs": 160,
    "fats": 38
  },
  "gaps": {
    "calories": 520,
    "protein": 38,
    "fiber": 7
  },
  "feedback": "Your protein is on track but fiber is noticeably short...",
  "snack_suggestions": [
    "Greek yogurt (200g) — +15g protein, +0g fiber"
  ],
  "affirmation": "Solid plan. Don't blow it at dinner.",
  "needs_clarification": false
}

Key Architecture Decisions

One endpoint, three modes Rather than separate routes for morning analysis, night analysis, and snack recalculation, everything goes through POST /api/analyze with a mode field.

One fetch wrapper on the frontend
Prompt logic lives in one place
Easier to tune Vilo's tone without hunting across multiple handlers

Vague input detection at the prompt level When a user types "some chicken", the app doesn't try to parse or validate before sending. Instead, the Claude prompt instructs the model to return needs_clarification: true if it can't calculate macros with reasonable confidence. This is more robust than regex—Claude catches edge cases a rule-based validator would miss. "Food from the gym" is vague. "Leftover pasta" is ambiguous but probably workable.
SVG rings over CSS conic gradients stroke-dasharray / stroke-dashoffset on SVG circles gives precise control over fill percentage and animates cleanly with CSS transitions. Conic-gradient is simpler to write but harder to animate and has inconsistent cross-browser rendering for partial fills. The SVG approach adds ~10 lines per ring but is rock-solid on every browser.
localStorage over a backend database For a personal-use demo with no auth requirement, localStorage is the right call. Zero infrastructure, zero latency, works offline, resets cleanly. The data model is designed so that migrating to a real database later is straightforward—each key (macroday_profile, macroday_today, macroday_history) maps directly to what would be a user-scoped database record.

Project Structure
MacroDay/
├── main.py # FastAPI app — serves frontend + API
├── requirements.txt
├── Procfile # Railway deployment config
├── static/
│ ├── index.html # Single-page app (all screens)
│ ├── style.css # Health/wellness UI styling
│ ├── app.js # Routing, profile, night check-in logic
│ └── analyze.js # API calls, ring rendering, snack logic
├── assets/
│ ├── Milo_Good.png
│ └── Vilo_Evil.png
└── docs/
├── scope.md
├── prd.md
└── spec.md

Running Locally
bash# 1. Clone
git clone https://github.com/Amulya631/MacroDay.git
cd MacroDay

2. Install

pip install -r requirements.txt

3. Set your API key

echo "ANTHROPIC_API_KEY=your-key-here" > .env

4. Start

uvicorn main:app --reload

5. Open http://localhost:8000 in Chrome

Get an Anthropic API key at console.anthropic.com.

What's Next (v2 Ideas)

📸 Photo macro analysis—photograph a meal, AI estimates macros from the image
🔔 Push notifications — morning reminder at 8am, night reminder at 8pm
📈 Multi-day insights—"You've been low on fiber all week."
💪 Post-workout mode — dedicated high-protein suggestion flow

Try It

🚀 Live demo: https://web-production-5c594.up.railway.app/
⭐ GitHub: https://github.com/Amulya631/MacroDay
🛠️ Built with: Claude Code · Anthropic

If you're a gym-goer who's ever abandoned a nutrition app because it felt like a second job — this one's for you. Give it a try, star the repo, or open an issue if you have ideas.

ResearchMind — AI Research Pipeline with Cross-Session Memory | Backboard Challenges 2026

Batila Amulya — Fri, 22 May 2026 10:43:40 +0000

I Built a Multi-Agent AI Research Pipeline in 2 Days — Here's Every Error I Hit

I just submitted ResearchMind to the Backboard Challenges Hackathon. This is the honest build log — what I built, how it works, and the 11 errors that almost stopped me.

What Is ResearchMind?

Type a research topic. Three AI agents collaborate and produce a polished academic research brief with real APA citations. Download it as a PDF. Come back next week — it remembers everything you've researched.

Live: https://researchmind-production-04c7.up.railway.app

GitHub: https://github.com/Amulya631/ResearchMind

The Architecture

Input Topic
    │
    ▼
┌─────────────────────────────────────┐
│  Stage 1 — Planner (Gemini Flash)   │
│  Reads memory → generates subtasks  │
└──────────────────┬──────────────────┘
                   │
    ▼
┌─────────────────────────────────────┐
│  Stage 2 — Summarizer (Gemini Flash)│
│  5–8 APA-cited facts per subtask    │
└──────────────────┬──────────────────┘
                   │
    ▼
┌─────────────────────────────────────┐
│  Stage 3 — Synthesizer (Claude Haiku│
│  Polished brief + References section│
└──────────────────┬──────────────────┘
                   │
    ▼
  Saved to Backboard Cross-Session Memory

Backboard Features Used

Multi-assistant architecture — 3 permanent assistants with distinct system prompts
Multi-model routing — Gemini 2.5 Flash for speed, Claude Haiku for synthesis quality
Persistent memory — client.add_memory() stores conclusions after every session
Cross-thread memory recall — memory="Auto" on add_message() triggers automatic recall

The Tech Stack

Backboard SDK v1.5.13
Streamlit 1.32
Google Gemini 2.5 Flash
Anthropic Claude Haiku
fpdf2 (PDF generation)
Railway (deployment)
Python 3.12

11 Errors I Hit (And Fixed)

The hackathon guide was written for an older SDK version. Here's every error I encountered:

Error 1 — `streamlit: command not recognized`

Windows PATH issue. Fix: python -m streamlit run app.py

Error 2 — `'dict' object has no attribute 'role'`

SDK v1.5.13 returns messages as dicts, not objects.

# Wrong
m.role, m.content
# Right
m["role"], m["content"]

Error 3 — Documents still being indexed

asyncio.sleep(3) was too short. Fixed with a polling loop.

Error 4 — BackboardServerError on every Synthesizer call

6 stuck documents from test runs overloading the RAG system. delete_assistant_document() doesn't exist in v1.5.13. Solution: deleted and recreated the assistant, then switched to inline content passing instead of document upload.

Error 5 — `NameError: tmp_path not defined`

Orphaned os.unlink(tmp_path) left after removing the upload block.

Error 6 — Invisible input text

CSS specificity conflict with Streamlit's internal theme. Fixed with !important and solid background colors.

Error 7 — `SyntaxError: unterminated string literal`

Apostrophe in you've inside a single-quoted Python string.

Error 8 — `assistants.py --update` crash

force_update=True was applied to the Planner even though its prompt hadn't changed.

Error 9 — `FPDFUnicodeEncodingException`

Em dash — outside Helvetica's Latin-1 range. Fixed with a clean() function that maps Unicode to ASCII equivalents.

Error 10 — `FPDFException: Not enough horizontal space`

20mm margins were too wide on Railway's environment. Reduced to 10mm, added dynamic line coordinates, and a safe_write() helper that catches individual line errors.

Error 11 — Topic chip wrapping to two lines

Double-width emoji ⚛️ (U+269B + U+FE0F variation selector) consuming full column width. Replaced with single-width ⚛ and restructured to a 3+2 chip layout.

The Feature That Makes It Different

The cross-session memory is what separates this from a standard chatbot.

await client.add_memory(
    assistant_id=planner_id,
    content=(
        f"Completed research on: '{query}'.\n"
        f"Subtasks covered: {', '.join(subtasks)}.\n"
        f"Key conclusions: {brief[:600]}"
    ),
    metadata={"topic": query, "type": "research_session"},
)

Next session, memory="Auto" on add_message() automatically retrieves this — and the Planner's system prompt tells it to skip already-covered subtasks. Knowledge compounds over time instead of starting from zero every run.

What I'd Do Differently

Skip document upload entirely from day one inline content passing is more reliable
Run python -m py_compile app.py after every change on Windows
Test on the deployment environment early PDF rendering behaved differently on Railway vs local

Try It

🚀 Live: https://researchmind-production-04c7.up.railway.app

💻 GitHub: https://github.com/Amulya631/ResearchMind

Feedback is welcome! especially if you're also building on Backboard.

Built by Batila Amulya—GCP Cloud Engineer & Gen AI enthusiast

python #ai #hackathon #buildinpublic #streamlit #llm #multiagent

For my hackathon submission I asked: what if you never had to open a calendar, task manager, or notes app again? NEXUS is my answer. Full breakdown inside 👇

Batila Amulya — Wed, 15 Apr 2026 07:27:15 +0000

Batila Amulya

Apr 15

Building NEXUS: How I Architected a Multi-Agent AI System on Google Cloud in 48 Hours

#ai #googlecloud #machinelearning #hackathon

Comments 2

3 min read

Building NEXUS: How I Architected a Multi-Agent AI System on Google Cloud in 48 Hours

Batila Amulya — Wed, 15 Apr 2026 07:14:09 +0000

`One sentence. Four AI agents. Real results — in under 4 seconds. Here's everything I learned building NEXUS for the Gen AI Academy APAC Edition hackathon.

The problem I wanted to solve

How many apps do you open on a typical workday just to stay organized? Calendar. Task manager. Notes app. Each one lives in its own silo, and switching between them adds up to a surprising amount of mental overhead.

I wanted to build something different — a single conversational interface where you say what you need to do, and the system figures out the rest. Not a chatbot that gives you a list of suggestions. An actual agent that acts.

That idea became NEXUS.

NEXUS is a fully deployed multi-agent AI system on Google Cloud Platform. You send one natural language request, and NEXUS automatically coordinates specialized AI agents to complete complex workflows — simultaneously.

What NEXUS actually does

Here's a quick example. You send:

"Schedule a team meeting tomorrow and create a task to prepare the agenda."

Within 4 seconds, two things happen in parallel:

ChronoBot creates event EVT-EACD61F3 in Firestore
TaskMind creates task TASK-462C3D6C in Firestore

No manual switching. No separate apps. One message, multiple agents, real results.

Meet the agent network

The architecture: how it all fits together

The core insight behind NEXUS is that routing intelligence should live in the AI, not in the code. The orchestrator sends your message to Gemini 2.5 Flash, which returns a JSON routing plan:

json {"agents": ["calendar", "tasks"], "plan": "Schedule meeting using calendar agent, then create prep task."}

The relevant agents are called in parallel — each an independent Cloud Run service. They write to Firestore and return structured results back to the orchestrator.

plaintext User message → NEXUS Core (Cloud Run + Gemini 2.5 Flash) → Dynamic routing to ChronoBot / TaskMind / MemoryVault → Firestore (5 collections) → Structured response with agent IDs + execution trace

Why Google Cloud Platform?

Cloud Run — Each agent scales to zero. No cost when idle, instant burst when needed.
Firestore (Native mode) — Schemaless and real-time. No schema migrations during a 48-hour build.
Gemini 2.5 Flash — Sub-second JSON responses at ~$0.000125 per request.
Cloud Pub/Sub — Async agent messaging. Decouples agents for future event-driven scaling.
Secret Manager — Zero hardcoded credentials. Non-negotiable for anything touching APIs.

What made this genuinely hard

Dynamic routing vs hardcoded logic. The temptation was to write explicit routing rules. I pushed back on that—trusting Gemini to classify intent and return a structured JSON plan is far more robust and extensible.

Keeping agents truly independent. Strict API contracts, no shared state except through Firestore. Tedious to maintain, but it means I can add a new agent without touching existing code.

IAM and least privilege. The service account uses exactly 8 roles. Getting this right during a hackathon is easy to skip; I'm glad I didn't.

Try it yourself

NEXUS is fully deployed and live:

shell curl -X POST "https://nexus-orchestrator-yqumqe2gtq-uc.a.run.app/query" \ -H "Content-Type: application/json" \ -d '{"message": "Remind me to follow up with the team on Friday"}'

Live demo: https://nexus-frontend-yqumqe2gtq-uc.a.run.app
GitHub: https://github.com/Amulya631/Nexus_Agent

What I'd build next

An email agent—draft a follow-up and schedule a reminder in one go
Agent-to-agent communication via Pub/Sub
A memory-aware orchestrator that learns your preferences over time

Closing thoughts

Building NEXUS taught me that the hardest part of a multi-agent system isn't the individual agents — it's the orchestration layer. Getting the routing right, keeping agents independent, and building proper observability is where the real engineering lives.

If you're building something similar or have questions about the GCP architecture, drop a comment or find me on GitHub!

Built for the Gen AI Academy APAC Edition — Google Cloud × H2S. Track: Multi-Agent AI Systems.`

DEV Community: Batila Amulya

I built a macro tracker powered by AI + attitude

2. Install

3. Set your API key

4. Start

5. Open http://localhost:8000 in Chrome

ResearchMind — AI Research Pipeline with Cross-Session Memory | Backboard Challenges 2026

I Built a Multi-Agent AI Research Pipeline in 2 Days — Here's Every Error I Hit

What Is ResearchMind?

The Architecture

Backboard Features Used

The Tech Stack

11 Errors I Hit (And Fixed)

Error 1 — streamlit: command not recognized

Error 2 — 'dict' object has no attribute 'role'

Error 3 — Documents still being indexed

Error 4 — BackboardServerError on every Synthesizer call

Error 5 — NameError: tmp_path not defined

Error 6 — Invisible input text

Error 7 — SyntaxError: unterminated string literal

Error 8 — assistants.py --update crash

Error 9 — FPDFUnicodeEncodingException

Error 10 — FPDFException: Not enough horizontal space

Error 11 — Topic chip wrapping to two lines

The Feature That Makes It Different

What I'd Do Differently

Try It

python #ai #hackathon #buildinpublic #streamlit #llm #multiagent

For my hackathon submission I asked: what if you never had to open a calendar, task manager, or notes app again? NEXUS is my answer. Full breakdown inside 👇

Building NEXUS: How I Architected a Multi-Agent AI System on Google Cloud in 48 Hours

Building NEXUS: How I Architected a Multi-Agent AI System on Google Cloud in 48 Hours

The problem I wanted to solve

What NEXUS actually does

Meet the agent network

The architecture: how it all fits together

Why Google Cloud Platform?

What made this genuinely hard

Try it yourself

What I'd build next

Closing thoughts

Error 1 — `streamlit: command not recognized`

Error 2 — `'dict' object has no attribute 'role'`

Error 5 — `NameError: tmp_path not defined`

Error 7 — `SyntaxError: unterminated string literal`

Error 8 — `assistants.py --update` crash

Error 9 — `FPDFUnicodeEncodingException`

Error 10 — `FPDFException: Not enough horizontal space`