Forem: Adam

QuestBoard: Turn Your Notion Workspace Into a Full RPG

Adam — Sun, 29 Mar 2026 16:35:26 +0000

This is a submission for the Notion MCP Challenge

See the generated workspace:
QuestBoard Notion

What I Built

QuestBoard turns a Notion page into a playable RPG-style productivity system.

Instead of giving you another flat task list, it creates a workspace where:

real tasks become quests
neglected areas become new quest targets
completed work turns into XP, levels, streaks, and achievements
bigger pressure points can become boss battles
weekly progress becomes a recap page written like a story chapter

The important part is that this is not just themed copy pasted into Notion. QuestBoard is MCP-native from end to end. It uses Notion MCP to create the workspace, create and update records, build hosted views, sync progression, log automation runs, and support review/correction loops.

Why It Is Useful

The core problem I wanted to solve was this: most productivity systems are good at storing work, but weak at making progress felt.

QuestBoard tries to make motivation, pressure, and momentum visible inside a workspace people already use:

weak skill areas are easier to spot
small wins still feel meaningful because they award progression
recurring inconsistency shows up as stale quests, not invisible drift
a user can review and correct generated content instead of treating AI output as automatically trusted

It also works beyond the canned showcase flow. A real user can onboard with:

a real goal
what success looks like
a real time budget
preferred pacing
constraints
motivation
optional domain context for niche tools or jargon

That profile is saved into Notion and used to shape future quests.

How A User Actually Gets Value

The real-user loop is:

Connect hosted Notion MCP and point QuestBoard at a blank Notion page.
Run guided onboarding so QuestBoard captures the user’s real goal, time budget, focus area, constraints, and motivation.
QuestBoard creates the full workspace in Notion.
The user works mostly in Notion: reviewing quests, moving them through status, and watching progression update.
QuestBoard syncs XP, levels, streaks, skills, achievements, run logs, and review state.
Weekly recaps and review workflows turn the workspace from “AI generated pages” into an operating system the user can keep using.

For ambiguous or niche goals, onboarding can optionally use Exa or Perplexity to ground the saved context before the first quests are generated.

What The Hosted MCP Path Creates

On the hosted path, QuestBoard creates 8 databases and 14 named views across 8 hosted view types.

Core databases:

Player Profile
Quest Board
Skill Trees
Achievement Log
Hero Roster
Adventure Recaps
Runs
Review Queue

Hosted views:

Hero Dashboard
Quest Ledger
Quest Map
Quest Calendar
Quest Timeline
Quest Cards
XP Progress
Skill Focus
Skill Board
Trophy Case
Hero Roster
Story Archive
Run Center
Review Queue

That is what makes the product feel like a real Notion system instead of a terminal tool that happens to write pages.

Demo

See the generated workspace:
QuestBoard Notion

The video focuses on the strongest hosted path:

create the workspace on a blank Notion page
Questboard generated views and structure
Questboard do quest generation and progression
QuestBoard syncs Notion changes back into the game state

Show Us The Code

bO-05 / questboard

QuestBoard

Turn your Notion workspace into an RPG. QuestBoard is a Python app that uses Notion MCP to create and operate a gamified workspace with quests, boss battles, skill trees, XP, recaps, runtime automation, and human review workflows.

What It Does

Creates a full QuestBoard workspace inside Notion
Guides first-time setup with questboard onboard so a real goal, time budget, motivation, and constraints shape the workspace
Generates quests from your focus areas and skill gaps
Creates boss battles for neglected skills or habits
Tracks XP, leveling, streaks, and achievements
Writes weekly recaps with AI or deterministic fallbacks
Can optionally ground ambiguous goals with Exa or Perplexity before the first quests are generated
Logs automation runs in Runs
Routes generated output through a Review Queue
Supports revision loops for reviewed quests and recaps
Runs a policy-based runtime loop with questboard runtime and questboard watch

Notion MCP Integration

QuestBoard is MCP-native. Notion…

View on GitHub

Key files:

File	What it does
`src/cli.py`	User-facing commands for setup, onboarding, doctor, sync, runtime, review, revision, and demo flows
`src/setup_workspace.py`	Builds the Notion workspace, schemas, hosted views, and seed data
`src/mcp_client.py`	MCP wrapper for hosted vs self-hosted Notion operations
`src/onboarding.py`	Goal grounding, optional research, and context-brief generation
`src/engines/quest_generator.py`	Quest generation, boss generation, JSON repair, and fallback templates
`src/engines/xp_engine.py`	XP, leveling, streaks, achievements, and progression reconciliation
`src/engines/recap_writer.py`	Weekly recap generation and stale quest patrol
`src/runtime.py`	Policy-based runtime planning, watch mode, and recurring control-loop behavior
`src/operations.py`	Review Queue operations and review-surface reconciliation
`src/revision.py`	Correction-loop revision from review notes

Local validation for the release snapshot reached 130 passed.

How I Used Notion MCP

QuestBoard is built around Notion MCP, not lightly assisted by it.

Every important operation goes through MCP:

MCP capability	How QuestBoard uses it
Create database	Builds the full multi-database workspace
Create pages	Creates quests, boss battles, recaps, player records, run logs, and review items
Update page	Syncs quest status, XP, levels, streaks, and review state
Create view	Builds the hosted product surfaces like Quest Map, XP Progress, Hero Dashboard, Run Center, and Review Queue
Search	Finds player, quest, skill, run, and review records across the workspace
Fetch	Reads schema and page state to drive generation, sync, and runtime decisions
Create comment	Adds progression flavor, warnings, and operational commentary
Move pages	Supports archival and organization flows

I also intentionally supported both hosted and self-hosted MCP paths:

hosted MCP is the strongest product/demo path because it can create the richer view suite
self-hosted MCP is still valuable for local validation and token-based setup

Reliability And Hardening

I spent a large part of the build on making the project less fragile:

questboard doctor provides a read-only workspace health check
questboard hosted-login makes the hosted OAuth path usable without hand-building tokens
setup accepts full Notion URLs, not just raw IDs
rerunning setup can repair an older saved workspace instead of blindly trusting stale local metadata
QuestBoard has deterministic fallback generation when model output is malformed or unavailable
generated content is reviewable, correctable, and revision-friendly through Review Queue and revision flows
Run Center records operational history instead of hiding it

That matters because an MCP project should not just generate a cool first page. It should keep behaving coherently once the workspace is alive.

Closing

QuestBoard is my attempt to make Notion feel less like a storage layer and more like a playable progression system.

The goal was not only to make something flashy. The goal was to make a workspace where motivation, progress, governance, and automation all become visible inside Notion itself.

I Built Bruno Simon's Inspired Portfolio as a 3d Web Noob, Here's My Learning Experience

Adam — Sat, 31 Jan 2026 19:42:50 +0000

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

About Me

Hi! I'm Adam, a full-stack vibe-developer from Jakarta, Indonesia. I specialize in AI-powered applications and interactive experiences. But I have very little 3d web experience, if any.

The challenge I set for myself: As a 3d noob, could I build a Bruno Simon-inspired 3D portfolio in under 20 days while juggling daily responsibilities? Bruno's site took him months, with years of experiences. I had January 12 → February 1, with just some AI assistant at my disposal and my own stubbornness.

This portfolio represents everything I've learned from juggling with projects, iterating with AI, winning hackathons (Auth0, Postmark, Wasp) and reaching the finals of Hack for Humanity 2025. I'm aiming more than just a gallery. Hopefully it is a playable game.

Try below, currently much better when on desktop

Portfolio

🎮 Full Controls & Features

Basic Controls

Input	Action
WASD / Arrow Keys	Drive the bajaj
E	Toggle engine on/off
Shift	Boost (with shake effect)
Space	Honk
C	Toggle headlights
J	Open journal
M	Expand/collapse minimap

Gameplay Features

Feature	Description
6 Buildings	Internet Cafe, Workshop, Library, House, Arcade, Warung — each houses different project categories
Parking System	Park near "P" markers to enter buildings (cursor changes when parked)
15 Collectibles	Scattered around the world — 8 visible, 4 in knockable boxes, 3 hidden in bushes
12 Achievements	"First Steps", "Speed Demon", "Night Owl", "Explorer", "Collector", "Completionist", etc.
Speedrun Mode	Drive to the speedrun zone, enter your initials, race through 10 rings — your time gets submitted to the global leaderboard
Global Leaderboard	Best speedrun times synced via Convex backend — compete globally!
Day/Night Cycle	Based on your local time, with dynamic lighting and stars
AI Chat (Warung)	Ask about any of my 25+ projects — Gemini knows everything

🥚 Easter Eggs

Trigger	Effect
↑↑↓↓←→←→BA	Konami code — Bajaj transforms into TransJakarta bus!
Honk 5x quickly	Bajaj does a wheelie
Visit 5 buildings	Unlock different Sky texture (day: jakarta, night: aurora)
Type "disco"	Disco lights mode

How I Built It

The 20-Day Journey

This project went through 3 build plan iterations before I was satisfied. The final build plan spans 2,500+ lines of granular tasks across 8 phases:

Week 1 (Jan 12-18): Foundation + Physics
Week 2 (Jan 19-25): Assets + Interactivity + Backend  
Week 3 (Jan 26-31): Polish, Easter Eggs, Optimization, Deploy

My AI-Powered Workflow (Full Transparency)

This project is supported by Google and I'm using Antigravity IDE. Antigravity is such a blessing — I really love how it generates implementation plans and task checklists whenever we plan things. It acts as a layer between my draft ideas and real working step-by-step tasks. Antigravity-specific extension I use is called "Antigravity Cockpit" to monitor my quota.

Since I already had my build plan, I mostly did one phase per session and the implementation-task system in Antigravity followed it nicely and seamlessly. I have Google AI Pro, so I use Claude Opus 4.5 and Gemini 3 Pro.

At the start when planning, I used Perplexity to research tech stacks and make my tasks reflect real-world documentation. I kept using Perplexity in Antigravity as an MCP server until the end of the project — super useful for research tasks.

🔍 AI Code Review Army

I'm abusing AI code review on this project (in a good way!) — I use a multitude of code review AIs on a single project. I didn't pay for most of them because I either got promos or they're currently free:

Tool	How I Got It
CodeRabbit	Free via DEV++ membership
Devin Review	Currently free
Cubic	Free tier
Mesa	Free tokens (ran out near project end 😅)
Entelligence	Free tier

When people see my Git history, especially my PRs, they'll see this code review AI army butchering my code and finding bugs/edge cases!

🤖 Agent Skills I Used

I use skills.sh (Vercel's Open Agent Skills Ecosystem) to extend Antigravity. Super easy to integrate — just copy the installation script to your terminal:

find-skills — Find other skills
gcp-cloud-run — Cloud Run deployment
google-gemini-api — Gemini SDK patterns
r3f-best-practices — React Three Fiber optimization

🎨 3D Asset Generation

For the 3D models, I used FAL.ai with:

Hunyuan 3D-v3 — Text-to-3D for buildings and vehicles (LowPoly mode, 40k triangles)
Imagen 4 — Textures (road, sky, grass)
Beatoven SFX — Sound effects (engine loop, honk)

The Bajaj and TransJakarta bus (the Konami code easter egg vehicle!) were both generated this way.

💬 My Prompting Style

When I hit complex bugs found by the code review AIs, I use this prompt pattern — making the AI act as a "senior distinguished engineer under audit":

# background 

we are on the code review of current phase. 

i do use multiple ai code review for latest PR.
they are done, and i am still not merging that PR so it is still open. and currently we are still on same last working branch if im not mistaken. 
i need u to check below regarding latest PR and change, here are some of its findings. some of it have high severity, some lower.

Check if these issues are valid — if so, understand the root cause of each and fix them. 
Again, check thoroughly (multiple times, if needed) if it is valid, if it is not valid no need to do it, if it is done no need to do again.

You must act as a senior distinguished game engineer overseeing an array of multiple senior engineers, operating under strict audit constraints of third party auditor
You are required to rigorously review, verify, and implement solutions at production quality.
All code writing and evaluations must include concrete code, gameplay systems, game physics, and overall technical architecture.
You must reason step by step with meticulous scrutiny, validate every assumption, identify risks and edge cases, and produce clear, auditable corrections and improvements.
No part of the system may be treated as implicit, optional, or assumed.

i dont care if you use librarian, oracle, or any other tool that built in in your disposal. do this job as best as you can with best understanding of everything.

we have:
- agent skills finder for finding skills if you are needing to have extra hand for searching agent skill, use it for absolute best practice of anything you need to do.
- perplexity for search web but be extra careful, please do include all context and background when asking query so they are giving the solution we literally face and not some problem that similar but has different solution. 

below findings might include few or all of the code review platform, it is each wrapped between: 
`<problem>  </problem>` 
tag.

<problem>  

## bug 1
## bug 2
## etc

</problem>

(The "librarian" and "oracle" in the prompt are from Ampcode — they have these roles in their agent. I use Ampcode because they give $10/day in their free ad-supported model, which is super useful.)

I supposedly integrated Sentry and PostHog for this project to experiment with tracking, but currently paused. Curious to see how it performs in production and whether I should re-initialize the analytics again!

Tech Stack

Layer	Technology
3D Engine	React Three Fiber + Drei
Physics	Rapier WASM (not Cannon — better performance)
State	Zustand (client) + Convex (server)
UI	React 19 + TypeScript + CSS Modules
AI Chat	Google Gemini 2.0 Flash (streaming SSE)
Analytics	PostHog (paused) + Sentry
Backend	Express.js
Deployment	Google Cloud Run

Google AI Integration

The Warung Chat is powered by Gemini 2.0 Flash with a comprehensive system prompt containing:

All 25+ projects with descriptions, tech stacks, and links
Developer profile, skills, awards
FAQ responses for common questions
Building guide for navigation

// Streaming SSE endpoint
const stream = await model.generateContentStream({
  contents: [{ role: 'user', parts: [{ text: prompt }] }],
});

for await (const chunk of stream) {
  res.write(`data: ${JSON.stringify({ text: chunk.text() })}\n\n`);
}

Features:

Real-time token streaming (ChatGPT-like)
24-hour response caching
Offline fallback with retry logic
Rate limiting (10 req/min)

Performance Engineering

The build plans have explicit Performance Gates that must pass before each phase:

Metric	Target	Achieved
Mobile FPS	>30	✅ 56 FPS
GPU Time	<5ms	✅ 3.1ms
CPU Time	<10ms	✅ 5.5ms
Draw Calls	<100	✅ 56
Bundle Size	<3MB	✅ 1.28MB models

Optimizations applied:

Draco-compressed GLTF models (98.5MB → 1.28MB, 98.7% reduction)
Frame-rate independent animations
Lazy-loaded analytics (PostHog (paused)/Sentry defer via requestIdleCallback)
Device-adaptive quality (auto-detects low-end devices)
WebGL context loss recovery

Cloud Run Deployment

Deployed via source-based deployment (no local Docker required):

gcloud run deploy jakarta-portfolio \
  --source . \
  --region us-central1 \
  --memory 1Gi --cpu 1 \
  --min-instances 1 --cpu-boost \
  --set-secrets=GEMINI_API_KEY=gemini-api-key:latest \
  --labels dev-tutorial=devnewyear2026

🔐 GCP Permissions Required (for anyone replicating):

Role	Service Account	Why
`storage.objectViewer`	Compute Engine	Source access
`storage.objectAdmin`	Cloud Build	Write access
`artifactregistry.writer`	Compute Engine	Push images
`logging.logWriter`	Compute Engine	Build logs
`secretmanager.secretAccessor`	Cloud Run	Gemini API key

Important: Cloud Run has no GPU. All 3D rendering happens in the user's browser. Cloud Run only serves static files and handles API requests.

What I'm Most Proud Of

🎮 It's a Real Game, Not Just a Portfolio

Most portfolios are static pages with projects listed. This is a playable experience with:

Physics-based driving (acceleration, braking, drift)
Collectible hunting with progress tracking
Achievements that unlock as you explore
A global leaderboard for speedrunners
Easter eggs rewarding curiosity

🇮🇩 Indonesian Cultural Context

Bajaj — the iconic orange three-wheeler
Warung — traditional food stall where local indonesian people gather and chit-chats (now serving AI chat)
Jakarta Street — the overall theme
TransJakarta — the secret easter egg vehicle

🤖 AI That Actually Helps

The Warung Chat isn't a gimmick. It's the fastest way to learn about my 25+ projects. Ask:

"What are your hackathon wins?"
"Tell me about Assistant Zero"
"What's your tech stack?"

And get instant, contextual answers with streaming responses.

⚡ 20 Days, 2 Build Plans, 8 Phases

The build plans in my repo (dokss/portfolio-1-granular-build-plan-v3.md and dokss/portfolio-1-granular-build-plan-v3-neo.md) document every decision:

Why Rapier over Cannon.js for physics
How to achieve <2s cold starts on Cloud Run
Frame-rate independent animation techniques
Memory leak prevention strategies

📊 Data-Driven from Day 1 -paused

PostHog analytics supposedly were integrated (currently paused) before the first building was rendered. Every interaction is tracked:

Which buildings users visit
How long they spend driving
Which achievements unlock most
FPS samples by device type

🔗 Links

Cloud Run URL: https://jakarta-portfolio-291766337994.us-central1.run.app
Live Demo: https://3d.asynchronope.my.id
GitHub: https://github.com/bO-05/3d-portfolio
Build Plans: v3 | v3-neo
Twitter/X: https://x.com/asynchronope

Built with ❤️ from Jakarta, Indonesia

Assistant0 - Secure AI Personal Assistant

Adam — Mon, 27 Oct 2025 06:58:47 +0000

This is a submission for the Auth0 for AI Agents Challenge

What I Built

Assistant0 - A secure, enterprise-grade AI assistant that helps you manage your digital life with the power of Auth0's security features.

Assistant0 is not just another chatbot. It's a comprehensive AI agent system that can:

📧 Search and manage your Gmail - Find emails, create drafts, and send messages
📅 Manage your Google Calendar - View events and schedule meetings
🔍 Search the web - Get real-time information using Exa AI-powered search
📄 Search your documents - With fine-grained access control
🔐 Maintain complete audit trails - Every action is logged and traceable

The key differentiator? Enterprise-grade security powered by Auth0 for AI Agents, ensuring that every action your AI agent takes is properly authenticated, authorized, and auditable.

Demo

🔗 Live Demo: https://assistant0agent.vercel.app

📦 GitHub Repository: https://github.com/bO-05/assistantzero

Screenshots

Clean, intuitive chat interface powered by Mistral AI

Complete visibility into all agent actions with risk scoring and approval status

Organize your work with isolated workspaces and FGA-based permissions

How I Used Auth0 for AI Agents

Assistant0 leverages the full spectrum of Auth0's AI agent security features:

1. 🔐 Token Vault for Federated API Access

The Token Vault is the backbone of Assistant0's Google integration. When users ask the AI to read emails or create calendar events, Auth0 securely:

Stores OAuth refresh tokens
Exchanges them for access tokens on-demand
Handles token refresh automatically
Creates user-friendly authorization flows

Implementation:

export const withGoogleConnection = auth0AI.withTokenVault({
  connection: 'google-oauth2',
  scopes: [
    'https://www.googleapis.com/auth/gmail.readonly',
    'https://www.googleapis.com/auth/gmail.compose',
    'https://www.googleapis.com/auth/calendar.events',
  ],
  refreshToken: getRefreshToken,
  credentialsContext: 'tool-call',
});

When the AI agent needs to access Gmail or Calendar on behalf of the user, it seamlessly prompts for authorization with a clean UI component, then securely accesses the API.

2. 🛡️ Fine-Grained Authorization (FGA) with Okta FGA

Assistant0 implements document-level access control using Okta FGA. Users can upload documents to their workspace, and the AI agent only retrieves documents they have permission to view.

Implementation:

const retriever = FGAFilter.create({
  buildQuery: (doc: DocumentWithScore) => ({
    user: `user:${user?.email}`,
    object: `doc:${doc.documentId}`,
    relation: 'can_view',
  }),
});

// AI only sees documents user can access
const authorizedDocs = await retriever.filter(documents);

This ensures that in multi-user workspaces, the AI agent respects organizational hierarchies and access policies.

3. ⚡ Client Initiated Backchannel Authentication (CIBA)

For high-risk operations like online purchases, Assistant0 implements async authorization using CIBA. When the AI agent attempts to buy something, it:

Sends an authorization request to the user's device
Displays the transaction details ("Do you want to buy 2 iPhone for $2000?")
Waits for user approval
Only proceeds after explicit confirmation

Implementation:

export const withAsyncAuthorization = auth0AI.withAsyncAuthorization({
  userID: async () => (await getUser())?.sub as string,
  bindingMessage: async ({ product, qty }) => 
    `Do you want to buy ${qty} ${product}`,
  scopes: ['openid', 'product:buy'],
  onAuthorizationRequest: async (authReq, creds) => {
    // Non-blocking: user can approve from mobile device
    await creds;
  },
});

This prevents unauthorized purchases even if someone gains access to the chat interface.

4. 📊 Comprehensive Audit Logging

Every AI agent action is logged to the Mission Control dashboard with:

Full Auth0 user context (user ID, email, session)
Tool name and agent role (communication-agent, scheduler-agent, etc.)
Input/output data
Risk assessment scores
Success/failure status
Duration metrics
Approval requirements

This provides complete provenance and traceability - critical for enterprise compliance.

5. 🎯 Risk-Based Step-Up Authentication

Assistant0 implements adaptive security with risk scoring:

Low-risk actions (searching emails, reading calendar): Seamless execution
Medium-risk actions (creating calendar events): Standard authorization
High-risk actions (sending emails, making purchases): Step-up authentication required

The system can be extended to trigger Auth0 Guardian for MFA when risk thresholds are exceeded.

6. 🔒 Secure Session Management

All routes are protected with Auth0 Next.js SDK middleware, ensuring:

Server-side session validation
Automatic token refresh
Secure cookie handling
Protection against CSRF and XSS attacks

Tech Stack

Frontend: Next.js 15.2, React 19, TailwindCSS
AI: Mistral AI (via AI SDK), LangChain Community Tools
Auth: Auth0 for AI Agents (@auth0/ai-vercel 4.0.1)
Database: PostgreSQL with Drizzle ORM
Authorization: Okta FGA for fine-grained access control
Deployment: Vercel

Lessons Learned and Takeaways

Challenges Faced

Token Vault Interrupts vs Errors
- Challenge: Initially, token authorization failures were returning as errors instead of interrupts, preventing the UI from showing authorization buttons.
- Solution: Discovered that getAccessTokenFromTokenVault() is synchronous, not async! Removing await fixed the interrupt flow.
- Lesson: Read SDK documentation carefully - async/sync semantics matter!
Database State vs Real-Time Interrupts
- Challenge: Old error messages persisted in the database prevented new authorization flows from triggering.
- Solution: Implemented smart history loading that detects TokenVault errors and auto-clears the conversation for fresh auth attempts.
- Lesson: Stateful systems need reconciliation logic between persisted data and real-time state.
LangChain vs Direct SDK Integration
- Challenge: Gmail tools use LangChain wrappers expecting () => Promise<string> for access tokens, but Auth0 SDK provides sync access.
- Solution: Wrapped the sync token getter in an async function for LangChain compatibility.
- Lesson: Bridge patterns are essential when integrating multiple SDKs with different conventions.
Audit Logging Without Breaking Interrupts
- Challenge: Wrapping tools with audit logic could catch and suppress Auth0 interrupts.
- Solution: Explicit interrupt detection by error name and re-throwing to preserve the interrupt flow.
- Lesson: Middleware must be interrupt-aware in AI agent architectures.

Key Insights

🎯 AI Agents Need Special Security Models
Traditional web auth isn't enough. AI agents act autonomously, access multiple services, and handle sensitive data. Auth0's specialized features (Token Vault, CIBA, FGA) are purpose-built for this new paradigm.

📝 Auditability is Non-Negotiable
In production, you MUST know what your AI agent did, when, why, and with whose permission. Mission Control-style audit dashboards aren't optional - they're table stakes for enterprise AI.

🔐 Progressive Security Works
Not every action needs Guardian MFA. Risk-based authentication provides the right balance: seamless UX for safe actions, step-up auth for risky ones.

🚀 Auth0 SDK Makes Complex Auth Simple
Implementing CIBA, Token Vault, and FGA from scratch would take months. Auth0's AI SDK reduces it to configuration and a few wrapper functions.

Advice for Other Developers

Start with Auth Early - Don't bolt on security later. Design your agent architecture around Auth0's primitives from day one.
Test the Unhappy Paths - Authorization failures, expired tokens, denied requests - these are where most bugs hide. Test them thoroughly.
Build Audit Logging First - You can't debug what you can't see. Mission Control saved me hours of debugging by showing exactly what the agent was doing.
Use TypeScript - The Auth0 AI SDK has excellent types. They caught dozens of bugs during development.
Read the Vercel AI SDK Docs - Auth0's AI SDK builds on top of Vercel AI SDK. Understanding both is crucial.

What's Next for Assistant0

Multi-Agent Orchestration: Specialized agents (email agent, calendar agent) collaborating on complex tasks
Voice Interface: Speak to your AI assistant with secure voice biometrics
Mobile App: iOS/Android apps with native Auth0 Guardian integration
Enterprise Features: SSO, custom branding, admin controls for organizations
More Integrations: Slack, Microsoft 365, Notion, Linear, and more

Try It Yourself

Clone the repo: git clone https://github.com/bO-05/assistantzero
Set up Auth0 credentials in .env.local
Configure Google OAuth social connection with offline_access
Run npm install && npm run dev
Chat with your secure AI assistant!

Built with ❤️ for the Auth0 AI Agents Challenge

Special thanks to the Auth0 team for creating such a comprehensive SDK for AI agent security. This challenge pushed me to explore the cutting edge of AI authentication, and I learned more in two weeks than I have in months of regular development.

Auth0Challenge #AIAgents #NextJS #SecureAI

I built this in about 2 days, so maybe still much needed touchup!

SpiritDex: An Explorer's Journal

Adam — Sun, 14 Sep 2025 09:22:57 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

I built SpiritDex, an explorer's journal that transforms the entire world into a canvas for discovery. It's a web application where users can explore any real-world location on a map, scan for spiritual energy, and discover unique AI-generated "spirits."

Each spirit is procedurally generated by the Gemini API, with its name, lore, appearance, and stats inspired by the genuine history, folklore, and mythology of the chosen location. This creates an endlessly replayable and deeply personal collection experience. You aren't just collecting monsters; you're uncovering the hidden stories of places, given form and life by AI.

The app solves the problem of generic content in collection games by grounding every single creation in authentic, verifiable real-world lore, making each discovery feel meaningful and unique to the player's journey.

Demo

Try the applet live here: https://spiritdex-25956270103.us-west1.run.app/

Here's a walkthrough of the core user journey:

Explore & Discover: The user finds a location on the map, like the Tower of London, and scans for spirits.
Uncover an Echo: A mysterious clue and a hazy image appear, hinting at a spirit of a specific rarity.
Reveal & Collect: The user spends energy to reveal the spirit. Gemini generates its full lore, stats, and a unique portrait.
Create a Personal Encounter: The user can then take a photo and use the "Create Encounter" feature. The AI seamlessly edits the spirit into their photo, creating a personal, shareable memory.
Build Your Journal: Every spirit is added to the user's journal and deck, where they can read its history, add personal notes, and even chat with it.

How I Used Google AI Studio

Google AI Studio was instrumental for prototyping and refining the complex, multi-step prompts that power SpiritDex. I heavily relied on it to test different model configurations and system instructions to achieve the desired tone and data structure.

The app is built entirely on the capabilities of the Gemini API:

gemini-2.5-flash: This is the workhorse of the app. It handles:
- Grounded Research: Using the googleSearch tool to find authentic historical and mythological context for locations.
- Structured Data Generation: Creating the core SpiritData JSON object with a strict schema (responseSchema).
- Creative Writing: Generating cryptic clues, lore, and dynamic journal entries.
- Conversational AI: Powering the "Commune" feature, where it role-plays as the spirit using a detailed system prompt.
imagen-4.0-generate-001: This model is responsible for giving the spirits visual form. It generates the primary spirit portraits and the artistic "journal illustrations" based on detailed textual descriptions created by gemini-2.5-flash.
gemini-2.5-flash-image-preview: This powerful image editing model is the magic behind the "Create Encounter" feature, allowing for sophisticated image-and-text-to-image generation.

Multimodal Features

SpiritDex is built from the ground up on multimodality, weaving different models and inputs together to create an immersive experience.

1. Grounded Spirit Generation (Search + Text-to-JSON)

This is the core of the app. Instead of just asking the AI to "make up a spirit," I use a two-step process to ensure quality and authenticity:

Research: First, gemini-2.5-flash is prompted to use the Google Search tool to find a specific, compelling piece of lore or history about a location.
Generation: The findings from that search are then fed as context into a second prompt. This prompt instructs the model to create a spirit directly based on that context, outputting the result as a clean JSON object using responseSchema. This combination of web grounding and structured data generation ensures every spirit feels like a real, researched legend, not just a random creation.

2. Visual Manifestation (Text-to-Image)

Once a spirit's data (including a detailed visual description) is generated, that description is passed to imagen-4.0-generate-001. The prompt is specifically engineered to produce a "found footage" aesthetic (harsh flash, high ISO noise, motion blur), making the spirits feel more mysterious and grounded, as if they were captured by an amateur explorer. This directly translates the AI's textual idea into a compelling visual.

3. Personal Encounters (Image + Text-to-Image)

This is my favorite feature. A user uploads their own photo and selects a spirit. The app then sends the user's image along with a detailed text prompt to gemini-2.5-flash-image-preview. This prompt instructs the model to:

Place the spirit into the user's environment.
Generate a new background and outfit for the user that matches the spirit's lore and location.
Apply the "found footage" style to the entire image for a cohesive look.

This creates a brand new, composite image that looks like a genuine snapshot of a supernatural encounter, providing a deeply personal and shareable piece of content that connects the user directly to their discovery.

4. Location Scouting (Image-to-Text)

To enhance the exploration fantasy, users can upload a photo of a landmark. The app uses gemini-2.5-flash's vision capabilities to analyze the image, identify the location, and provide its name (e.g., "Eiffel Tower, Paris, France"). This text output is then used to automatically search for that location on the map, providing a fun, alternative way to begin the discovery process.

Ultimate List of 25+ Essential Startup Credits

Adam — Sat, 02 Aug 2025 12:25:59 +0000

The other day, I was catching up with a friend who's deep in the startup grind. He was venting about something lots of folks felt: "Why isn't there just one place to find all the startup credit programs? It's a mess of partner pages, outdated blogs, and half-remembered tweets."

He was 100% right. That conversation lit a fire under me. I decided to build the resource we were looking for. Initially, this was just for my own reference. I want to make a master list to save my sanity for future projects. But it felt selfish to keep it locked away.

So, this guide is my personal documentation, shared with all of you. My hope is that it saves you countless hours and, more importantly, helps you extend that precious runway.

Because building a startup is a race against time and money. Your runway is your lifeblood. Every dollar you don't spend on operational overhead is another dollar you can invest in product, engineering, and growth.

That's where startup credit programs come in. These aren't just small discounts; they are massive injections of non-dilutive capital. Tech giants are fighting to become the foundation of your stack, and they're willing to give you tens or even hundreds of thousands of dollars in free services to win you over.

This guide is your playbook. I've compiled a comprehensive directory of the best programs available in 2025 and broken down the strategy you need to stack them, time them, and maximize their value. Let's dive in.

Master Directory: The At-a-Glance List

Bookmark this. Here’s a quick-reference table of the best startup deals out there.

Provider	Program Name	Core Offering (Value & Type)	Key Eligibility Criteria	Direct Link to Program
Cloud & Infrastructure
Cloudflare	Cloudflare for Startups	Up to $250,000 in credits	Funded up to Series B; partner affiliation for higher tiers	https://www.cloudflare.com/forstartups/
Amazon Web Services	AWS Activate	Up to $100,000 in cloud credits	All stages; partner affiliation often required for higher tiers	https://aws.amazon.com/activate/
Microsoft	Microsoft for Startups Founders Hub	Up to $150,000 in Azure credits + software bundle	All stages; investor referral for highest tier	https://portal.startups.microsoft.com/
Google Cloud	Google for Startups Cloud Program	Up to $350,000 in credits (for AI startups)	Tiered by funding stage (Pre-seed to Series A)	https://cloud.google.com/startup
DigitalOcean	Hatch Program	Varies; 12 months of infrastructure credits	Requires VC/Accelerator partner; Series A or less	https://www.digitalocean.com/hatch
GitHub	GitHub for Startups	20 seats of Enterprise free for 1 year	Funded up to Series B; new to paid plans	https://github.com/enterprise/startups
MongoDB	MongoDB for Startups	Free Atlas credits & one-on-one technical advice	Series A or earlier; must be a product company	https://www.mongodb.com/startups
Data & Analytics
PostHog	PostHog for Startups	$50,000 in credits + generous free tier	Early-stage companies	https://posthog.com/startups
Datadog	Datadog for Startups	$30,000 - $100,000 in credits	Requires VC/Accelerator partner referral	https://www.datadoghq.com/partner/datadog-for-startups/
Twilio Segment	Segment Startup Program	Up to $50,000 in credits	Early-stage companies	https://segment.com/startups
Mixpanel	Mixpanel for Startups	1 year free on Startup Plan (1B events)	< 5 years old; < $8M funding	https://mixpanel.com/releases/startups/
Amplitude	Amplitude for Startups	1 year free on Growth Plan	< 20 employees; < $10M funding	https://amplitude.com/venture-partner-program
Algolia	Algolia Startup Program	$10,000 in credits	< 3 years old; < $5M funding	https://www.algolia.com/industries/startups
Productivity & Collaboration
Retool	Retool for Startups	1 year free (up to $60,000 value)	Series A or earlier; <$10M funding	https://retool.com/startups
Notion	Notion for Startups	Up to 6 months free (Business Plan + AI)	< 100 employees; partner affiliation for 6 months	https://www.notion.com/startups/producthunt
Linear	Linear for Startups	Up to 6 months free on paid plans	< 50 employees; requires VC/Accelerator partner	https://linear.app/startups
Asana	Asana for Startups	Discount on plans (e.g., 50% off)	Varies; direct application or via partner	https://asana.com/startups
Miro	Miro for Startups	$500 - $1,000 in credits	< 30 employees; partner affiliation for higher tier	https://miro.com/startups/
Slack	Slack Discounts	25-30% off Pro/Business+ plans	< 200 employees; available via partners	https://slack.com/partner-offers
Sales, Marketing & CX
Intercom	Early Stage Program	93% off year 1, then tapering discount	< 15 employees; < $10M funding	https://www.intercom.com/help/en/articles/9361928-early-stage-program
HubSpot	HubSpot for Startups	Up to 90% off year 1, then tapering discount	Tiered by funding; partner affiliation for best rate	https://www.hubspot.com/startups
Zendesk	Zendesk for Startups	6 months free of Zendesk Suite	< 50 employees; up to Series B funding	https://www.zendesk.com/business/startups/
Freshworks	Freshworks for Startups (Freshstack)	$3,000+ in credits	Early-stage companies	https://www.freshworks.com/company/partners/startup-program/freshstack/
Specialized Platforms
ElevenLabs	ElevenLabs Startup Grants	3 months free (11M characters/month)	< 25 employees; monetized product use case	https://elevenlabs.io/startup-grants
OpenAI	OpenAI API Credits	Up to $2,500 in credits	Via partners like Microsoft or Ramp	https://www.microsoft.com/en-us/startups/ai
Stripe	Stripe Atlas & Startup Program	$500 incorporation + waived processing fees	Varies; Atlas is open, credit program for VC-backed	https://stripe.com/startups
Gusto	Gusto for Startups	6 months free payroll (via partners)	All new businesses; partner offers vary	https://gusto.com/product/solutions/size/start-up-payroll
Rippling	Rippling for Startups	Exclusive discounts & perks	Via VC/Accelerator referral program	https://www.rippling.com/venture-firms-and-accelerators

Deep Dive: Cloud, Infrastructure & DevOps

This is your foundation. The big cloud providers are fighting an "ecosystem war" to win your loyalty early. Their goal is to get you hooked on their entire suite of tools, not just hosting. This is the most valuable category of credits.

Cloudflare for Startups

The Deal: Up to $250,000 in credits for their usage-based services, valid for one year.
The Catch: There are caps on high-demand services (e.g., only $10k on R2 storage, $50k on Workers AI). The best tiers ($25k+) require affiliation with a partner VC or accelerator.
Why It's Worth It: Beyond CDN, you get access to Workers, Pages, R2, and security tools that can form a huge part of your stack.
Link: https://www.cloudflare.com/forstartups/

Amazon AWS Activate

The Deal: Up to $100,000 in flexible cloud credits, plus technical support credits and a "deal book" with discounts on other SaaS.
The Catch: The highest credit amounts almost always require you to be part of a partner VC or accelerator's portfolio.
Why It's Worth It: It's the market leader with the broadest set of services. Credits can be used on almost anything, including ML services on Bedrock.
Link: https://aws.amazon.com/activate/

Microsoft for Startups Founders Hub

The Deal: Up to $150,000 in Azure credits PLUS free software: Microsoft 365, GitHub Enterprise (20 seats), Visual Studio, and more.
The Catch: The top tier requires a referral from an investor in their network.
Why It's Worth It: This is the ultimate ecosystem play. It can cover your cloud, dev tools (GitHub!), and office productivity software in one shot. The combined value is immense.
Link: https://portal.startups.microsoft.com/

Google Cloud for Startups

The Deal: Up to $200,000 in credits over two years (100% cover in Y1, 20% in Y2). AI-focused startups can get up to $350,000.
The Catch: Eligibility is tied directly to your funding stage (Pre-seed up to Series A).
Why It's Worth It: Huge value, especially for AI companies. The two-year structure gives you a longer runway than most 12-month programs.
Link: https://cloud.google.com/startup

DigitalOcean Hatch Program

The Deal: 12 months of infrastructure credits (amount varies by partner). Killer pricing on NVIDIA H100 GPUs.
The Catch: Strictly partner-gated. You must be affiliated with an approved accelerator or VC.
Why It's Worth It: The developer-friendly platform and exceptional GPU pricing make it a top choice for lean teams and AI startups.
Link: https://www.digitalocean.com/hatch

GitHub for Startups

The Deal: 20 seats of GitHub Enterprise free for one year, plus 50% off Advanced Security.
The Catch: Must be funded (up to Series B) and new to paid GitHub plans.
Why It's Worth It: Your code lives on GitHub. Enterprise gives you the security, CI/CD, and collaboration features you'll eventually need, for free, from day one.
Link: https://github.com/enterprise/startups

MongoDB for Startups

The Deal: Free MongoDB Atlas credits, one-on-one technical advice from their experts, and co-marketing opportunities. AI startups can get extra credits and promotion through their AI Innovators program.
The Catch: You need to be Series A or earlier and can't be an agency. They prefer referrals from VCs or accelerators, and you need a live website and company LinkedIn page to even apply.
Why It's Worth It: Get your database infrastructure covered by the leading NoSQL platform. The direct access to technical advice is a huge perk that can save you days of debugging and help you architect your data layer correctly from the start.
Link: https://www.mongodb.com/startups

Deep Dive: Data, Analytics & Observability

You can't build what you can't measure. These tools are non-negotiable for finding product-market fit. Be aware of two models here: the 1-year free plan (great up front, but watch for the pricing shock when it ends) and the generous free tier (better for a slower, more predictable cost curve).

PostHog for Startups

The Deal: A massive, always-free tier (30M events/month) plus $50,000 in credits if you outgrow it.
The Catch: The credits are for when you scale past the free tier.
Why It's Worth It: It's an open-source, all-in-one platform (product analytics, session replay, feature flags, A/B testing). It can replace 3-4 other tools.
Link: https://posthog.com/startups

Datadog for Startups

The Deal: $30,000 - $100,000 in credits for one year.
The Catch: Partner-gated. You need a referral from a VC or accelerator.
Why It's Worth It: The industry standard for observability. Monitor your infrastructure, logs, and APM in one place.
Link: https://www.datadoghq.com/partner/datadog-for-startups/

Twilio Segment Startup Program

The Deal: Up to $50,000 in credits (can last up to two years).
The Catch: Designed for early-stage companies.
Why It's Worth It: A leading Customer Data Platform (CDP). It's the plumbing that connects all your customer data tools, saving immense engineering effort.
Link: https://segment.com/startups

Mixpanel for Startups

The Deal: 1 year free on their Startup Plan, which includes a massive 1 billion events.
The Catch: Must be <5 years old with <$8M in funding. You have to start sending data within 90 days.
Why It's Worth It: No feature gates. You get all the advanced reports and add-ons from day one. A fantastic deal for B2C apps expecting high event volume.
Link: https://mixpanel.com/releases/startups/

Amplitude for Startups

The Deal: 1 year free on the Growth plan, plus lifelong discounts after the free year.
The Catch: For startups with <20 employees and <$10M funding.
Why It's Worth It: A powerful all-in-one platform with analytics, experimentation, and a CDP. The "discount for life" is a unique and valuable perk.
Link: https://amplitude.com/venture-partner-program

Algolia Startup Program

The Deal: $10,000 in credits for 12 months.
The Catch: Must be <3 years old with <$5M in funding.
Why It's Worth It: The best-in-class API for building amazing search experiences in your product.
Link: https://www.algolia.com/industries/startups

Deep Dive: Productivity & Collaboration

This is your startup's operating system. Some tools here are so dominant (Figma, Canva) they don't need a formal credit program; their free tiers are the deal.

Retool for Startups

The Deal: 1 year free on any monthly plan (up to $60,000 value), plus 25% off your second year. You also get their "Deal Book" with over $200k in partner offers.
The Catch: You must be Series A or earlier with less than $10M in funding. The weird part: you have to upgrade to a paid plan first, then apply to get the discount.
Why It's Worth It: Stop wasting precious engineering time building internal dashboards, admin panels, and support tools from scratch. Retool lets you build them in a fraction of the time, so your team can focus on your core product.
Link: https://retool.com/startups

Notion for Startups

The Deal: Up to 6 months free on the Business Plan, including Notion AI.
The Catch: You need a partner code (from AWS Activate, etc.) for the 6-month deal; otherwise it's 3 months. For new customers with <100 employees.
Why It's Worth It: It's your wiki, project manager, and doc repository all in one. Free access to the AI features is a huge bonus.
Link: https://www.notion.com/startups/producthunt

Linear for Startups

The Deal: Up to 6 months free on any paid plan.
The Catch: Strictly partner-gated. You need a code from a VC or accelerator partner and must have <50 employees.
Why It's Worth It: The gold standard for issue tracking in modern software teams. It's fast, beautiful, and a joy to use.
Link: https://linear.app/startups

Miro for Startups

The Deal: $1,000 in credits if you have a partner affiliation, or apply for $500 without one.
The Catch: For new customers with <30 employees.
Why It's Worth It: The best digital whiteboard for brainstorming, sprint planning, and remote collaboration.
Link: https://miro.com/startups/

Figma & Canva

The Deal: No formal credit programs. Their value is in their incredibly powerful and functional free tiers. Figma also offers its pro plan free for students and educators.
Why They're Worth It: They are the undisputed leaders. Figma for product UI/UX design, Canva for marketing and business assets. You can build your entire visual identity and product mockups for free.
Links: https://www.figma.com/ and https://www.canva.com/

Deep Dive: Sales, Marketing & CX

When you start getting users, you need tools to talk to them. The strategy here is often the "tapering discount": a massive discount in year one that shrinks over time. This makes adoption cheap but locks you in. Warning: calculate the Total Cost of Ownership (TCO) over 3 years before committing.

Intercom for Startups

The Deal: A steep tapering discount: 93% off Year 1, 50% off Year 2, and 25% off Year 3.
The Catch: For new customers with <15 employees and <$10M funding.
Why It's Worth It: A top-tier platform for customer messaging, support bots, and help centers. The year-one price is a steal.
Link: https://www.intercom.com/help/en/articles/9361928-early-stage-program

HubSpot for Startups

The Deal: Up to 90% off Year 1, 50% off Year 2, and 25% off in perpetuity.
The Catch: The best 90% discount requires a partner affiliation and <$2M in funding.
Why It's Worth It: An all-in-one CRM, marketing, and sales platform. If you go all-in on HubSpot, this deal can save you a fortune.
Link: https://www.hubspot.com/startups

Zendesk for Startups

The Deal: 6 months free of the full Zendesk Suite.
The Catch: For new customers with <50 employees and up to Series B funding.
Why It's Worth It: A straightforward, generous free trial of a powerful, mature customer support platform.
Link: https://www.zendesk.com/business/startups/

Deep Dive: Specialized & Emerging Platforms

Your startup needs more than just cloud and SaaS. Here are deals for AI, payments, legal, and HR.

ElevenLabs Startup Grants (AI Voice)

The Deal: 3 months free, including 11 million characters/month (200+ hours of audio).
The Catch: Must have <25 employees and a clear product monetization plan.
Why It's Worth It: The leading platform for generative voice AI. Perfect for building voice-enabled products.
Link: https://elevenlabs.io/startup-grants

OpenAI API Credits (AI LLMs) via Microsoft for AI Startup

The Deal: No direct program, but you can get credits through partners. Microsoft for Startups lets you use Azure credits on OpenAI models. Fintech platforms like Ramp offer up to $2,500 in direct API credits.
Why It's Worth It: Access to GPT-4 and other state-of-the-art models.
Link: Apply via https://www.microsoft.com/en-us/startups/ai or check your corporate card perks.

Stripe for Startups (Payments & Incorporation)

The Deal: Two parts. Stripe Atlas incorporates your company for a $500 flat fee. The Startup Program (for VC-backed companies) offers waived payment processing fees (e.g., $25k fee-free).
Why It's Worth It: Atlas demystifies and cheapens the legal setup process. Waived fees mean more revenue in your pocket.
Link: https://stripe.com/atlas and https://stripe.com/startups

Your Game Plan: How to Maximize These Credits

Getting the credits is easy. Using them strategically is what matters.

1. Build the "Zero-Cost" First-Year Stack

By layering these deals, you can eliminate most of your overhead for the first 12-18 months. Here's a sample stack:

Formation: Stripe Atlas ($500).
Cloud & Dev: Microsoft for Startups ($150k Azure credits + free GitHub Enterprise + free M365).
Docs & PM: Notion for Startups (6 months free via Microsoft partner code).
Analytics: Mixpanel for Startups (1 year free).
Design: Figma and Canva (free tiers).

2. Timing is Everything

Activate programs only when you need them. Most are time-bound.

Day 1: Use Stripe Atlas to incorporate.
First Hire: Activate Gusto or Rippling deals for HR/payroll.
MVP Dev: Activate AWS/GCP/Azure and GitHub credits.
Pre-Launch: Activate Mixpanel/PostHog to instrument your app.
Post-Launch: Activate Intercom/HubSpot to manage users.

3. How to Get the "Invite-Only" Deals

Many of the best deals (Linear, Datadog, Digital Ocean, Microsoft) are partner-gated. If you're not in a top accelerator:

Join Startup Communities: Many paid communities are official partners and unlock deals worth more than the membership fee.
Use Fintech "Super-Partners": Corporate cards like Ramp and Brex have huge deal books with exclusive offers for their customers.
Ask Accelerators: When considering an accelerator, ask for their list of software perks. It's part of their value proposition.

4. Watch Out For These Traps (A Checklist)

🔍 Read the Fine Print: Check for usage caps on specific services (like Cloudflare's R2 limit).
🗓️ Track Expiration Dates: Most deals expire in 12 months. Use 'em or lose 'em.
💸 Model the "Pricing Shock": For tapering deals (HubSpot, Intercom), calculate your year 2 and 3 costs. Don't get caught by surprise.
✅ Confirm Eligibility First: Don't build your workflow around a tool until you're sure you qualify for their startup program.

Now go build something amazing.

Async_Dime Office Personalities

Adam — Sat, 26 Jul 2025 18:21:18 +0000

This is a submission for Frontend Challenge: Office Edition – CSS Art: Office Culture.

Why I built it

Cluttered desks, whether when we viewed over Zoom or onsite, including mine, tells a story. I wanted to freeze-frame that energy in pure CSS which is four tiny workstations with each one screaming its owner’s personality. No frameworks, no images (i put one emoji as "image" tho) just gradients, borders, and far too many border-radius and other css pixel values.

See it in action

each desk can be clicked, and you can use 'esc' to exit the workspace's screen.

PS: Optimal scale view of CodePen below is 0.5x scale :)

https://github.com/bO-05/async_dime-office

How it came together

I started from a blank index.html, sketched each desk with flex and grid, then layered on animations: computer screens, objects glow, pages fluttering, and readjusting. I get an impression of 3-second loops felt lively without being chaotic. Far too many border-radius and setting pixel positioning of objects, but it is nice.

The file ended up around 4 k lines of CSS – chunky, but every keyframe is handcrafted (with the occasional AI nudge – first time posting to CodePen, I’ll take all the help I can get).

Desks are clickable: hit one and it jumps into fullscreen; mouse-wheel or arrow keys let you scroll the zoomed-in scene. Hover the little characters to read their random chatter. I use vanilla events.

If I had more time

Maybe I'll add more personal items like wallet, bags, sunglasses that make each desk more personal. Record a few extra speech-bubble lines (the developer needs more dad jokes) would be nice too. Also let the rubber-duck squeak on click (CSS-only animation, no audio). And maybe ship a dark-mode toggle for late-night coders. And few ui readjusting, I still felt this isn't that nice :).

Thanks for reading – feedback is welcome, and feel free to remix the pen!

AI Blog Studio: Multimedia Content Generation with AI & Storyblok

Adam — Sun, 29 Jun 2025 09:47:20 +0000

This is a submission for the Storyblok Challenge

What I Built

AI Blog Studio is a multimedia content generation platform that combines AI technologies with Storyblok's headless CMS. The application generates blog posts with AI-written content, contextual images, and audio narration, then stores and manages this content through Storyblok's API.

The platform automates the creation of multimedia blog posts while providing content creators with control over the generation process. Users can create complete blog experiences including text, images, and audio accessibility features through a single interface.

Demo

Live Application: https://aiblogstudio.chronolove.app/

Admin Access: Visit login page and use password: devtosecurestoryblokpassword123

Storyblok Space:
https://app.storyblok.com/#/me/spaces/285396856923566

This application uses Storyblok as a headless CMS backend for content storage. Content is managed via Storyblok's Management API and displayed through the frontend at https://aiblogstudio.chronolove.app. User when logged in can access the admin page and access all functionalities to generate multimedia blog posts with the help of AI.

Code Repository:

https://github.com/bO-05/aiblogstudio

Screenshots

Homepage showing published blog posts
Login page with password field (Password: devtosecurestoryblokpassword123)
Admin panel content generation form
Modal showing blog generated successfully
Timeline view showing post with no playable audio status
Timeline view showing post with playable audio status
Network tab showing Storyblok API calls when publishing blog post
Storyblok content tab with published status of blog post
List of blog posts in /blog page
Individual blog post without active audio player (only logged in user can generate audio)
Individual blog post with active audio player

Tech Stack

Frontend & Core

React 18 with TypeScript
Vite for development and builds
React Router DOM for client-side routing
Tailwind CSS for styling
Framer Motion for animations
Lucide React for icons

AI Services

Mistral AI (mistral-large-latest) for content generation
FAL AI with Imagen4 for image generation
ElevenLabs for text-to-speech audio

Content Management

Storyblok CMS as headless backend
Storyblok JS Client for API integration
LocalStorage for session management

Deployment

Netlify for hosting with serverless functions
Netlify Functions for production audio generation

How I Used Storyblok

Headless CMS Implementation

I implemented Storyblok as a headless CMS backend, using it for content storage while building a custom React frontend. The application uses Storyblok's Management API for content operations and the Delivery API for content retrieval.

Content Type Structure

Created a blog_post content type in Storyblok with these fields:

title (Text) - Blog post headlines
content (Rich Text) - Full markdown content
excerpt (Text) - Post summaries
image (Asset) - AI-generated images with external URL support
audio (Asset) - Text-to-speech audio stored as data URLs
theme (Text) - Content categorization
tone (Text) - Writing style metadata

API Integration

The application uses environment variables for Storyblok configuration:

// Environment setup
VITE_STORYBLOK_TOKEN=your_storyblok_preview_token
VITE_STORYBLOK_MANAGEMENT_TOKEN=your_storyblok_management_token
VITE_STORYBLOK_SPACE_ID=your_space_id

Content Publishing:

const publishPost = async (post: BlogPost) => {
  const spaceId = import.meta.env.VITE_STORYBLOK_SPACE_ID;
  const managementToken = import.meta.env.VITE_STORYBLOK_MANAGEMENT_TOKEN;

  const storyData = {
    story: {
      name: post.title,
      slug: `blog/${slug}`,
      content: {
        component: 'blog_post',
        title: post.title,
        content: post.content,
        excerpt: post.excerpt,
        image: post.imageUrl,
        audio: post.audioUrl,
        theme: post.theme,
        tone: post.tone
      }
    }
  };

  const createResponse = await storyblokManagement.post(
    `spaces/${spaceId}/stories`, 
    storyData
  );

  await storyblokManagement.get(
    `spaces/${spaceId}/stories/${storyId}/publish`
  );
};

Content Retrieval:

const getStories = async () => {
  const response = await storyblok.get('cdn/stories', {
    version: 'published',
    content_type: 'blog_post',
    starts_with: 'blog/',
    per_page: 100,
    cv: Date.now() // Cache busting
  });
};

Key Storyblok Features Used

Management API for CRUD operations
Delivery API for content retrieval
Folder Management with automatic blog folder creation
Content Publishing with immediate availability
Asset Handling for images and audio data URLs
Slug Generation for SEO-friendly URLs

AI Integration

Content Generation with Mistral AI

Uses Mistral's mistral-large-latest model for blog content generation:

const generateContent = async (request: GenerationRequest) => {
  const response = await axios.post(MISTRAL_API_URL, {
    model: 'mistral-large-latest',
    messages: [{
      role: 'user',
      content: prompt
    }],
    temperature: 0.7,
    max_tokens: 4000
  }, {
    headers: {
      'Authorization': `Bearer ${import.meta.env.VITE_MISTRAL_API_KEY}`,
      'Content-Type': 'application/json'
    }
  });
};

Features:

Configurable word counts (300-2000 words)
Three tone options (professional, casual, humorous)
JSON response parsing with fallback handling
Title and excerpt generation

Image Generation with Imagen4

Uses FAL AI's Imagen4 API for contextual image generation:

const generateImage = async (theme: string) => {
  const response = await axios.post(FAL_API_URL, {
    prompt: atmosphericPrompt,
    aspect_ratio: "16:9",
    num_images: 1
  }, {
    headers: {
      'Authorization': `Key ${import.meta.env.VITE_FAL_API_KEY}`,
      'Content-Type': 'application/json'
    }
  });
};

Features:

Theme-based prompt generation
Atmospheric scene composition
16:9 aspect ratio for blog headers
Fallback to placeholder images

Text-to-Speech with ElevenLabs

Dual-environment audio generation system:

Production (Netlify Functions):

exports.handler = async (event) => {
  const response = await fetch(`${ELEVENLABS_API_URL}/${VOICE_ID}`, {
    method: 'POST',
    headers: {
      'xi-api-key': process.env.ELEVENLABS_API_KEY
    },
    body: JSON.stringify({
      text: cleanText,
      model_id: 'eleven_turbo_v2'
    })
  });

  const audioBuffer = await response.arrayBuffer();
  const audioBase64 = Buffer.from(audioBuffer).toString('base64');

  return {
    statusCode: 200,
    body: JSON.stringify({
      audio: audioBase64,
      contentType: 'audio/mpeg'
    })
  };
};

Development (Client-side):

const generateAudio = async (text: string) => {
  const response = await axios.post(
    `${ELEVENLABS_API_URL}/${voiceId}`,
    {
      text: prepareTextForTTS(text),
      model_id: 'eleven_turbo_v2',
      voice_settings: {
        stability: 0.5,
        similarity_boost: 0.5
      }
    },
    {
      headers: {
        'xi-api-key': import.meta.env.VITE_ELEVENLABS_API_KEY
      },
      responseType: 'blob'
    }
  );
};

Features:

Rachel voice model for consistent narration
Markdown content cleaning for natural speech
Base64 data URL storage for Storyblok persistence
Environment-specific implementation

AI Content Warnings

The application includes disclaimers about AI-generated content limitations and potential inaccuracies, encouraging users to review content before publication.

Learnings and Takeaways

Technical Challenges Solved

Audio Storage in Storyblok: The main challenge was storing dynamically generated audio files. I solved this by converting audio to base64 data URLs and storing them directly in Storyblok content fields, eliminating the need for external file hosting.

Cross-Environment Audio Generation: Created a system that automatically detects the environment and uses either client-side APIs (development) or Netlify serverless functions (production) for audio generation.

Multi-Service AI Integration: Coordinating three different AI services with different response formats and rate limits required careful error handling and user feedback systems.

Storyblok Implementation Insights

Headless Architecture Benefits: Using Storyblok as a pure backend provided flexibility in frontend design while maintaining robust content management capabilities.

API Token Management: Implemented secure token handling with separate preview and management tokens, plus proper environment variable configuration.

Content Type Design: Balancing flexibility with structure in the blog_post content type, especially for multimedia content with both traditional assets and data URLs.

Development Experience

Environment Configuration: Managing multiple API keys across development and production environments required careful setup and validation systems.

Rate Limiting: Implemented configurable rate limiting to prevent API cost overruns while maintaining user experience.

Error Handling: Each AI service has different failure modes, requiring specific error handling strategies and meaningful user feedback.

What I Learned

Headless CMS Integration: Gained experience with Storyblok's Management and Delivery APIs, understanding the benefits of headless architecture for custom applications.

AI Service Orchestration: Learned to coordinate multiple AI services effectively, handling different response formats and implementing fallback strategies.

Team

This project was developed by async_dime.

Built using React, TypeScript, Storyblok, and AI technologies

Live Demo: Live demo | Admin: /login with password devtosecurestoryblokpassword123

EPB: Turn Emails into Code - AI-Powered Pull Requests from Your Inbox

Adam — Mon, 09 Jun 2025 00:50:29 +0000

This is a submission for the Postmark Challenge: Inbox Innovators.

What I Built

EPB (Email PR Bot) is an AI-powered code generation service that lets developers create code through email. Simply send an email with your code requirements, and within seconds, you'll receive a pull request with working code generated by Mistral AI, optimized for your specific repository.

The application:

Receives emails through Postmark's inbound email parsing
Extracts the instruction from the email body
Identifies the target GitHub repository (via email content or user defaults)
Analyzes the repository to understand existing code patterns and structure
Generates contextually-aware code using Mistral AI's codestral model
Creates a GitHub pull request with the generated files
Responds to the sender with a link to view the PR

This workflow creates a seamless experience where developers can quickly implement new features or fix bugs without needing to switch contexts or open their code editor.

Demo

How to Test EPB:

Send an email to: 7c3d33ed3c24d9b62b5c9ee11cd0b019@inbound.postmarkapp.com
Include a code request in the email body (see example below)
Specify a repository make pr in the test repo bO-05/mailforge-test-target as current functionality and github repo/ token is only for this repo.
Wait for the response with your PR link (usually within <1 minute)

Test Credentials:

You can use the default repository bO-05/mailforge-test-target for testing
No authentication is needed to test the service
The system's GitHub token is configured to only have access to this test repository

Real-World Example Requests:

I've tested the system with progressive enhancement requests to demonstrate its ability to understand context and build on existing code. Here are the actual email requests sent to the system:

Email #1: Basic Implementation

Subject: Python Script to Convert DOCX to Markdown

Body:
Could you please implement a simple Python script that converts a .docx file to Markdown format (.md)? The goal is to extract the text (including basic formatting like headings, bold, italics, and bullet points) and output a clean Markdown version of the document.

Result: Successfully created docx_to_markdown.py with basic formatting conversion

Email #2: Feature Enhancement

Subject: Enhancement Request: Additional Features for DOCX to Markdown Conversion of repo: "bO-05/mailforge-test-target"

Body:
I'd like to request a set of enhancements to a Python-based .docx to Markdown conversion tool — possibly building on a previous task you may have worked on involving basic text formatting extraction from Word documents.
This time, I'm looking to expand the feature set with the following:

Table conversion: Convert Word tables to Markdown tables (GitHub-compatible).

Image handling: Save embedded images to a local folder and insert Markdown image syntax in the output (e.g., ![alt text](images/image1.png)).

Hyperlink preservation: Convert Word hyperlinks to Markdown format [text](url).

Code block detection: For monospaced or code-style text (e.g., Courier New or "Code" paragraph styles), wrap the content in triple backticks (```

).

Result: Enhanced the existing script with the requested features, building on the previous implementation

Email #3: Frontend Addition



Subject: Enhancement Request: simpe frontend for DOCX to Markdown Conversion of repo: "bO-05/mailforge-test-target"

Body:
make simple frontend and edit readme to reflect our app

Result: PR created with index.html and app.py files (pending merge)

Screenshots:

Request from email

GitHub PR Created by EPB

Response Email with PR Link

Vercel logs

Code Repository

GitHub Repository: EPB (Email PR Bot)

How I Built It

Tech Stack:

Backend: Python serverless function on Vercel
Email Processing: Postmark inbound email webhook
AI Code Generation: Mistral AI (codestral-latest model)
Repository Integration: GitHub API
Email Response: Postmark outbound emails

Implementation Process:

Setting up Postmark Inbound Processing:
- Created a Postmark server with inbound webhook processing
- Configured the webhook endpoint to point to the Vercel-hosted API
- Set up email validation and parsing to extract instructions
Repository Context Analysis:
- Implemented a system to fetch and analyze existing repository structure
- Created an algorithm to identify relevant files based on request context
- Built a context-aware prompt system for the AI model
AI Code Generation:
- Integrated with Mistral AI's codestral model
- Developed a custom prompt format that includes repository context
- Implemented parsing logic to extract multiple files from AI responses
GitHub Integration:
- Created a workflow to create branches, commit files, and open PRs
- Added support for handling existing files (update vs. create)
- Implemented error handling for repository access issues
Response System:
- Designed HTML email templates for success and error scenarios
- Implemented email response logic through Postmark's outbound API
- Added tracking and detailed information in response emails

Challenges and Solutions:

Repository Context:
- Challenge: Getting the AI to understand existing code patterns
- Solution: Implemented targeted repository scanning to provide relevant code context
Email Format Parsing:
- Challenge: Reliably extracting target repositories and instructions
- Solution: Created multiple regex patterns and fallback detection mechanisms
Code Generation Quality:
- Challenge: Ensuring generated code integrates with existing repositories
- Solution: Enhanced system prompts with detailed integration guidelines
Error Handling:
- Challenge: Providing useful feedback when errors occur
- Solution: Implemented detailed error emails with troubleshooting suggestions

Experience with Postmark:

Postmark's inbound email parsing capabilities were central to this project's success. The reliable webhook system, clean email parsing, and structured JSON payload made it straightforward to extract and process email content.

Key Postmark features used:

Inbound webhook processing for email reception
Email body and subject extraction
Reply handling with StrippedTextReply
Outbound email API for response delivery
HTML email formatting for rich responses

The clean API and reliable delivery of Postmark made it the perfect foundation for this email-driven workflow. The ability to receive and process emails programmatically opened up an entirely new interface for code generation that doesn't require specialized tools or interfaces.

Team

This project was developed by async_dime.

Devbridge, a knowledge bridge

Adam — Mon, 12 May 2025 06:03:35 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: Crushing the Command Line

What I Built

I built DevBridge, an AI-Powered Cross-Project Knowledge Bridge designed to streamline command-line workflows for developers. It was developed rapidly over a few days for this hackathon, so please expect a lack of polish in some areas! Since it was heavily prototyped on Windows, its functionality on other platforms (like macOS or Linux distributions) hasn't been extensively tested and might have some quirks.

The core problem DevBridge aims to solve is reducing the friction developers face when context-switching between multiple projects, trying to understand unfamiliar code, or reusing existing solutions. It tries to make your terminal a bit smarter by integrating with Amazon Q.

Here's a quick look at what DevBridge can do, based on its devbridge --help output:

index: Index repositories to build a local knowledge base.
find: Search for code patterns and text across your indexed projects.
transfer: Adapt and transfer code between projects using Amazon Q. This is a key feature leveraging Amazon Q!
document: Generate documentation for code files using Amazon Q.
analyze: Analyze code files for best practices and issues with Amazon Q.
check-q: Verify your Amazon Q CLI setup.
learn: Fetch and process documentation from URLs or topics (with DeepWiki integration ideas).
demo: Run a quick demonstration of core features.
init: A guided setup for first-time use.
chat: An experimental interactive chat with Amazon Q about your code.
repo: Manage your local repositories.

The goal is to help developers stay in their flow by bringing AI-powered assistance directly to the command line.

Demo

Prerequisites:

Python 3.8+
Git
An AWS account and a configured AWS Builder ID for Amazon Q Developer CLI access.
Amazon Q Developer CLI (q) installed and configured.

Installation from TestPyPI:

pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ devbridge
# (This will install the latest version, e.g., 0.1.4 or newer if published)

Then, run devbridge init for a quick guided setup!

Code Repository

The code for DevBridge is open source and available on GitHub:
https://github.com/bO-05/devbridge

Feel free to explore! As mentioned, it was a quick build, so contributions or feedback for future polish are welcome.

How I Used Amazon Q Developer

DevBridge uses the Amazon Q Developer CLI (q) under the hood to bring AI capabilities to your terminal. Here's a brief overview:

Code Adaptation (transfer): When you use it DevBridge takes your source code and your prompt, sends it to the q CLI, and then incorporates Q's suggested adaptations into your target file. This helps in refactoring code to fit new project contexts.
Code Analysis (analyze): The analyze command sends the content of a specified file along with your query (via the --prompt option) to the q CLI. Amazon Q's explanation or analysis is then displayed in your terminal.
Documentation Generation (document): Similarly, the document command uses q to generate docstrings or other documentation for your code, based on the file content and your prompt.

The integration is primarily through constructing and executing q CLI commands with appropriate prompts based on user input and indexed code data. Given the short timeframe, the interaction with q is direct and aims to showcase the potential of CLI-driven AI assistance. The main insight is that with clear prompts, the q CLI is a powerful tool for these kinds of direct code manipulations and queries.

Hey I just made a game, please try it folks! ✌️

Adam — Sun, 27 Apr 2025 09:11:11 +0000

Adam

Apr 25 '25

Ali Roboshoot: A Phaser 3 Arcade Shooter Powered by Alibaba Cloud

#alibabachallenge #devchallenge #gamedev #webdev

Comments 12

5 min read

Ali Roboshoot: A Phaser 3 Arcade Shooter Powered by Alibaba Cloud

Adam — Fri, 25 Apr 2025 15:11:17 +0000

This is a submission for the Alibaba Cloud Challenge: Build a Web Game.

What I Built

Ali Roboshoot is a fast-paced, arcade shooter built with Phaser 3 and Vite. Players take command of an combat red car, battling waves of diverse robot enemies (Scarabs, Hornets, Spiders, and Orange Samurai) using primary weapons and a powerful secondary RPG.

The core gameplay involves surviving as long as possible against increasingly difficult waves of enemies. Key features include:

8-Directional Movement & Mouse Aiming: Classic arcade controls.
Multiple Enemy Types: Each with unique movement and attack patterns (melee, ranged, strafing).
Pickup System: Collect health packs, ammo clips, RPG ammo, and temporary fire rate boosts dropped by enemies.
RPG Secondary Weapon: Fires explosive rounds with area-of-effect damage.
Objective Capture: Capture flags guarded by special 'Orange Robot' enemies for bonus points. An arrow guides you to the current flag.
Time-Based Difficulty Scaling: Enemies become more numerous and spawn faster over time.
Online Leaderboard: Submit your initials and score to compete on the Top 5 leaderboard, powered by a serverless backend.
Visual Polish: Includes enemy health bars, hit flashes, screen shake, explosions, and a retro pixel art style.
Custom Initials: Players can set their own initials for the leaderboard.

The goal is simple: survive, destroy robots, capture flags, collect power-ups, and get the highest score!

Demo

Play the game live: https://aliroboshoot.chronolove.app/
Source Code: https://github.com/bO-05/ali-roboshoot
bO-05 / ali-roboshoot
Alibaba Robot Shooter Game

A web-based robot shooter game built with Phaser 3. Play as a combat red car and defend against waves of enemy robots!

A fast-paced, top-down arcade shooter built with Phaser 3 and Vite. Take command of an advanced combat vehicle and battle waves of robotic enemies in a futuristic sci-fi world!

Game Overview

Ali Roboshoot is a browser-based action game where you control a heavily armed combat vehicle fighting against relentless robot adversaries (Scarabs, Hornets, Spiders, & Orange Samurai Robot). Use quick reflexes, tactical movement, powerful weapons (including RPGs), and strategic objective captures to survive and achieve a high score!

Features
- Fast-paced, top-down arcade shooting action
- Control an advanced combat vehicle with 8-directional movement
- Multiple enemy types with unique attack patterns (melee, ranged, strafing)
- Objective Capture mechanic: Capture flags for bonus points
- Pickup system: Collect health, ammo, RPG ammo, and temporary fire rate boosts
- RPG secondary…
View on GitHub
Video Demo (2x speed):

Alibaba Cloud Services Implementation

I utilized several Alibaba Cloud services to build and deploy Ali Roboshoot, primarily focusing on cost-effectiveness, scalability, and ease of use for a web game architecture. All services were provisioned in the ap-southeast-1 (Singapore) region.

Object Storage Service (OSS):
- Why: OSS is ideal for hosting static assets and the frontend application build. It's cost-effective, highly available, and integrates well with other Alibaba services.
- How: I used two separate OSS buckets:
  - asset bucket: Stores all game assets (spritesheets, sound effects, music). The game client loads these directly.
  - game bucket: Hosts the static website build output (HTML, JS, CSS generated by npm run build). This bucket is configured for static website hosting.
- Integration: I configured a custom domain (aliroboshoot.chronolove.app) to point to the game hosting bucket and enabled HTTPS through the Alibaba Cloud console, which handled the certificate management and integration with my external DNS provider. Deploying updates was streamlined using the ossutil command-line tool to upload the contents of the dist folder.
- Experience: Setting up static hosting and the custom domain/HTTPS involved navigating the console and DNS settings, which was a learning experience but ultimately successful. ossutil was very convenient for deployment.
Function Compute (FC):
- Why: For the leaderboard backend API, I needed a simple way to handle POST requests (submit score) and GET requests (retrieve top scores). Function Compute offered a serverless approach, meaning I don't manage servers, it scales automatically, and I primarily pay for execution time, which is very cost-effective for this type of low-traffic API. I initially considered ECS but FC felt like a better fit for this simple API need and potential free tier benefits.
- How: I created a service (ali-bot-shooter-service) and deployed a Node.js 16 function (highscore-api). The function code handles database connections, executes SQL queries to insert or retrieve scores, and formats the JSON response.
- Integration: An HTTP Trigger was configured for the function, providing a public API endpoint (https://highscore-api-ali-bot-service-iwcbnbmnlw.ap-southeast-1.fcapp.run) that the Phaser game client calls using fetch. Crucially, the function was configured to run within the same VPC as the RDS database, allowing secure access via the database's internal endpoint without exposing the database directly to the public internet. Environment variables within FC were used to securely store database credentials.
- Experience: FC was relatively straightforward to set up for a simple Node.js API. The key was configuring the VPC and Security Group correctly to allow communication with RDS.
ApsaraDB RDS for MySQL:
- Why: A persistent relational database was needed to store the leaderboard scores. RDS manages the database instance (provisioning, patching, backups), simplifying operations compared to self-hosting a database. MySQL is a familiar and robust choice.
- How: I provisioned a small ApsaraDB RDS for MySQL 8.0 instance (mysql.n2.medium.1, Basic Edition, PL1 ESSD storage) within a VPC in the Singapore region. I created a dedicated database (alibotshooter_scores) and a specific user (alibot_user) with limited privileges for the Function Compute API to use. The database schema consists of a single high_scores table (id, player_initials, score, created_at).
- Integration: The Function Compute service connects to RDS using the internal endpoint (rm-gs5eh9n6m74822e3u.mysql.singapore.rds.aliyuncs.com) over the standard MySQL port (3306) within the secure VPC network. RDS Whitelist rules were configured initially for local development access via MySQL client and later potentially adjusted for the FC Security Group if needed (though VPC internal access often bypasses explicit IP whitelisting).
- Experience: Provisioning RDS was straightforward through the console. Connecting from Function Compute via the internal VPC endpoint worked well once the network configurations were correctly set up.

Game Development Highlights

First Game Project: As my first significant web game project, this was a huge learning experience, particularly with the Phaser 3 framework, game state management, and asset loading. Never knew spritesheet is such a fun assets to work with.
Cloud Deployment: Integrating and deploying the frontend (OSS + Custom Domain/HTTPS) and backend (Function Compute + RDS + VPC) on Alibaba Cloud was a practical introduction to cloud architecture for web applications.
Feature Creep (Positive!): The project grew from a basic shooter to include more complex systems like the RPG weapon, objective flags with guardian AI, and various pickups, which made development more challenging but also more rewarding.
Community Assets: Leveraging freely available graphical and audio assets (properly credited in the README) was essential for a solo developer to achieve a polished look and feel within the hackathon timeframe.
Repository Reset: An early development mistake involved committing sensitive info to a private repo. This necessitated recreating the public repository and carefully migrating the cleaned codebase, reinforcing the importance of Git security practices.

Acknowledgements

Frameworks:
- Vite
- Phaser 3
Graphic Assets:
- Matt Walkden
- Edu Silv Art
- OpenAI Sora
Sound Effects and Music - All from Pixabay:
- freesound_community
- Driken Stan
- DjLofi

The above contributors/ platforms/ frameworks made this project possible. Thank you!

Developed by B G Adam (async_dime)

Code, Nature & Personal Bits

Adam — Wed, 29 Jan 2025 05:46:46 +0000

This is a submission for the 2025 New Year Writing challenge: Compiling 2025 and Retro’ing and Debugging 2024.

As a freelancer who's seen how deep specialization creates unexpected opportunities, I'm approaching 2025 with a "T-shaped growth" mentality - going deep enough in my core skills (the vertical bar of the T) to fuel broader explorations (the horizontal top).

Here's what that looks like in practice:

🏔️ Code & Growth

Ship First - current focus queue:
- Building client's internal DB (React + RxDB)
- No-nonsense Personal Finance Calculator (Next.js + Typescript)
- Multi-Persona Chat Generator (Next.js + Elevenlabs or Kokoro)
Challenge-Driven Development: Monthly coding challenges (start small: 30-min daily sprints)
Learn Expo, to make one app for web & mobile (Android & iOS)
Learn cybersecurity by doing hands-on projects and build simple tool

My ongoing personal side project

🌿 Nature Reboot Protocol

There's something magical about standing on a mountain peak after hours of hiking. To be alone with nature, feel that same feeling of what our ancestors feel. During my university years, I lived this magic frequently—once four different mountains in a single month, including an adventure that took me 8 hours by bus to another province. Add snorkeling to the mix, and you get the picture of someone who was deeply connected to nature. I was.

This year, I'm making a conscious decision to return to these roots. Why? Because I've learned that more nature equals a happier me. It's as simple as that. Let's be real - nature's my original mental health hack. No subscription required.

Reigniting my university-era outdoor cadence:
- 1 mountain bi-monthly
- Getting back in the water (snorkeling, diving maybe, idk?)
- Rediscovering bus/ train adventure days (>5-hour rides = perfect audiobook time)
New phone rules:
- No devices above 2,000m elevation
- No devices when it is nature time

As Trump, (hypothetically) said:

"Folks, our nature - it's tremendous, absolutely tremendous. The trees, they're doing things nobody's ever seen before. And the mountains? Big, beautiful mountains. Nobody has mountains like we do, believe me. It's fantastic, maybe the most fantastic nature in history. That's what everyone is saying!"

😂😂

But, it is beautiful, isn't it?

🤝 Connection Stack

The post-pandemic world left many of us, including myself, retreating further into our shells. While my introverted nature served me well during isolation, 2025 is about finding balance. Starting from zero? Perfect. No legacy code to maintain here.

Metric	2024 Baseline	2025 Target
IRL Collabs	4/year	1/month
Tech Coffee Chats	0	1/quarterly
Mentorship	None	1 mentee

📔 Journaling 2.0

In 2024, I started a journaling practice that, like many new year's resolutions, faded after two months. But I was approaching it all wrong. I saw journaling as a productivity hack, but its real value lies in its ability to make us more human. If I wrote it, I was alive that day. That's enough.

Thankfully, my undated journal is patient, waiting for me to continue our conversation in 2025.

New rule: If it's written, it counts. Even if it's:

console.log("2025-02-01: Ate rice, debugged things, survived")

The undated journal is my anti-perfectionism weapon. Now tracking:

Some daily wins (any size)
1 curiosity nugget (non-tech allowed)
Sunset time (forces outdoor break)
Mood
Habits

🔥 Core Realizations

These two brain bombs keep me grounded:

I read psycho-cybernetics by Maxwell Maltz and I think this quote capture a principle very similar to what his teachings is about:

"I stopped thinking life was so hard and it stopped being so hard"

An infoblessing + infohazard in one quote:

"There is no audience to perform for, there is no approval, no admiration to attain. There is no role worth playing, there is no one to convince. Let it go."

All pictures above were taken by me and are from my own personal gallery during my trip.

Your turn: What's one non-technical goal that'll make your 2025 coding better? Mine's "nature will take care of you". Let's compare roadmaps 👇