LiquidRead

Academic papers are written for specialists, but most tools still assume every reader needs the same kind of explanation.

Existing tools help people search, summarize, or categorize research, but they do not adapt the reading experience to the reader's knowledge state.

That leaves beginners excluded and advanced readers underserved.

I began with exploratory interviews to check whether this was a real user problem and not just a personal frustration.

At this stage, the goal was not to test an interface, but to understand how people currently discover, read, and judge research.

This helped establish where the real gap was before committing to a solution direction.

The interviews showed that the biggest gap was not access to research, but lack of personalisation in how it was presented.

Visual explanation also came up repeatedly, with participants asking for diagrams and visual aids as part of the reading experience.

This shifted the concept from a better summary feed to a system that adapts depth, framing, and format to the reader.

The initial idea was a personalised research feed with summarisation, but that direction was too easy to commoditise.

The stronger opportunity was not personalising what people see, but personalising how the same paper is shown to them.

That became the core thesis behind LiquidRead.

LiquidRead is a web app that fetches real open-access papers and generates a reading experience based on a short calibration quiz.

The same paper can be presented at different depths, with different framing and visual support, depending on the reader.

The prototype combined paper retrieval, generative content, adaptive visual structure, and feedback capture in one flow.

A short calibration quiz estimated the reader's knowledge state and routed them to one of three reading depths.

The generated output changed not just in difficulty, but also in framing, section order, and visual emphasis.

The system recommended a depth rather than enforcing it, so users could still override the result.

Before building the full live system, I used a survey to test whether the routing idea worked at all.

This was the fastest way to validate whether people preferred a depth-matched explanation before investing in a fully dynamic prototype.

26 participants completed the survey.

The survey gave directional evidence that readers preferred explanations closer to their actual level.

It also revealed an important asymmetry: showing something too basic created a worse experience than showing something slightly too advanced.

That suggested the system should bias upward when calibration is uncertain.

Think-aloud testing with three participants showed that paper relevance had to work before depth personalisation could be judged properly.

In practice, the system was sometimes personalising the wrong paper well, which made user feedback hard to interpret.

This changed the next design priority from better calibration to better relevance matching.

The main lesson was that generative personalisation is not just a model problem, but a design problem about signals, trust, and feedback.

A system cannot adapt well if it does not first understand what the user cares about and what kind of explanation they actually need.

The most transferable part of the project was translating research findings into prompt behaviour in a structured way.

The next version should add a relevance gate before depth routing so the system first checks whether the paper is actually worth showing.

It should also separate topic mismatch from depth mismatch in the feedback loop, so recalibration becomes meaningful.

Over time, behavioural signals could support better session-to-session adaptation instead of relying only on the initial quiz.