HumanCore Advisor

Context

Human coaches cannot sit with every manager. HumanCore needed a product that could run a coaching session with shared context, then turn model output into something a manager could act on — not a chat transcript.

My ownership

• Frontend architecture and technical delivery for the 0→1 Next.js (App Router) core.
• Real-time shared context so a session stayed in sync across clients.
• Coaching UI: structured, actionable surfaces on top of OpenAI and Anthropic output.
• Owned end-to-end feature delivery across the Next.js UI, AdonisJS APIs and MongoDB/Redis persistence when product requirements crossed the frontend boundary.
• Internal developer tooling on the same stack: the PR reviewer and the planning assistant.

Constraints

• Coaching data is sensitive. Context had to be assembled deliberately, not dumped into a prompt.
• Cost and latency are part of the session. Routing is by task complexity, latency and cost.
• The UI renders structured actions. It is not a chat transcript wrapped in a panel.

Architecture

Browser  — Next.js App Router, React, TypeScript
        ↳ real-time shared session context
        ↳ structured coaching UI (Zod-validated model output)
AdonisJS — API when the feature leaves the client
        ↳ MongoDB persistence
        ↳ Redis for session / cache
Model router — task complexity, latency and cost
               lower-cost models for routine workloads
               higher-capability models for complex flows
               OpenAI | Anthropic

Technical decisions

• Next.js App Router as the product core so server and client work could live in one system.
• Structured outputs over free-form chat: the UI renders actions, not paragraphs the user has to parse.
• Cross the frontend boundary when the feature needs persistence or fan-out — AdonisJS + MongoDB + Redis — instead of pretending the browser is the system.

AI architecture

• Model routing by task complexity, latency and cost: lower-cost models for routine workloads, higher-capability models for complex flows.
• Context construction from the live session, not a generic system prompt.
• Structured output into the coaching UI.
• Fallbacks when a provider or a parse fails.
• The coach keeps the decision. The model returns a structured proposal to the UI.

Reliability

• Coaching output is validated with Zod before the UI renders it.
• A provider error or a failed parse uses the fallback path.
• Model choice is the router: task complexity, latency, and cost.

Decision

The UI is a pnpm and Turborepo monorepo: a Next.js App Router app, an AdonisJS API, and a shared @humancore/api client. Routes are split into authenticated and public groups. Server actions follow the API. Shared UI is grouped into data-display, data-entry, feedback, and layout, with Storybook, Radix, and Conform plus Zod on forms.

• A chat transcript would have been the faster screen. I did not ship that. Coaching and insight data go through data-display components, because a manager has to act on the result, not read a thread.
• I designed that UI architecture and the interface from scratch, with product in the room on what each screen had to show.

Tradeoffs

I did not train or host a private model. The leverage was product architecture, routing, and UI. Planning and review stayed internal tools, so they could fail without a customer watching.

A failure

A database change broke the API test suite. The suite was running again in about 30 minutes after an AI-assisted pass. Weeks is the team's estimate of doing that same repair by hand, not a timed baseline.

Impact

The product core and the UI system are live at humancore.ai. Time to approval — from pull request open to approval — was about 60% shorter than when every change waited for a fully manual first review. The team compared those two workflows. The figure is not a measure of whether each comment was correct.

• Architecture and the interface designed from scratch
• About 60% shorter time to approval versus the fully manual queue, from the team's comparison of the two workflows
• Test suite running again in about 30 minutes. Weeks is the estimated manual effort, not an observed duration
• Internal talks, and hands-on help so other engineers could use AI in their own work
• I also reviewed the visual result of PRs, not only the diff

What I learned

• Routing and structured output changed the product more than prompt edits.
• Persistence lives in AdonisJS, MongoDB and Redis. The client does not own it.
• The reviewer and the planning assistant shipped as internal tools on the same stack.