DEV Community: Naomi Pereira

Passion Brought Me to Open Source. PatchQuest Helps Others Get Started.

Naomi Pereira — Sun, 12 Jul 2026 21:36:17 +0000

PatchQuest: Turning Passion into Open Source Contributions

This is a submission for *Weekend Challenge: Passion Edition*.

🚀 What I Built

When I saw this weekend's theme, Passion, my mind immediately went to open source.

Every day, thousands of developers star repositories, bookmark issues, and tell themselves they'll contribute "one day." But that first contribution can feel overwhelming. You have to understand an unfamiliar codebase, pick up new concepts, and somehow know where to begin.

I wanted to build something that makes that first step feel a little less intimidating.

That's how PatchQuest came to life.

PatchQuest transforms real GitHub issues into personalized learning quests. Instead of simply giving you the answer, it helps you understand the problem, learn the concepts behind it, and build the confidence to contribute.

The workflow

Start with any GitHub issue.
PatchQuest analyzes the repository using Google Gemini.
Receive a personalized learning quest based on the skills you'll need.
Learn the concepts before diving into the code.
Pair program with a live AI mentor using voice and screen sharing, powered by Google Gemini and ElevenLabs.
Generate a PR Readiness Report before opening your pull request.
Keep learning on the go with the Wear OS companion app, where you can track your progress, active quests, reminders, and streaks.

Personalized Learning Quest

Gemini Live Pair Programmer

PR Readiness Report

‹ ›

🎥 Demo

You can try PatchQuest here:

🌐 Live Application

https://patchquest.vercel.app

Or watch the demo below.

Note: Developer logs are intentionally visible during the demo to make the AI pipeline easier to follow. The live application showcases the polished production UI without those logs.

💻 Code

The complete source code is available on GitHub.

NaomiiAP / patchquest

🐉 PatchQuest

Your AI pair programmer for open source. Learn, build, and contribute with confidence.

Turn GitHub issues into personalized learning quests powered by Google Gemini Built for the DEV Weekend Challenge: Passion Edition using Google Gemini, Gemini Live, ElevenLabs, and Wear OS.

🎥 Demo

🌍 Live Website	patchquest.vercel.app
📖 DEV Post	dev.to/naomiiap/patchquest

🔥 What is PatchQuest?

Open source is hard to break into. You find a promising GitHub issue, read it once, and immediately feel lost — "What even is a race condition? What's a mutex? Where do I start?"

PatchQuest fixes that. Paste a GitHub issue URL and watch it transform into a structured learning quest — skill gaps identified by Gemini AI, curated resources, a step-by-step solution outline, and a voice tutor to walk you through it all. It even includes a Wear OS companion app to keep your learning journey with you wherever you go.

This…

View on GitHub

⚙️ How I Built It

I wanted PatchQuest to feel like more than another AI coding assistant. The goal was to build something that helps developers learn while contributing to open source instead of simply generating answers.

Google Gemini

Google Gemini powers the core experience. It analyzes GitHub issues, understands repositories, identifies the skills required for each task, creates personalized learning quests, powers the live AI pair programmer through voice and screen sharing, and generates PR Readiness Reports before a pull request is submitted.

ElevenLabs

For the live mentoring experience, I integrated ElevenLabs to provide natural voice interactions. I wanted conversations to feel less like talking to a chatbot and more like pair programming with another developer.

Wear OS Companion

One feature I especially enjoyed building was the Wear OS companion app. Learning doesn't stop when you step away from your computer, so the watch lets you keep track of your active quest, progress, reminders, and streaks without needing to open the web app every time.

The biggest challenge wasn't building each feature individually. It was making repository analysis, learning quests, live mentoring, PR review, and the smartwatch companion all feel like one seamless experience.

🏆 Prize Categories

I'm submitting PatchQuest for the following prize categories.

🤖 Best Use of Google AI

Google Gemini powers:

Repository understanding
GitHub issue analysis
Skill mapping
Personalized learning quests
Live AI pair programmer with voice and screen sharing
PR Readiness Reports

🎙️ Best Use of ElevenLabs

ElevenLabs powers the live AI mentor's voice, making mentoring sessions feel natural and conversational while pair programming.

Thanks for taking the time to check out PatchQuest! I'd genuinely love to hear your thoughts and feedback.

CareSync: A Local Health Memory Agent for Family Caregivers

Naomi Pereira — Sun, 31 May 2026 18:20:02 +0000

This is a submission for the *Hermes Agent Challenge*: Build With Hermes Agent
(had to edit as code block wasnt rendered properly)

What I Built

CareSync is a CLI-based caregiving assistant that helps me keep track of everything related to caring for my grandmother.

I'm Naomi, a 21-year-old engineering student. Between classes, assignments, and part-time work, I also help care for my grandma, Kamala. Over time, I realized that caregiving is surprisingly difficult to manage.

A symptom might be mentioned over breakfast. A medication change could happen after a doctor visit. A few weeks later, someone asks, "Has this happened before?" and suddenly I'm digging through WhatsApp messages, notes, and my memory trying to find the answer.

I built CareSync to solve that problem.

CareSync acts as a personal caregiving command center. It stores observations, symptoms, medications, reports, and important events in a local SQLite database, making them searchable and easy to organize.

For example, I can quickly log a symptom:

./caresync add "Kamala felt dizzy after breakfast"

Search past events:

./caresync search --person Kamala --query dizziness

Generate a doctor-ready summary:

./caresync brief --person Kamala --days 14

Or create handoff notes when another family member takes over care:

./caresync handoff --person Kamala --for-person Aunt

CareSync isn't just a record-keeping tool. It helps answer questions, identify recurring patterns, prepare for appointments, and keep family members aligned.

Key capabilities include:

Quick logging of symptoms, meals, medications, vitals, and observations
Searching historical events and recurring symptom patterns
Medication tracking and report imports
Appointment briefs and doctor question generation
Caregiver handoff summaries
Audit logs for transparency
Natural-language workflows powered by Hermes Agent
Local-first storage using SQLite

CareSync does not provide medical advice. Its goal is to help caregivers remember less, stay organized, and feel more prepared.

Demo

The demo follows a typical caregiving workflow using CareSync.

It starts with logging a new symptom after Grandma mentions feeling dizzy. From there, CareSync is used to search past observations, helping answer an important question before a doctor visit: "Has this happened before?"

Next, the demo shows how CareSync can generate suggested questions for the doctor and create a concise appointment summary based on recent observations.

The demo also highlights Hermes Agent's natural-language capabilities. Instead of manually searching records, I can ask questions like:

Has Grandma been dizzy before?

Hermes searches the caregiving history, identifies relevant events, and returns a summarized answer with supporting context.

Finally, the demo demonstrates transparency through the audit log, showing how actions performed by the agent can be reviewed and traced.

Example commands shown in the demo:

./caresync add "Kamala felt dizzy after breakfast"
./caresync search --person Kamala --query dizziness
./caresync timeline --person Kamala
./caresync questions --person Kamala
./caresync brief --person Kamala --days 14
./caresync handoff --person Kamala --for-person Aunt
./caresync chat "has grandma been dizzy before?"
./caresync audit

Code

Repository: https://github.com/Byte-Sized-Brain/caresync

Architecture

My Tech Stack

Core Technologies

Hermes Agent – Natural-language orchestration and skill execution
Python 3.12 – Core application and CLI implementation
SQLite – Local-first storage for observations, medications, reports, and audit logs
agentskills.io – Custom Hermes skill definitions and execution
Terminal-based CLI – Primary interface for caregivers
Nous Portal – Development, testing, and agent deployment

Hermes Skills

CareSync is powered by seven custom Hermes skills:

log-health-event – Record symptoms, meals, vitals, medications, and observations
symptom-search – Search historical records and identify recurring patterns
medication-tracker – Manage medications, doses, and prescriptions
import-report – Import reports and prescription information into memory
appointment-brief – Generate summaries for upcoming doctor visits
handoff-notes – Create caregiver transition summaries for family members
doctor-questions – Suggest follow-up questions based on observations and reports

Storage Philosophy

CareSync is designed to be local-first. All caregiving information is stored in a local SQLite database rather than a cloud service, giving caregivers full ownership of their data while enabling long-term searchable memory.

How I Used Hermes Agent

CareSync started as a collection of CLI tools for managing caregiving information. While the commands are useful, caregiving often involves answering questions rather than running specific commands.

That's where Hermes Agent comes in.

Hermes acts as an orchestration layer on top of CareSync's tools and memory. Instead of remembering which command to run, I can describe what I need in natural language and Hermes determines the appropriate actions.

For example, I can ask:

Has Grandma been dizzy before?

Hermes searches historical observations, reviews matching events, identifies patterns, and returns a concise answer based on information stored in CareSync.

The biggest advantage came from multi-step workflows.

Consider the request:

Prepare me for tomorrow's doctor appointment.

Instead of manually reviewing notes and running several commands, Hermes can:

Search recent symptoms and observations
Review medication history
Generate suggested doctor questions
Create an appointment summary

All from a single request.

Hermes is also useful for family coordination. When another family member takes over caregiving responsibilities, the agent can gather recent observations, medication updates, and upcoming appointments to generate a clear handoff summary.

The terminal tool was particularly valuable because Hermes performs real actions against the CareSync CLI rather than generating responses from memory alone. Every action interacts with actual data stored in SQLite and is recorded in an audit log.

This makes CareSync feel less like a collection of commands and more like an assistant that understands caregiving workflows. Hermes handles the reasoning and orchestration, while CareSync provides the tools and long-term memory.

Why I Built This

I built CareSync because I experienced this problem myself.

As a student, I help care for my grandmother, Kamala. Important details like symptoms, medication changes, and doctor recommendations were often spread across messages, notes, and memory.

CareSync gives me one place to record, search, and organize that information, making it easier to prepare for appointments and keep family members informed.

Its goal is simple: reduce the mental load of caregiving and help families stay organized.