joans.cat

Lab

The lab

Where my vision gets tested before it reaches the org. Everything here is built with my own hands, on nights and weekends, out of the conviction that a design leader's opinions about AI should come with receipts.

Persona Studio

Interrogable AI personas grounded in real UX research: around 60 archetype bots distilled from 200+ discovery interviews, each answering only from its own corpus, with provenance back to source interviews, a confess-ignorance contract, and an eval suite guarding the grounding. The subject of its own case study; the trust argument is the essay Synthetic users you can trust. Internal tool; shown here with synthetic data.

UX Research Skills

Open source. The qualitative research pipeline itself, packaged as AI skills anyone can run. Drop a project's interview transcripts in a folder and work through the whole method: empathy maps, journey maps, personas clustered on attitudes and behavior together, jobs-to-be-done analysis, design scenarios, and a scored AI opportunity assessment. Hours instead of weeks, on the methodology my researchers already practice, and runnable by non-coders in Claude Code or Copilot.

This is the practice-transformation belief made shareable: the same kinds of grounded artifacts that Persona Studio's dossiers are built from, offered to any research team that wants the leverage without giving up the rigor.

Interview transcripts 10 to 20 per project in parallel Empathy maps says · thinks · does · feels Journey maps phases · emotion · pain points attitudes behavior Personas 3 to 5 grounded clusters Jobs-to-be-done why users hire the product Design scenarios user stories · concepts AI opportunities scored and tiered, P1 to P4 Evidence-based roadmap hours instead of weeks
The pipeline, as codified in the repo's workflow guide: empathy maps and journeys run in parallel, personas require both, and every step hands structured, transcript-grounded artifacts to the next.

→ github.com/uh-joan/ux-research-skills · the essay: When the method becomes code

Cortellis CLI

Open source. The most advanced build in the lab: an AI-native intelligence workbench on top of the Cortellis pharma platform (community-built and unofficial; it needs your own subscription). Three layers. A CLI covering 13 data domains with 80+ commands. Above it, analytical skills (competitive landscape, company pipeline, drug and target profiles, conference briefings) that run through a deterministic harness: a DAG executor that sequences every step, hard-fails on any error, and returns the same output whether invoked from chat, the web UI, or the command line. No silent gaps, no improvised analysis. The skills work with Claude Code, Codex, Copilot CLI, or a local model.

The third layer is the reason it exists: every analysis compiles into a persistent wiki with a knowledge graph underneath, session insights accumulate automatically, and after each run a reviewer step encodes what it learned back into the skill itself. Knowledge that compounds instead of evaporating. It is my working argument for the beyond-chat belief in the vision: agents earn trust through deterministic workflows and inspectable provenance, not through a chat box improvising.

chat web UI terminal same output, any entry Skill harness deterministic DAG executor · hard-fails on error landscape · pipeline · drug and target profiles sequences the steps CLI: 80+ commands 13 data domains: drugs, trials, deals, regulatory, targets, ... every run compiles in Knowledge base: wiki + graph articles with provenance · session insights accumulate a reviewer encodes each run's patterns back into the skills injected into the next session
Three layers and the loop that makes them compound: every analysis lands in the knowledge base, and the knowledge base starts the next one. Determinism where it matters, memory everywhere else.

→ github.com/uh-joan/cortellis-cli · the essay: Knowledge that compounds

A second surface: WebMCP. The same intelligence, moved into the browser tab. A replica of the Cortellis experience on the Helix design system exposes 48 typed tools that a visitor's own agent can call, so the agent drives the real interface on a live session instead of guessing at pixels. The tools do the thing and show the thing: a question filters the grid, a threat radar builds, a substructure search runs across patent families, all in the open where the analyst can watch and take the wheel. It is the clearest build I have for the belief that an agent should meet a product through tools its makers designed, and its guardrails live in the tool schemas so a caveat cannot be dropped on the way to the answer. The write-up: The door where the designer gets in.

A workspace where humans and agents are teammates

I run a self-hosted collaboration relay (built on the open-source block/buzz project) where human colleagues and AI agents share the same rooms. Two agents live there today: a pharmaceutical-intelligence agent that answers drug, trial and regulatory questions with sources, and an independent fact-checker agent whose only job is to verify what the first one claims. Each has its own cryptographic identity, its own channel memberships, its own audit trail, and an evaluation harness scoring its answers.

This is my working answer to a question most organizations haven't asked yet: when agents join your team, what does accountability look like? Scoped identity, adversarial verification, and audit trails, not blind trust.

→ The essay: The org chart will have agents on it

Signal Studio

Ask the intelligence anything: a web app where Claude drives two MCP servers over voice-of-customer and win/loss data. Friction and feature requests in prose on one side; competitive rankings, renewals and pricing on the other, with every tool call visible in a live trace.

There's a long thread behind it. In 2022, my team's discovery research diagnosed exactly this problem: customer feedback fragmented across tools, departments and formats, with no way to see across it. Four years later I built the system that answers it. Internal tool; described, not demoed.

OpenPharma

Founder. An open-source organization of 50+ Model Context Protocol servers giving AI agents access to pharmaceutical and biomedical data: FDA and EMA regulatory sources, clinical trials, genomics and variants, proteomics, pathways, literature. The public half of the story told in Prototyping the strategy.

→ github.com/openpharma-org · the essay: An MCP wrapper is table stakes, not strategy

Morra

The 0→1 one. A browser game of morra, the Mediterranean finger-and-shout game, played against an AI corsair, in Catalan. The camera counts your fingers (computer vision), the microphone hears your call (speech recognition), and a throw only counts when hand and voice land together. The rival's move is cryptographically committed before you throw, so it can never peek. Built spike-first, validated with real players before the production port, shipped with its own telemetry.

Proof that craft, playfulness and rigor are the same muscle. Also the only project here where the users giggle.

→ github.com/uh-joan/morra-app · play at morra.joans.cat

More CLIs and models

The pattern across all of it: connect trustworthy data to AI agents, make the provenance inspectable, and design for the human who has to defend the answer.