Nice2

Nice2

One you. Many lives.

Inspiration

I have never had just one life competing for my time. I am a founder, marketer, nonprofit operator, novelist, creator, singer, product builder, and daughter. Traditional productivity tools treat those as separate projects. But real decisions do not happen separately: a deadline can affect family, creative identity, energy, long-term goals, and the kind of person I am trying to become.

I first thought this was a time-management problem. Then I realized that dropping a meaningful project can feel less like deleting a task and more like silencing a person I have not finished becoming.

That became the question behind Nice2:

Can one governed model of a person understand many meaningful life threads, make one integrated judgment, and delegate only the work that does not require the human being?

Build Week provenance

Nice2 and its Alina Console governance control plane were both conceived on July 15, 2026, after the OpenAI Build Week submission period had opened. All ideation, naming, interviews, product architecture, identity-governance design, interface design, implementation, testing, privacy review, public-repository preparation, deployment, and submission work for both Nice2 and Alina Console happened during OpenAI Build Week. There was no pre-existing Nice2 product, Alina Console product, or Nice2/Alina Console codebase before July 15.

Nice2 itself—including the Identity Root and Life Threads model, Residence client, integrated decision flow, bounded delegation, Reality Feedback Loop, evidence governance, Alina Console review and audit workflows, public repository, and deployed demo—was created during the hackathon. References below to inspecting or refactoring an existing architecture refer only to earlier Nice2 and Alina Console iterations created during the same Build Week, not to any pre-hackathon project.

What it does

Nice2 is a browser-based digital-self client for moments when several parts of one life compete for attention at once.

It is built around five ideas:

One Identity Root — one person remains the source of final judgment. Many Life Threads — work, family, creativity, learning, and other meaningful areas stay visible without becoming separate personalities. One Integrated Deliberation — Nice2 produces one coherent recommendation instead of letting role-based agents vote. Many Bounded Executors — research, organization, QA, drafts, and continuity work can be prepared without giving the system open-ended authority. One Reality Feedback Loop — outcomes return as evidence, not as silent identity updates.

The public client is organized as a residence:

Living Room / Home surfaces the next move that needs the person. Study / Decide lets the user change conditions, compare an integrated judgment, and commit a plan. Workshop / Delegate prepares bounded work through a clearly labeled deterministic replay. Journal Room / Reflect records what happened, what changed, and what was surprising. Mirror Room / Self shows the identity baseline and a 25-part dossier. Library / Evidence exposes the evidence, counterevidence, and limits behind a claim. Governance Console demonstrates Source → Evidence → Candidate → Human Review → Confirmed Record → Snapshot → Audit.

How it works

A user begins with a real conflict, such as a product deadline, family time, and a creative project all competing for the same evening.

Nice2 combines the selected project, time, energy, deadline pressure, family availability, and a hard constraint into a deterministic, prevalidated decision path. It then separates the result into:

YOU — final judgment, relationships, presence, and consequences that remain human-only; NICE2 — bounded preparation the digital self may continue; KEEP WARM — a minimal continuity action for a meaningful thread that should not disappear; NOT NOW — work that is intentionally deferred.

A committed plan updates the shared client state. A bounded task moves into the Workshop, produces a structured artifact for review, and can be sent into the Reality Loop. A recorded outcome becomes browser-local evidence. If the user chooses, it can support a provisional Candidate. That Candidate enters the identity model only after explicit human review.

Nothing in the public demo publishes, represents the user, performs an outside action, or rewrites identity automatically.

How I built it

I built Nice2 with ChatGPT, GPT-5.6, and Codex.

I used long live conversations in ChatGPT to create a baseline from real choices, mistakes, work, family, ambition, and contradictions. The original conversation and later corrections remain separate so the system does not quietly rewrite the past.

GPT-5.6 supported the reasoning-intensive parts of the project: structuring the baseline into a 25-part identity dossier, examining evidence and counterevidence, distinguishing interpretation from fact, translating product decisions into state transitions, and checking the consistency of the evidence and approval chain.

Codex was the repository-level engineering environment. It helped inspect and refactor earlier Nice2 and Alina Console iterations created during the same Build Week, implement the React and TypeScript client, connect the shared browser-local state, build deterministic Scenario and Studio workflows, add migration and recovery, create tests, run responsive and accessibility QA, scan the public export for privacy issues, and deploy the final verified build to Vercel.

The public demo uses React 19, TypeScript, Vite, a versioned localStorage state store, deterministic fixtures and replay, Node tests, and Vercel static deployment with SPA route rewrites.

Challenges

The hardest challenge was not generating another AI answer. It was preserving the difference between:

understanding and authority; evidence and interpretation; simulation and identity change; preparation and representation; one person and many active life threads.

Another major challenge was making a deep governance architecture feel like a consumer product rather than an admin dashboard. The Residence interface, action-first navigation, progressive disclosure, bounded artifacts, and browser-local reset flow were designed to make those boundaries understandable without hiding them.

The final challenge was making the demo reproducible and safe. The public client intentionally has no public backend, model key, private founder data, OpenClaw connection, or external-action authority. Judges can reproduce every state transition without an account or paid API call.

Accomplishments

I am proud that Nice2 is now a working, stateful client rather than a static concept page.

The final build includes:

a single shared state across Home, Decide, Delegate, Reflect, Evidence, and Console; four deterministic decision paths with meaningful condition changes; structured bounded-work artifacts; a 25-part dossier with evidence, counterevidence, alternatives, and falsification conditions; browser-local Outcome → Evidence → Candidate → Confirmed Record lineage; human review, versioning, Snapshot changes, Audit history, Undo, Reset, migration, and corrupted-state recovery; direct links and refresh-safe routes; responsive desktop and mobile layouts; 45 deterministic tests; a sanitized public repository and stable Production deployment.

What I learned

I learned that a useful digital self cannot be built from personality adjectives alone. It needs provenance, uncertainty, contradictions, boundaries, and a way for reality to correct the model.

I also learned that delegation is not one permission. Understanding, drafting, speaking, acting, disclosing, and changing identity state need different levels of authority.

Most importantly, I learned that the interface itself must make an integrated judgment. A product for people with many competing lives should not give them another wall of equally urgent choices. It should surface the one thing that needs them now, show what can continue without them, and keep everything else visible without making it loud.

What's next

The current public release is a safe, browser-local demonstration of the product model. The next steps are durable per-user identity stores, authenticated accounts, encrypted source storage, real approval queues, optional integrations, and governed executors that can operate only within explicit task-level permissions.

The long-term goal is not to replace the person. It is to help one person understand themselves, rehearse possible paths, preserve meaningful continuity, and extend what one human body has enough time to do—without surrendering control of who they are.

Try it

Live product: https://nice2-public-judge-demo-bonaviaedu-bona-via-edu.vercel.app/

Code: https://github.com/BonaViaEdu/nice2-build-week

No account or credentials are required. The Workshop is explicitly labeled as a deterministic replay, and the entire public demo can be reset from the Founder Demo information panel.

Built With

• chatgpt-live
• codex
• deterministic-fixtures-and-replay
• gpt-5.6
• localstorage
• lucide-react
• node.js
• npm
• react-19
• typescript
• vercel
• vite