Kynd: AI-Powered User Testing with High-Fidelity Synthetic Personas
Creator & Lead Developer
•2026-06-18
Problem / Product Goal
When you are an early-stage founder, you need to validate your product ideas with real people before spending months building them. But finding, recruiting, and scheduling human testers takes forever, costs too much money, and scales horribly. If you run five user testing sessions, you walk away with exactly five data points. That completely falls apart when you need feedback on fifty different variations of a new pricing page.
The bigger issue is that human insight gets trapped in time. A researcher who just wrapped up twenty user interviews cannot sit down and accurately predict how those exact twenty people would react to five entirely new feature concepts. The data stays frozen in text transcripts. The product feedback loop represents the single most important cycle in any startup, yet it remains completely bottle-necked by human scheduling.
I built Kynd to break through that exact limitation. The goal was simple: spin up realistic, opinionated synthetic personas using minimal initial inputs, then drop them onto live websites to collect structured, behavioral feedback at scale.
Thought Process
I started by copying the Berkeley technique directly. I generated narrative backstories as extended interview transcripts and fed them into the system prompt. It definitely beat basic demographic targeting, but the personas still started losing their edge after three or four turns. They quickly drifted right back into behaving like a polite, agreeable AI assistant. They wouldn't push back on a high price tag the way a real, cash-strapped buyer actually does.
Because of that, I spent a solid month reading through every piece of literature I could find on inference-time guardrails, persona tracking, and psychometric evaluation. I pulled together a stack of separate research-backed techniques to see what would stick:
- Compartmentalized prompts (Wang 2024b): I split the core definition into four distinct sections (
<<PERSONA IDENTITY>>,<<PSYCHOGRAPHIC PROFILE>>,<<EPISTEMIC BOUNDARIES>>,<<BEHAVIORAL GUARDRAILS>>). This keeps the model focused on specific boundaries so it doesn't drop character. - PB&J scaffolds (Joshi 2025): Adding structured values and deep fears directly into the persona framework bumped character adherence by 6-9%, even though it required an extra LLM call to build the profile.
- Persona anchors (SyTTA, Atri 2026): Injecting short, 4-16 token identifier tags across every single turn cut character drift by nearly half. I found the best results came from a triple-injection method (putting them in the header, right before the chat history, and immediately ahead of the final generation block).
- ID-RAG (Tan 2025): This pulls pieces of the persona's backstory into active memory mid-turn to keep responses grounded in their fictional history.
I built all of these into the engine, but the real breakthrough came from a completely different direction.
Cracking the $r < 0.26$ Ceiling
I was working on a feature that let users upload raw customer interview transcripts to generate matching personas automatically. At first, I tried using zero-shot LLM prompts to pull Big Five personality scores straight from the text. Then I found a paper by Zhu et al. (2025) showing that this specific approach hits a hard ceiling, maxing out at a terrible $r < 0.26$ correlation with actual human personality metrics. You cannot reliably pull personality scores out of an interview transcript; it is a mathematical wall that prompt engineering cannot fix.
That data forced me to flip the entire pipeline on its head. I stopped trying to guess personality traits from the text. Instead, I wrote prompts to extract only directly observable data points (things like specific daily frustrations, explicit product goals, and exact verbatim quotes).
Once I had those concrete signals, I pooled them across every uploaded interview, ran a mathematical trigram-similarity deduplication step, and used that frequency layout to generate a brand-new personality that naturally matched the observed data. The architecture went from a naive extraction guess to a data-driven sampling pipeline. It entirely skips the $r < 0.26$ bottleneck because it never attempts to extract abstract traits from raw text in the first place.
Giving Up on Streaming
The second major shift happened inside the pricing analysis engine. I originally built it around a heavy streaming pipeline so you could watch each persona evaluate a page in real-time. It was incredibly brittle. Schema enforcement was weak, timeouts caused regular crashes, and Next.js HMR would occasionally wipe out our server-side stores mid-run. Every single live demo ended up dropping at least one persona.
I spent two weeks writing patches for the streaming code before admitting the core setup was simply wrong for this use case. I tore the whole thing out and replaced it with a completion-based setup. I forced strict Zod validation, added a 3-minute max timeout tied to an AbortController, hooked up globalThis to preserve active stores during code reloads, and wrote an explicit AnalysisLogger.
The system became a lot more boring, but it became completely stable. It is always better to make a user wait three minutes for a flawless, structured dataset than to hand them a broken UI in thirty seconds.
Solution
Kynd connects high-fidelity synthetic personas directly to automated browser environments to run hands-off user testing on live sites.
The Inference Stack
The core engine layers six independent techniques to keep the simulation accurate:
- Narrative backstories (Moon 2024) — Boosts human behavioral alignment by 14-18%.
- Compartmentalized prompts (Wang 2024b) — Four explicit zones lock down model focus.
- PB&J scaffolds (Joshi 2025) — Structured fears and values improve character retention.
- Persona anchors (SyTTA 2026) — Multi-place token injection stops assistant drift.
- ID-RAG (Tan 2025) — Contextual vector retrieval keeps responses factually grounded.
- InCharacter + PICon — Continuous background cross-examination to catch character contradictions.
Architecture
The system uses a strict Hexagonal Architecture layout where all dependencies point straight inward. The UI talks to Server Actions, which trigger Application use cases. These coordinate pure TypeScript entities in the Domain layer (which features zero external npm dependencies) before executing tasks through Infrastructure adapters.
Ten explicit port interfaces handle every single outside service connection. The key infrastructure adapters include PersonaPromptCompiler, IdRagStore for swift local lookups, VisionAnalysisAdapter (which utilizes Qwen VL to read web layouts visually), and RemotePlaywrightAdapter to handle live browser automation.
Key Features
- Persona Creation Pipeline: Processes raw text notes through a structured brainstorm, narrative generation, psychological scaffolding, and final vector indexing.
- Pricing Analysis Engine: A clean, two-part flow. Playwright goes out to scout the target URL, extracts the DOM layout, and then runs up to 5 personas in parallel using completion-based vision logic and Zod validation.
- Interview-to-Persona Pipeline: Extracts observable user issues, matches them using trigram-similarity pooling, samples from that frequency distribution, and spins up matching personas. It can transform 20 raw interviews into 40 distinct, ready-to-test personas in less than 60 seconds.
- Debate Room: Lets you throw a product feature proposal into a multi-persona chat room to watch different customer segments argue the pros and cons in a structured event loop.
Model Setup
The platform uses a tiered routing strategy to keep costs reasonable. DeepSeek V4 Flash handles the heavy text processing, fast data extraction, and general reasoning tasks. Qwen VL 30B A3B manages visual page evaluations, while Claude Sonnet 4 is reserved specifically for the browser agent's internal reasoning loop, where navigation execution demands absolute precision.
Takeaways
Hitting that $r < 0.26$ personality ceiling taught me to thoroughly review the literature before sitting down to write a line of code. I wasted an entire week building an extraction tool that academic papers had already proved was mathematically impossible. Now, I start every complex feature with a deep dive into recent research papers to see where the real engineering boundaries live.
I also learned that streaming is completely wrong for structured data evaluation. It works beautifully for a conversational chat window, but it is a nightmare for building validated, dashboard-ready datasets. Overhauling the architecture to use a completion layout was painful, but it was necessary. I should have prioritized system stability over chasing a flashy streaming UX.
System fidelity is about layering, not finding a single silver bullet. No individual prompt technique carries the weight of the system on its own. Compartmentalization, anchors, and RAG each add a minor improvement to the persona's accuracy, but the real value comes from how they operate together. If I had shipped the app using only the narrative backstory paper, the personas would have turned out completely mediocre.
On a minor note, the GitHub repository is still hosted at jeremykamber/deepbound to keep existing links alive. The product is named Kynd, and I really need to get around to updating the repo name, but it is tough to prioritize that over shipping active feature work.
If I could do the whole project over again, I would build the interview-to-persona pipeline on day one. The pricing analysis tool took up most of my early developer focus, but the pipeline is a much more interesting piece of software. It is the core feature that actually separates Kynd from typical persona generators.