Flow Compass

• 

• 

• 

• 

• 

Inspiration

Flow Compass began when productivity itself became part of the problem.

I was carrying too many responsibilities, ambitious goals, and opportunities that all looked valuable. I did not want to miss the right opportunity, make the wrong decision, or choose a path I would regret later. Because the future was impossible to predict, the safest response seemed to be doing more: learning more, planning more carefully, and trying to keep every option alive.

It worked until it did not.

The tools I knew could tell me what I should do and how to organize it. They could not tell me which opportunity deserved my energy now. Instead of creating confidence, they gave me more things to manage. The same pattern appeared in conversations with clients. People were rarely missing another task list. They were struggling with a more human question: “With everything that matters, what should I give my energy to next?”

Human Design had given me a useful language for noticing how different people experience energy, pressure, and decisions. But a static chart was not enough. Real decisions happen in context. A strong response can exist alongside limited capacity. Uncomfortable work may be genuinely misaligned, or it may simply be difficult, unfamiliar, or necessary for cash flow. “Follow your energy” without examining reality can become another form of avoidance.

That tension became Flow Compass: not an oracle and not another task manager, but a calm companion that helps someone move from pressure to one honest next step.

What it does

Flow Compass is an AI decision-reflection companion for people whose minds are busy with work, business, and life-direction decisions. It is designed to turn a tangled situation into one reality-aware next move in about three minutes without taking the decision away from the user.

The live experience follows a short path:

1. Choose a topic — Work, business, life direction, relationships, or something else gives the user a starting point instead of a blank page.
2. Describe the situation — The user writes what they are deciding, what makes it difficult, and any immediate constraint.
3. Answer one or two focused questions — Flow Compass asks only what it needs to separate the choice from pressure, expectations, fear, fatigue, and practical limits.
4. Leave with one next step — The result includes a manageable action, a boundary, what to set aside for now, what to notice, and when to review.

Users can optionally add Human Design profile information. That information is used only to select more relevant questions; it is never used to predict the future or tell someone what they must do.

Behind the interface, each session examines four things: the user's present response, outside or internal pressure, real-world constraints, and available capacity. The system can choose among six internal routes: move now, test something small, change the way, use a temporary bridge, pause for clarity, or recommend deeper human support. Those internal labels stay out of the conversation so the user sees familiar language rather than framework jargon.

After the conversation, the user receives a structured Next-Step Plan. Signed-in private-beta users can save it, return to their history, and add a reflection later. They can also correct the interpretation once or request one revision without turning the process into an endless chat.

The public read-only demo shows the complete path without starting an AI call or saving any data: https://flow-compass.flow-compass.workers.dev/demo

How I built it

I first converted an intuitive coaching process into explicit, testable layers:

• a product constitution and non-negotiable guardrails;
• a signature question method;
• optional Human Design question rules;
• six decision-path selection rules;
• safety and escalation rules;
• plain-language policies for Thai and English;
• a strict schema for every conversation turn and final plan.

The application is built with Next.js 16, React 19, and TypeScript. It uses the OpenAI Responses API with gpt-5.6-terra, medium reasoning effort, and Zod-backed Structured Outputs. Every model response must match the application schema and pass additional checks for question count, agency, plain wording, and required plan fields. If a response fails, the server gives the model one constrained repair attempt instead of showing an unverified result.

OpenAI requests use store: false. The browser never receives the API key, and conversation counters are carried in signed server-verified session tokens. The API also enforces payload limits, a question budget, one interpretation correction, one plan revision, private-beta access, and basic rate limiting.

Supabase provides authentication and Postgres persistence for profiles, sessions, plans, history, and reflections. The application runs on Cloudflare Workers through OpenNext. The knowledge base is intentionally small, curated, and rule-oriented, so I used versioned JSON rules instead of a vector database. That makes the system easier to inspect, test, and change during the MVP.

I also built a 16-case synthetic regression suite, all six decision routes, prompt-injection attempts, high-stakes scenarios, and the two-question limit. The final release run passed 16/16 cases for path selection, schema validity, question budget, plain-language checks, and guardrails. This is a useful release signal, not proof that every real conversation will be safe or helpful.

How I used Codex and GPT-5.6

I used Codex throughout Build Week as a development collaborator, not only as a code generator. It helped me turn the coaching concept into a product specification, separate the knowledge rules from the application, challenge ambiguous requirements, implement the Next.js and Supabase flows, create tests and evaluations, diagnose Cloudflare deployment issues, and inspect the real mobile experience.

The most important Codex work happened after user feedback. Every early tester could reach a useful result, but every tester was initially unsure what to do first. I worked with Codex to trace the first-use path, compare the live mobile screens, and rebuild the onboarding around topic starters, clearer progress language, fresh decision sessions, and a read-only walkthrough that shows the whole process rather than only a polished answer.

GPT-5.6 Terra is also part of the product itself. It handles the short adaptive conversation and produces the structured decision envelope. The application, not the model, owns the limits and validates the output. This division lets GPT-5.6 interpret nuanced context while deterministic code protects the shape, question budget, and user-agency rules.

Challenges I ran into

The hardest challenge was not generating advice. It was preventing advice from becoming authority.

Human Design can easily be presented as certainty: “Your type means you should do this.” That would make the product simpler, but it would undermine the user's agency and create claims the system cannot responsibly support. I redesigned it as an optional hypothesis and source of questions, never as a conclusion.

Another challenge was separating experiences that can feel similar:

• genuine resistance versus ordinary reluctance;
• misalignment versus fatigue from previous overwork;
• a wrong goal versus a difficult but necessary skill gap;
• a strong yes versus excitement amplified by fear of missing out;
• an attractive opportunity versus a commitment beyond current capacity.

Reality created another important constraint. A user may need to accept work they do not want because cash flow is urgent. A system that simply says “honor your no” can become financially irresponsible. Flow Compass therefore has a temporary-bridge route with an explicit scope, limit, and exit condition.

The three-minute promise forced equally difficult product choices. A meaningful decision can become an endless coaching conversation. I limited the system to two focused questions, a bounded result, and a clear handoff when the situation needs deeper support.

Finally, the first mobile test exposed a product-design problem rather than a model problem: users did not know how to start. The original demo showed answers, not the journey. Fixing that meant redesigning the experience before asking the model to do more.

Accomplishments I am proud of

Flow Compass now works end to end as a deployed private beta rather than a concept or technical proof of concept.

• A user can sign in, start a fresh decision, choose a topic, complete the short AI conversation, receive a structured plan, save it, revisit history, and add a reflection.
• The optional profile influences questions without exposing framework labels or making deterministic claims.
• The decision engine has six routes that can respect both internal response and practical reality.
• The production app is deployed on Cloudflare Workers and connected to Supabase and the OpenAI Responses API.

I am especially proud of the Next-Step Plan. Most AI conversations disappear into a transcript. This result creates a compact agreement with the user: one next move, one useful limit, one observation, and one review point. It makes the conversation testable in real life.

What I learned from users

I tested the early product informally with about seven people, mostly working adults dealing with work, business, or life-direction questions. Nearly everyone who reported back said the process helped them feel clearer, and roughly half told me they had taken the suggested next step. Because the sample is small and follow-up was informal, I treat this as a directional signal rather than a validated outcome metric.

The most consistent negative feedback was not about the final plan. It was about beginning. Every early tester was unsure what to do first and needed a video or direct explanation. That led to the largest product change so far: show the process before asking for input, provide topic starters, keep questions to one or two, and make the final plan easy to scan.

I also learned that some users want AI to tell them exactly what to do. Flow Compass deliberately resists that request. Its job is not to solve an entire life problem or create dependence on a long conversation. Its job is to help someone see the choice, respect reality, and leave with a small action that produces real evidence.

What's next

The next product step is to measure the loop more rigorously: whether a user starts without help, completes within three minutes, understands the plan, takes the next step, keeps the boundary, and returns with useful evidence.

The roadmap includes voice input for people who find speaking easier than writing, export to image/PDF/text, review reminders, a dashboard of active decisions, and a quick “leaning in or not?” response after each plan. These are roadmap items, not claims about the current build.

The longer-term vision is not an AI that knows the user's future. It is a system that helps people build self-trust through repeated, reality-tested decisions, one honest next move at a time.

Built With

• cloudflare-workers
• codex
• gpt-5.6-terra
• next.js
• openai-responses-api
• opennext
• postgresql
• react
• structured-outputs
• supabase
• typescript
• zod