Personal Pattern Lab

Turn a messy daily reflection into an editable observation, an evidence-backed personal pattern, and one small experiment—without complex tracking or causal claims.

Comment

Devpost Project Story

Copy only the story between the horizontal rules into Devpost's About the project field.

Inspiration

Most personal trackers ask people to structure every day, maintain a streak, and interpret a dashboard later. That is a lot of work for someone who is already tired or busy. I wanted to start with something people naturally do: describe a messy day in one or two sentences.

The question behind Personal Pattern Lab became: can AI help turn a reflection into one small, evidence-backed decision without pretending to know more than the data shows?

That led to the product's core rule: evidence before advice. The AI can help interpret language, but the user must be able to inspect, edit, and approve that interpretation. Patterns must show their supporting records. Experiments must be optional. Results must remain descriptive rather than causal or medical.

What it does

Personal Pattern Lab turns a short natural-language check-in into an editable observation, an inspectable possible pattern, and one bounded experiment to try.

The judge flow follows a synthetic persona named Raka:

  1. Raka writes a reflection and rates afternoon energy.
  2. The app extracts a draft observation, shows the exact source text, and allows editing or removal.
  3. Nothing is persisted until the observation is explicitly confirmed.
  4. The app compares confirmed lunch-status and energy records, including counts, averages, missing values, and all supporting check-ins.
  5. It proposes a three-day lunch-break experiment and discloses the synthetic readings before asking for consent.
  6. The Result screen compares the baseline and experiment averages while clearly stating what the numbers cannot prove.

The experience is intentionally not a medical tool and does not claim that correlation is causation.

How I built it

The application uses TypeScript end to end with Next.js, React, and same-origin server routes. Zod validates client, API, domain, and model boundaries. The configured persistence path uses Supabase PostgreSQL with row-level security, ownership-checked RPCs, idempotent mutations, deletion support, and distributed rate limiting.

The browser never receives OpenAI or Supabase server credentials. Each judge browser receives a signed isolated synthetic workspace, and Start over resets only that workspace. The credential-free test path uses process-local synthetic persistence so judges can run the complete product without an account or API key.

The AI boundary integrates the OpenAI Responses API with the exact gpt-5.6 model, strict Structured Outputs, store: false, refusal handling, a pseudonymous safety identifier, bounded timeouts, and post-validation of evidence offsets. A model response remains an unpersisted draft; deterministic application code owns authorization, evidence thresholds, arithmetic, consent, state transitions, and outcomes.

When a live provider is unavailable, the app uses a narrow deterministic fallback that is visibly labeled “Deterministic fallback — not GPT output.” The recorded demo uses this repeatable fallback and does not misrepresent it as a live GPT response.

How I used Codex and GPT-5.6

I used Codex as a Manager-led delivery team with Product Manager, Frontend, Backend, AI, and QA roles. Work was divided into bounded units with explicit acceptance criteria and non-overlapping ownership. Each role returned evidence and a handoff.

A repository-local second brain tracked product decisions, architecture, risks, current status, append-only session events, and role handoffs. Historical notes were treated as context, while current code, tests, and runtime evidence remained the source of truth.

Codex accelerated product framing, architecture contracts, UI implementation, server APIs, SQL and RLS design, the GPT-5.6 structured-output adapter, synthetic evaluations, accessibility repairs, Docker and CI/CD packaging, security hardening, Playwright automation, and submission preparation. I retained the key product decisions: the narrow audience, non-medical boundary, single hero pattern, explicit consent, synthetic demo isolation, and transparent fallback.

Challenges I faced

The hardest challenge was avoiding a generic “tracker plus charts plus AI advice” product. The product became more useful only after the flow changed from recording history to making one reversible decision:

Reflection → Review → Insight + Experiment → Result

Trust was another challenge. Model output had to remain editable, evidence offsets had to match the user's text, and the app needed to distinguish possible association from causal proof. I also had to keep the synthetic demo isolated between browsers, make retries idempotent, and prevent AI drafts from saving themselves.

Finally, release QA found issues that a happy-path recording missed, including stale test expectations, accessibility contrast and focus problems, and a development indicator inside an early video export. Each issue was fixed and retested instead of being hidden.

What I learned

I learned that AI is most valuable here as a constrained interpretation layer, not as the owner of truth or product state. The strongest system combines flexible language understanding with deterministic authorization, evidence, calculation, and consent boundaries.

I also learned that multi-agent development needs a small amount of durable structure. Clear ownership, acceptance criteria, handoffs, and a validated second brain made the work faster without allowing old notes to overrule the actual application.

The final provider-free gate passed 31 unit tests, 23 deterministic AI assertions, and 27 Playwright API, E2E, and accessibility tests with zero skips, plus a successful production build and dependency audit.

What's next

Next steps are a hosted synthetic judge deployment, authenticated personal workspaces, product-level deletion, repeated official GPT-5.6 reliability and cost evaluation, and longer-term experiments across additional user-chosen routines. Real personal-data production remains intentionally out of scope until those privacy and operations gates are proven.

Built With Tags

Add these tags in Devpost:

  1. TypeScript
  2. Next.js
  3. React
  4. Node.js
  5. OpenAI API
  6. GPT-5.6
  7. Codex
  8. Zod
  9. Supabase
  10. PostgreSQL
  11. Playwright
  12. Vitest
  13. axe-core
  14. Docker
  15. GitHub Actions
  16. Tailwind CSS
  17. FFmpeg

Try It Out Links

  • Source code and credential-free test build: https://github.com/DifanaDAP/hackanton
  • Add the hosted demo URL only after a deployed-URL smoke passes.
  • Add the YouTube URL in the dedicated Video demo link field after upload.

Gallery Upload Order and Captions

Upload the four files from submission-artifacts/devpost-gallery/ in this order:

  1. 01-landing.jpg — From reflection to one small experiment
  2. 02-review.jpg — Review and edit what the app understood before persistence
  3. 03-insight-evidence.jpg — Inspect the records behind a possible pattern
  4. 04-result.jpg — Compare a descriptive baseline and experiment result without causal claims

Built With

Share this project:

Updates