Read the full submission
Project Description
Care Circle is a bilingual (English/Spanish), mobile-first web app built for a family of five sisters coordinating care for their two aging parents. Information that used to live scattered across group texts, memory, and paperwork — medications, appointments, hospitalizations, symptoms, lab results, documents — now lives in one shared record every sister can log into and see.
Focus: turning raw caregiving data into understanding. It's not just a shared spreadsheet — an AI assistant named "Kin" (built on Claude) explains what each medication is actually for given the parent's real situation, flags documented drug interactions worth asking a pharmacist about, and reads/summarizes paperwork (bottles, insurance cards, lab reports, hospital discharge summaries) so a family member never has to manually type in what a photo or PDF already says.
Mission: the family understands what's going on and nothing falls through the cracks — and no single sister has to hold it all alone.
Strengths:
- AI does the data entry, not the family. Point a phone camera at a pill bottle, insurance card, or lab report and Kin reads it, extracts the details, and asks for a quick confirm — because any tool that's hard to set up gets abandoned back to group texts.
- A hard-enforced AI safety boundary. Kin informs and flags — it explains and surfaces cautions "worth asking the doctor about," but it is never allowed to tell anyone to start, stop, or change a medication. This is enforced by one shared safety-line instruction across every AI call in the app, not a disclaimer bolted on after the fact.
- Bilingual by design. Interface language and generated-content language are independent choices, built in from day one rather than retrofitted.
- Real privacy posture for sensitive records. Documents are stored behind authentication (not public URLs), with a PIN-locked folder specifically for IDs/SSNs.
- Built to scale beyond one family. A multi-tenant "Circles" model means the same app can host other families' care circles in full isolation.
- Timezone-aware for a geographically spread-out family (Orlando, Phoenix, and Paraguay all appear in real usage), so an appointment time is never ambiguous.
Achievements
- A complete shared care record: recipient profiles, medications, diagnoses, symptoms, appointments & hospitalizations, lab results, a flags/action-items system, and a secure document vault.
- AI photo-scan intake across four different document types (medication bottles, insurance cards, lab reports, appointment printouts) — Claude's vision reads the photo and pre-fills the form.
- An AI visit notetaker: record a doctor visit, Deepgram transcribes it (auto-detecting English/Spanish mid-conversation), and Kin turns it into a structured note with a separate "questions to ask" list.
- Automatic hospital discharge report intake: upload a PDF and Kin reads, summarizes, and archives it as a filed note with zero manual typing.
- AI medication intelligence: a plain-language "why you take this" explanation per medication, plus automatic cross-medication interaction flags, regenerated any time the medication list changes.
- Full medication lifecycle: pause/resume with notes, time-of-day grouping, and a clean printable medication schedule for at-a-glance tracking.
- Multi-user, multi-tenant architecture: individual logins, admin controls, and a "Circles" model for hosting unrelated families in isolation.
- Meaningful privacy/security features: PIN-locked personal documents, auth-gated file serving, self-service password reset, and an optional whole-app PIN lock.
- Installable as a home-screen app (PWA) on iOS and Android, with in-app notifications for new results.
- Velocity: roughly 110 commits and dozens of shipped features between August 2–9, 2026 — about one week — and it's in daily production use by the actual family today.
Tools
- Claude (claude-sonnet-5, Anthropic API) — powers Kin's chat, medication explanations, cross-medication review, all photo/document vision reading, visit-note summarization, and translation.
- Claude Code — the AI coding agent used to design, build, debug, and deploy the entire application collaboratively.
- Deepgram (nova-2) — speech-to-text transcription for recorded visits, with built-in English/Spanish code-switching.
- Next.js 16 / React 19 — the web application framework.
- Prisma ORM + Neon (serverless Postgres) — the database layer.
- Vercel — hosting and CI/CD deployment from GitHub.
- GitHub — version control.
- Tailwind CSS — styling foundation, layered under a custom design system (Fraunces/IBM Plex typography, a defined color and flag-severity system).
Methodology
- Spec-first, but lightweight. A living product spec (problem, vision, "win condition," and a hard-coded AI safety line) was written before and alongside building — not a heavyweight upfront document, but enough shared understanding to keep every AI feature honest to the mission.
- Conversational, iterative build loop. Each feature or bug started as a plain-language description or a real screenshot/file from actual use, which Claude Code would investigate against the existing codebase, plan a fix consistent with established patterns, implement, build, and verify — often in a live browser preview — before shipping.
- Git-first delivery. Every logical change is its own commit with a clear rationale, pushed to GitHub and auto-deployed to Vercel, enabling same-day feature-to-production cycles.
- Debugging against real data, not synthetic tests. When something broke, it was diagnosed using the family's actual real-world files (e.g., an actual hospital discharge PDF) rather than a short made-up test case — which is precisely how a subtle AI output-truncation bug was caught: it only appeared on a long, real document, not a synthetic one.
- One enforced safety boundary for every AI call, rather than trusting individual prompts to each get it right — a deliberate, auditable guardrail for a health-adjacent product.
- A pragmatic single-environment setup. One database serves both development and production, trading strict environment separation for the speed appropriate to a small, fast-moving family project.
Learnings
- An AI coding agent can take a non-developer from idea to a real, deployed, multi-user production application — but the human still has to make every product and safety judgment call along the way (what the AI is and isn't allowed to say, what to build vs. deliberately not build).
- AI output limits can fail silently in ways that look like "the feature is broken" rather than "the model ran out of room" — this project's discharge-report summarizer worked fine in every quick test but silently truncated on a real, long hospital document, a class of bug that only shows up with real-world inputs.
- Slow AI calls need visible feedback. A multi-second AI medication cross-check with no loading indicator reads as "broken" to a real user even when it's working correctly — UX around AI latency matters as much as the AI logic itself.
- A single, explicit, hard-coded safety instruction is a stronger and more auditable guardrail for a health-adjacent AI feature than relying on each individual prompt to phrase things carefully.
- Tight feedback loops beat long planning cycles: real bug reports (an actual screenshot, an actual failing file) diagnosed and shipped the same day moved the project faster than upfront over-specification would have.
- Requirements like bilingual support and multi-timezone correctness are dramatically easier to get right when designed in from day one than retrofitted later.
Relevant URLs
- Live app: https://care-circle-one.vercel.app
- GitHub repository: available upon request if needed for review
