Mari · Carol Munar

Problem

Teams don't struggle to have ideas. They struggle to agree on what to build first and who owns what, and they waste hours in planning sessions that could have been a document.

A PRD exists. The team is assembled. The roles are known. And yet the first 90 minutes of every sprint cycle are spent in a room negotiating priority and arguing over assignment. Nothing in that room requires the room.

Mari was built in 2 hours at a hackathon hosted by Kaan Calgar, supported by Cursor and Antler. A five-person team set out to show what AI-assisted planning could look like when it feels trustworthy and legible, not like a black-box chat.

The Brief

Design a guided workflow that turns a PRD and team context into a prioritized, assigned Kanban board, with clear approval steps along the way.

Solution

I owned the full UX and UI, from flow definition to final screens. I worked alongside the developer to shape what the AI agents would expose to the user at each step, and made the key decisions on how much control to give users versus how much to let the agents handle.

Key Decisions

The PRD is the starting point, not a form.

Most planning tools begin with an empty board or a template. We started with a document. The Context Input screen accepts a Notion link or a file upload, and the team panel sits right beside it, already populated with names, roles, and availability. The brief exists. The people exist. The tool's job is to connect them, not make you recreate everything from scratch.

Make the AI reasoning visible while it works.

During analysis, the agent doesn't just show a spinner. It narrates what it's doing: "Extracting goals, constraints, and scope. Keeping only what is supported by your input." This was a deliberate trust decision. An AI that hands you a finished plan with no trace of its logic is one you'll second-guess or override by default. Showing the agent's thinking in real time makes the output feel earned rather than arbitrary.

Assign by role and availability, not by name.

The Team Context panel shows who's active and who isn't. David Kim is on PTO and toggled off. The AI maps tasks to available team members based on their function (Frontend, Backend, Design), not to whoever's name you typed in. Assignment decisions made without availability context get renegotiated in Slack an hour later. Building availability into the input layer removes that loop entirely.

Under the Hood

Mari is not one chatbot. It is a pipeline of specialized AI steps, each with a narrow job, a fixed output shape, and guardrails so the UI always gets predictable data. The interface walks the user through four screens. Behind the scenes, three steps use Gemini and one step is pure logic (no AI).

Think orchestrated workflow, not "the AI figures everything out in one message." Each agent returns structured JSON the UI can trust. The user reviews context, then the matrix, then assignments, before the board appears. AI proposes. The human approves.

The Four Agents

1. Context

Reads the PRD from a Notion link, file upload, or notes and turns messy input into a structured project summary: goals, constraints, and team snapshot. The agent is grounded on the actual document content so it cannot invent requirements that are not there.

2. Analysis

Takes that summary and produces 8 to 15 tasks scored by effort and impact. Prioritization logic (quick wins, major projects) is enforced in code after the model responds, not left to the model to guess.

3. Assignment

Maps each task to an available team member by role, with a match percentage and a plain-language reason. Availability rules (for example, David on PTO) are enforced in code before anything reaches the UI.

4. Kanban

Deterministic only. No AI. It turns the assignment plan into a board with every card in To Do. In Progress, Review, and Done stay empty. Sprint has not started yet, and the board reflects that.

Why This Matters for Design

Specialization over one mega-prompt.

Each step has a small scope, which means clearer screens and easier debugging when something goes wrong.

Structured outputs.

Zod schemas act as a contract between the AI and the UI components. The matrix, table, and Kanban always get the fields they expect.

Human-in-the-loop.

The user reviews context, matrix, and assignments before the board appears. AI proposes. The user approves.

Guardrails outside the model.

Availability, quadrant math, and board state are code rules, not model decisions. Behavior stays consistent even when the model drifts.

Three Gemini calls. One logic step. React and Zustand on the frontend, Hono API on Vercel, Vercel AI SDK with schema-constrained outputs.

Learnings

Transparency builds trust faster than a polished result.

Showing the AI's reasoning step by step made the output feel earned. A finished plan with no visible logic is one users will override by instinct, even when the plan is correct.

Start with what already exists.

The brief exists. The team is assembled. The roles are known. Great planning tools don't ask you to rebuild the context. They read it and move forward.

Availability is a design input, not an afterthought.

Building availability into the input layer removed the renegotiation loop that normally happens in Slack an hour after planning ends. Context that lives outside the tool always gets lost.

Four-Agent AI Planning Pipeline (Hackathon Prototype)

Problem

Solution

Under the Hood

Learnings