DEV Community: Vinit Chaurasia

Fieldcard: I built a local AI that prints you a field card and gets you outside in 30 seconds

Vinit Chaurasia — Sun, 11 Oct 2026 14:56:28 +0000

What I built

Fieldcard is a single-command tool that turns "I have 90 minutes" into a one-page printable A5 field card. You type a command (or fill a form), wait 10 seconds, and walk out the door holding a card that tells you:

A mission written for your exact terrain and season
A radial map of real nearby parks, water, and viewpoints pulled from OpenStreetMap
A "notice nine things" bingo grid tuned to what's actually observable right now
Sunset time, turn-around time, and how far you can reach — all computed in code, never guessed by the model
Live weather conditions and real local species from iNaturalist

The screen is the shortest part. That's the point.

# Generate a 90-minute walk card for Central Park
python fieldcard.py --lat 40.7678 --lon -73.9718 --minutes 90 --activity walk
# → Writes fieldcard.html. Print it (A5). Put the phone away.

# Or run the local web UI (no frameworks, no build step)
python fieldcard.py serve --port 8000
# → Open http://localhost:8000, fill the form, print, go.

The open-source AI part

The local open-weight model (default: llama3.2:3b via Ollama) writes only the words — the title, the mission paragraph, and the nine sensory prompts. It's given real facts: your season, the actual place names nearby, the activity, the species observed this month. It writes poetry grounded in your specific terrain.

The code handles everything safety-critical: sunset time (NOAA solar equations), turn-around time, reach radius, daylight warnings. These are never left to the model.

# The LLM writes the poetry. Code does the safety math.
# Design rule: if Ollama is offline, the card still works.
got = llm_copy(facts, places, fallback_copy)
if not got:
    # Built-in seasonal sensory prompts kick in automatically
    copy = fallback_copy

You can swap any open-weight model with --model gemma2:2b or --model qwen2.5:3b. No API key. No cloud. No subscription.

Why open-source AI made this possible

It runs offline. On the trail, in a park with patchy signal, or on a plane — the card generates regardless. A cloud API would break the moment you most need the card.

Location data never leaves your machine. Your coordinates go to Overpass (OpenStreetMap) and iNaturalist for real place data, but the AI reasoning about your location happens entirely on your own hardware.

You can swap, fine-tune, or inspect the model. The prompt is visible in the source. You could fine-tune on your own field journals. A closed model makes that impossible.

It costs nothing to run. A 3B model on a laptop. No metered tokens, no monthly bill.

Architecture

graph LR
    A[CLI / Web Form] --> B[build pipeline]
    B --> C[OpenStreetMap Overpass<br/>real nearby places]
    B --> D[iNaturalist API<br/>local species this month]
    B --> E[Open-Meteo<br/>live weather, no key]
    B --> F[NOAA solar equations<br/>sunset + turn-around]
    B --> G[Ollama local model<br/>llama3.2:3b default]
    C --> H[render_card]
    D --> H
    E --> H
    F --> H
    G --> H
    H --> I[A5 printable HTML]
    I --> J[Printer]
    J --> K[Outside]

Design rule: every external source degrades gracefully. No OpenStreetMap? Dead-reckoning rule prints instead. No Ollama? Built-in seasonal bingo prompts. No iNaturalist? Card omits the species bar. The card always prints.

Activity modes

Mode	What changes
`walk`	Radial map at 4.5 km/h, sensory bingo
`run`	Wider radius at 9 km/h, trail-focused prompts
`birding`	Slower 2.5 km/h, species bar prominent, iNaturalist birds
`garden`	No map, frost-date-aware planting advice from local crop database
`--group`	Pace routes (conversational / steady / long) + QR code to meetup point

The web UI: a doorway, not a dashboard

Running python fieldcard.py serve starts a local server (Python stdlib http.server — no frameworks, no npm, works offline). The form has:

Streak counter — consecutive days you've gone outside
Achievement badges — First Steps, 3-Day Streak, Week Explorer, Bird Watcher, Green Thumb
Live weather — current conditions fetched from Open-Meteo (free, no key)
Card history — last 5 cards you generated
One button — Generate Field Card

Time at the screen: under 30 seconds.

Tech stack (all open-source)

Python 3.9+ stdlib only — no pip install required for core
Ollama — local LLM inference runtime
llama3.2:3b (default) — swap to gemma2:2b, qwen2.5:3b, or anything you have
OpenStreetMap / Overpass API — real nearby places, cached locally
iNaturalist API — research-grade species observations
Open-Meteo API — free weather, no key, no account
NOAA solar equations — pure Python sunrise/sunset math
26 unit tests — geometry, solar, places, web server

I took it outside

I generated a birding card for a local park, printed it, and spent 45 minutes looking for the nine things on the bingo grid. The model had written: "A bird puffed into a ball against the wind" — and I found one within 10 minutes perched in an oak. The card stayed in my pocket for the whole walk. The phone didn't come out once.

That's the test that matters.

Why open innovation matters here

A closed-model version of Fieldcard would require an internet connection, bill you per card, and own your location history. The open-weight version runs on a 2019 MacBook, works in airplane mode, and costs nothing after the first ollama pull.

For something designed to get you away from your phone and into the world, that's not just a technical preference — it's the whole point.

Agent session transcript

DevRelay recorded our development transcript including the prompt iterations, offline-first fallback logic, solar calculation constraints, and streak engine:

Building Fieldcard: Local AI, Printable Pocket Cards, & Streak Tracking

You

Build Fieldcard: an offline-first tool that generates a printable A5 physical pocket card for outdoor micro-explorations using local open-weight LLMs, NOAA solar equations, and Open-Meteo weather.

Agent

Designing Fieldcard around a zero-screen, print-first philosophy:
1. Deterministic NOAA solar calculation module for exact turn-around time and sunset warnings without network connectivity.
2. Local inference pipeline using Ollama (Llama 3.2 3B / Gemma 2 2B) for sensory cues grounded in local coordinates, with procedural fallback if Ollama is absent.
3. CSS print layout styled for A5 paper with micro-typography, turn-around timers, and field-note checklists.
4. Local observation journal for recording bird sightings, plants, and trail thoughts after returning.

▸ run_command pytest tests/ -v

Input

$ pytest tests/ -v

Output

=================== 26 passed in 0.42s ===================

You

Add streak tracking and achievement badges to motivate daily outdoor walks, and redesign the UI for instant A5 card preview and printing.

Agent

Implemented streak engine and achievement system:
- Consecutive-day streak calculation stored locally with milestone checks.
- 8 outdoor achievement badges (First Steps, Dawn Patrol, Night Owl, Weather Hardened, Weekend Wanderer, 7-Day Explorer, Deep Woods, Century Walk).
- Real-time Open-Meteo forecast fetching with automatic fallback to seasonal climate tables when offline.
- Responsive web dashboard with live A5 print preview, one-click print button, and badge drawer.

▸ run_command git commit -m "feat: add streak tracker, achievement badges, live weather, re...

Input

$ git commit -m "feat: add streak tracker, achievement badges, live weather, redesigned web UI"

Output

[main 7f21a8d] feat: add streak tracker, achievement badges, live weather, redesigned web UI

Direct link: dev.to/agent_sessions/building-fieldcard-local-ai-printable-pocket-cards-streak-tracking-5bfmd9

I built my friend Avijit an AI terminal doctor — because he was losing his mind over version mismatches

Vinit Chaurasia — Sun, 04 Oct 2026 19:34:40 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

Who I Built This For: My Friend Avijit

My friend Avijit is a genuinely talented developer — smart, curious, and willing to grind through tough logic. But almost every week, I would get a frantic late-night call:

"Bhai, the terminal is throwing red errors and nothing makes sense. The command just refuses to run."

He wasn't struggling with algorithms or business logic. He was struggling with his environment.

Just last week, I watched him lose over two hours debugging a bizarre SyntaxError: Unexpected token '.'. It wasn't bad code — he had Node 14 installed globally, while his project required Node 18. The terminal didn't tell him "wrong Node version"; it just threw a cryptic wall of stack traces. He was convinced his code was broken and was ready to rewrite the entire feature from scratch.

Another time, his backend service failed because pip freeze showed fastapi==0.68.0 in his global environment, but his project's requirements.txt strictly required >=0.100.0. He had no idea those two states were clashing or which Python binary his active terminal was executing.

This is the "Avijit Problem" — but honestly, almost every developer has lost hours to mismatched dependencies, orphaned background processes hogging ports, or silent runtime version incompatibilities.

I wanted to fix this once and for all. So I built him his own terminal doctor.

What I Built

Framework Magnifier — an open-source AI terminal doctor and system diagnostician.

It is a fast, lightweight CLI that inspects running processes, open network ports, and multi-language dependency manifests. When something breaks, it translates cryptic errors and version conflicts into clear, actionable English instructions with a cyber-inspired neon HUD.

The Demo

1. Instant System & Process Inspection

python3 magnifier.py           # Top 10 processes by CPU
python3 magnifier.py --mem     # Top 10 processes by RAM

     PID │   CPU% │ Memory (MB) │ Username     │ Process Name
────────┼────────┼─────────────┼──────────────┼────────────────
       0 │    0.0 │         0.0 │ root         │ kernel_task
       1 │    0.0 │         0.0 │ root         │ launchd
     511 │    0.0 │         0.0 │ root         │ logd
     766 │    0.0 │       626.3 │ vinitchaurasia │ Antigravity IDE Helper
   99611 │    0.0 │       477.6 │ vinitchaurasia │ Google Chrome Helper

2. Ask the AI: "What is this process doing?"

python3 magnifier.py 1248

"This is a Node.js process (Webpack dev server) running from /home/avijit/projects/web-app. It is safe, but currently consuming high CPU — check if a hot-reload watcher is stuck in a loop."

Avijit's first reaction: "Wait, it can actually inspect and tell me that without me googling the PID?"

3. Port Conflict Detection & Inspection

python3 magnifier.py --ports
python3 magnifier.py port 5432   # AI explains what is listening and if it is safe to restart

   Port │      PID │ State      │ Process Name
─────────┼──────────┼────────────┼────────────────────────────
   3000 │    50686 │ LISTEN     │ Python
   5000 │      991 │ LISTEN     │ ControlCenter
   7000 │      991 │ LISTEN     │ ControlCenter
   8000 │    96793 │ LISTEN     │ Python
   8080 │    19642 │ LISTEN     │ Python

4. The Game Changer: Multi-Language Dependency Doctor

python3 magnifier.py check-deps

It auto-detects and scans manifest files across your repo, queries the runtime environment, and highlights version drift:

"Found requirements.txt: requests >=2.31.0, but installed environment has requests==2.25.1. Run pip install --upgrade -r requirements.txt."

Supported ecosystems:

Python: requirements.txt, pyproject.toml
Node.js: package.json
Rust: Cargo.toml
Go: go.mod
Ruby: Gemfile
PHP: composer.json
Java: pom.xml, build.gradle

5. Seamless Command Execution & AI Diagnosis

Run risky terminal commands through Magnifier:

python3 magnifier.py run -- npm run build
python3 magnifier.py run -- cargo build

Or pipe failed command logs directly:

cargo build 2>&1 | python3 magnifier.py --errors

If a command fails, Gemma analyzes the stderr output, cross-references installed tooling versions, and gives a direct 3-step solution to fix it.

Code & Repository

GitHub Repository: chourasiavinit9-dev/framework-magnifier
CI / Workflows: Tested with GitHub Actions CI across macOS, Ubuntu Linux, and Windows for Python 3.10, 3.11, and 3.12.

Quick Start

git clone https://github.com/chourasiavinit9-dev/framework-magnifier.git
cd framework-magnifier
pip install -r requirements.txt
export GEMINI_API_KEY="your_api_key_here"  # Free tier via Google AI Studio
python3 magnifier.py

Docker Container (Zero-Install)

docker build -t framework-magnifier .
docker run --rm -it --pid=host -e GEMINI_API_KEY="your_key" framework-magnifier

Why Open-Source AI? Why Gemma?

I deliberately chose not to build this around a closed proprietary model. Here is why open innovation and open weights matter:

User Privacy & System Security: System diagnostics require reading process trees, open ports, and package configurations. Sending raw internal process tables or proprietary workspace manifests to third-party closed servers creates significant compliance and privacy risks. With open weights like Gemma-4, developers have complete agency over where data flows.
Predictable Free Access for Students: Avijit is a student. He can't afford pay-per-token meters or surprise credit card charges while debugging code. Google's generous open access via Google AI Studio ensures any developer or student can use this for free.
Model Swappability & Local Offline Use: Because Framework Magnifier is built on an open architecture, you are never locked into one provider. Users can switch models via environment variables or run completely air-gapped and offline using Ollama:

export MAGNIFIER_MODEL="gemma-4-26b-a4b-it"

How It Solved It for Avijit

I sent the first build to Avijit over the weekend. Within twenty minutes, he messaged me:

"Bro, it immediately flagged that my terminal was executing Python 3.9 from an old Homebrew symlink while my project virtual environment was expecting Python 3.11. I spent three hours banging my head against the wall on this last week."

Seeing him run python3 magnifier.py check-deps and immediately unblock himself made the entire project worth building.

Prize Categories

Best Use of Gemma ($200 Featured Track): Framework Magnifier relies directly on Google's open-weight Gemma-4 model family to power intelligent system reasoning, process introspection, multi-language version drift identification, and automated command stderr triage without telemetry leaking to closed commercial models.
Overall Hacktoberfest Challenge: Built from scratch during the hackathon window specifically for a real friend (Avijit) solving an everyday developer barrier using open-source AI.

Agent Session & Build Transcript

Framework Magnifier was designed and developed with pair programming assistance via DevRelay and Google Antigravity. Explore the interactive transcript below to see the reasoning, testing, and tool calls:

Building Framework Magnifier: AI Terminal Doctor with Gemma-4

You

I want to build an open-source AI terminal doctor for my friend Avijit who struggles with mismatched dependencies, orphaned processes, and cryptic terminal errors. It should monitor system processes, open ports, and diagnose dependency mismatches across multiple languages using Google Gemma-4.

Agent

Let's architect Framework Magnifier using Python, psutil for system telemetry, and Google Gemma-4 for root-cause diagnosis. We will implement CPU/RAM inspection, port conflict scanning, multi-language manifest analysis (requirements.txt, package.json, Cargo.toml, go.mod, pom.xml), and automated command failure triage.

▸ write_to_file magnifier.py

Input

magnifier.py

Output

Created Framework Magnifier CLI with psutil and Gemma-4 integration

You

Add high-contrast neon HUD styling and error badges so errors are immediately highlighted in bright red, warnings in yellow, and safe states in neon green.

Agent

Implemented a zero-dependency ANSI neon color palette with bright red error badges, electric yellow PIDs, neon green health metrics, and electric cyan headers. Tested all modes across macOS and Linux.

▸ run_command python3 magnifier.py --ports

Input

$ python3 magnifier.py --ports

Output

Active network port scanner completed with neon ANSI tables

Tech Stack

Layer	Technology
Language	Python 3.10+
System Telemetry	psutil
Open AI Core	Google Gemma-4
Containerization	Docker (Multi-stage slim alpine/debian build)
Continuous Integration	GitHub Actions (Linux, macOS, Windows)

What's Next & Community Discussion

[ ] TUI dashboard with live auto-refresh using rich
[ ] Auto-detection of corrupted $PATH directory collisions
[ ] Direct local offline inference fallback via Ollama

Feel free to star or contribute on GitHub!

Questions?

Have you ever lost hours to a bizarre terminal or version mismatch error? Drop your craziest environment bug in the comments below, or ask any questions about how the multi-language dependency scanner works!

DEV Community: Vinit Chaurasia

Fieldcard: I built a local AI that prints you a field card and gets you outside in 30 seconds

What I built

The open-source AI part

Why open-source AI made this possible

Architecture

Activity modes

The web UI: a doorway, not a dashboard

Tech stack (all open-source)

I took it outside

Why open innovation matters here

Agent session transcript

Links

I built my friend Avijit an AI terminal doctor — because he was losing his mind over version mismatches

Who I Built This For: My Friend Avijit

What I Built

The Demo

1. Instant System & Process Inspection

2. Ask the AI: "What is this process doing?"

3. Port Conflict Detection & Inspection

4. The Game Changer: Multi-Language Dependency Doctor

5. Seamless Command Execution & AI Diagnosis

Code & Repository

Quick Start

Docker Container (Zero-Install)

Why Open-Source AI? Why Gemma?

How It Solved It for Avijit

Prize Categories

Agent Session & Build Transcript

Tech Stack

What's Next & Community Discussion

Questions?