Concepts

JTBD lives in three places: corpus, project profile, and score

Jobs-to-be-Done isn't a single lookup. In TheDesignAgent it shows up in three distinct places — and the evaluation only makes sense when all three are in play.

Jobs-to-be-Done is often described like a research method — interview users, find the job, design for it. That's fine as far as it goes. But in a system that evaluates agent-built UI on every build, JTBD has to be operational, not just a framing. It has to be something a pipeline can ask against.

In TheDesignAgent, JTBD appears in three distinct places. Understanding all three is what makes the jtbd_alignment score mean something instead of just saying "does this serve the user."

The corpus layer: generic job archetypes

The first place JTBD lives is the corpus — a body of domain-specific job patterns built from working examples across industries. Warehouse operations, inventory planning, financial review, SaaS operations, customer support queues. For each domain, the corpus holds: what the primary job archetypes are, what cognitive requirements those jobs carry, which UI patterns fit them, and which patterns consistently fail.

This layer is universal. It doesn't know your product. It knows that a planner reviewing reorder recommendations is doing a deciding job, not a monitoring job, and that deciding jobs need inline actions, not dashboards. It knows that warehouse fulfillment is sequential, not categorical, and that sequential jobs need progress rails, not tabs.

When an agent calls without any project context — on the very first call — the corpus is the only thing grounding the evaluation. It's still specific enough to be useful, because domain knowledge is real and transferable.

The project memory layer: your actual jobs

The second place JTBD lives is project memory — the profile built for your specific product from the first time an agent called with real context.

Discovery — the init call type — is when this gets built. The system infers the domain, creates a persona profile (working memory capacity, time pressure, expertise level, multitasking demands), and builds a job registry: every job the persona does, with priority, frequency, complexity, cognitive requirements, and success criteria. Critically, it captures day_shape — the sequence of jobs a user moves through across a workday, because most users don't have one job, they have several, and the layout needs to know which one is loaded.

From that point on, every evaluation is anchored to this profile. The active job on each call is matched against the job registry. The score reflects whether the artifact serves this persona doing this specific job — not whether it serves a generic user.

Why it matters: a score against generic JTBD tells you the artifact fits a category. A score against your project's job registry tells you whether it fits your users' actual day.

The rubric layer: the jtbd_alignment sub-score

The third place JTBD lives is the evaluation rubric itself — specifically the jtbd_alignment sub-score in the /ux lens.

jtbd_alignment asks a pointed question: does the layout's shape match the job's shape? A sequential job needs a sequential interface — the layout should mirror the workflow, not the data model. A deciding job needs inline decision units — the action should be on the record, not behind it. A monitoring job, one of the rare ones that actually calls for a dashboard, needs aggregates and trend lines up front.

The sub-score is what makes JTBD actionable in a patch. If jtbd_alignment is low, the patches name the mismatch: "layout is shaped like the data (tabs over state categories); job is sequential (pick → pack → ship → confirm); switch to progress rail." The agent gets a concrete structural change, not a note to think about user needs.

Why all three have to be in play

A score against only the corpus tells you if the general pattern fits the domain. Useful, but generic. A score against only the project memory without corpus knowledge misses the accumulated domain wisdom. A score that has both but can't express the mismatch in a structural patch is information without action.

The three layers braid: corpus knowledge sets the domain baseline, project memory makes it specific to your users, and the rubric translates both into a score the agent can act on. The first call is where the braid starts — which is why the init call matters more than any individual score that follows it.

We'll write more about what discovery actually captures and how to shape the init call to get the most specific profile in a future note.