Inspiration
Aura began with a moment I never saw coming.
Nearly a decade ago, a complete stranger assaulted me without warning. I was blindsided. The encounter was over in moments, but it left me with a sharp pain behind my right shoulder blade that has never gone away.
Since then, I have seen doctors, described the pain as carefully as I could, gone through scans, and waited for someone to explain what happened to my body.
The pattern was usually the same:
- A few minutes of conversation
- Another test
- No clear answer
- A prescription intended to dull the pain
But I was not looking for stronger painkillers.
I was looking for someone—or something—to help me finally solve the problem instead of trying to drown it away.
I was looking to fix it.
The pain feels physical and mechanical. Something changes when I move. Something is happening inside my body.
Yet every unsuccessful appointment leaves me responsible for starting the story again—trying to remember which details might matter and finding the right words before the clock runs out.
This is not because doctors do not care. It is because even caring professionals work inside a machine shaped by limited time, fragmented information, and an overwhelming number of possible explanations.
A system full of good people can still produce an experience that feels like a prescription bot:
Describe the pain, rule out the obvious emergency, dull the symptom, and move on.
That realization became Aura.
What if a patient could begin the investigation before entering the examination room?
What if software could patiently track the possibilities, remember every answer, and keep choosing the question most likely to reveal something useful?
What if technology handled the catalogue work so clinicians had more time for the human work?
Aura is the tool I wish I had after that assault: a visual, adaptive medical self-diagnostic tool that does not pretend to know everything—but refuses to stop thinking after the first answer.
What It Does
Aura begins with the most natural question in pain care:
Where does it hurt?
The user adds a small amount of context, then points directly to the painful area on an interactive anatomical map.
Aura uses that location and pain geometry to open a focused candidate graph for that specific presentation.
Then the algorithm takes over.
Aura starts with the pain generators that could plausibly fit. It considers factors such as:
- Location
- Age
- Sex
- Onset
- Movement
- Radiation
- Associated symptoms
It then chooses the next question based on one goal:
Which answer would separate the remaining candidates most effectively?
Every response changes the picture.
Some candidates become better supported.
Some conflict with the new evidence.
Some remain possible but unresolved.
The next question changes accordingly.
Aura repeats this loop—
Ask. Learn. Rerank. Separate.
—to narrow the candidate pool as efficiently as the available evidence allows.
Inspired by Akinator
The candidate pool—and the process Aura uses to narrow it down—was directly inspired by Akinator, the famous genie that guesses which character you are thinking about.
I have always been fascinated by how Akinator works. It is such a simple, elegant system, yet the way it consistently figures out who you are thinking of still feels almost like magic.
Humans are actually pretty terrible at this kind of guessing game.
Keeping a mental record of every celebrity, fictional character, historical figure—or even every possible medical condition—would be impossible.
But for machines, that kind of vast, structured recall is exactly what they were built for.
They do not get overwhelmed, forget a clue, or lose track of thousands of possibilities. They narrow the field relentlessly.
That is why tasks that feel almost supernatural to us are often where AI excels far beyond human capability.
That is the idea at the heart of Aura.
But Aura is not playing a guessing game with fictional characters. It is applying the same elegant process of elimination to something deeply personal: understanding what may be causing your pain.
Aura begins with a broad but relevant candidate pool. Location, age, sex, pain geometry, and how common each pattern is help establish the starting order. From there, every answer becomes evidence.
The clever part is deciding what to ask next.
Aura does not follow a fixed questionnaire. It examines the candidates still in play, identifies where they disagree, and selects the question most capable of dividing them.
A great question can dramatically shrink the search space. Then Aura studies the candidates that remain and does it again.
Ask. Learn. Rerank. Separate. Repeat.
It is the same principle that makes Akinator feel magical, transformed into a structured investigation of pain.
Imagine beginning with dozens of plausible explanations. One answer weakens half of them. The next distinguishes the leader from its closest rival. Another reveals that the apparent leader no longer fits, causing a different candidate to rise.
The conversation evolves because the reasoning evolves.
That is why Aura can feel uncannily attentive. It remembers every clue, keeps every relevant alternative in view, and never becomes mentally exhausted. It can perform the repetitive catalogue work that is extraordinarily difficult for a human to sustain while also listening, documenting, and caring for the person in front of them.
And unlike a black-box chatbot, Aura can show its work.
The Insight screen reveals the strongest supported pattern, the meaningful alternatives, and the evidence that shaped the result. If an answer changes, the candidate ranking changes with it. The explanation is not invented after the fact—it is produced from the same evidence trail that powered the assessment.
Aura then turns that investigation into a Care Card: a structured summary of the pain location, relevant context, important responses, strongest pattern, and care timeframe.
The user leaves with more than a guess. They leave with a clearer understanding of their pain and a far better way to communicate it.
Aura turns “something hurts” into a structured, traceable story.
How I built it
I did not want to build another medical chatbot that accepts a paragraph, generates a convincing answer, and hides everything that happened in between.
I wanted to build the reasoning itself.
Aura is built with Next.js 16, React 19, TypeScript, and Zod. Its visual experience, adaptive questioning engine, candidate graphs, evidence model, Insight, and Care Card form one connected system.
Each supported pain presentation has its own versioned graph containing:
- Plausible pain generators
- Stable clinical questions
- Possible responses
- Evidence produced by each response
- Candidate-specific supporting and conflicting features
- Rules for selecting the next useful question
- The most specific explanation the available evidence can support
When an assessment begins, Aura retrieves the graph associated with the selected anatomy. It creates the initial candidate pool, applies the available context, and begins searching for the most informative gaps between candidates.
The question engine does not simply ask what is unanswered. It asks what is worth answering.
That distinction is essential.
If several candidates would respond identically to a question, asking it provides little narrowing value. But if the candidates strongly disagree, that question may transform the entire ranking.
Each answer updates every live candidate. Aura keeps track of supporting evidence, conflicting evidence, and information that remains unknown. It then recomputes the candidate order and chooses the next question from the new state of the assessment.
The result is a compact feedback loop:
Pain geometry → candidate retrieval → evidence → ranking → separation → explanation
I designed the system so the reasoning remains inspectable. Missing information stays unknown. “Unsure” does not quietly become “no.” Revising an answer recomputes the candidate state rather than stacking contradictory assumptions together.
This attention to state is what allows Aura to be both intelligent and explainable.
Assessment data remains in browser memory, with no account or personal health-history database required. The Care Card is generated locally using Canvas.
I used Codex as my engineering collaborator throughout the solo build: exploring the product architecture, implementing the experience, reviewing the reasoning path, finding defects, creating challenge cases, running end-to-end browser tests, and building the demo pipeline.
I also designed a bounded GPT-5.6 server-side assistant that can help interpret a user’s natural language, choose from questions already approved by the active graph, or explain a supported result more conversationally.
The generative model enhances the conversation. The structured engine preserves the reasoning.
That combination gives Aura something far more interesting than a chatbot:
A deterministic diagnostic core with an intelligent, human-facing layer around it.
Challenges I ran into
The greatest challenge was turning medical deduction into software without flattening it into a checklist.
Pain does not arrive as clean data. People hesitate, revise themselves, describe sensations differently, and sometimes simply do not know. The system had to preserve those distinctions rather than forcing every observation into yes or no.
Missing is not absent. Unsure is not no. A skipped answer is not evidence. A point on the body does not automatically describe the pain’s depth, movement, or extent.
These may seem like small details, but they can completely alter the candidate ranking.
I had to make the entire product behave as one reasoning system—from the body map and answer controls to the candidate engine, explanations, and final Care Card.
The second major challenge was question selection.
A static questionnaire is easy to build. An adaptive investigation is much harder.
Aura has to understand not only which questions are available, but which one provides the greatest value right now, given this person’s previous answers and this exact candidate pool.
The third challenge was presentation.
There is a sophisticated ranking engine operating underneath Aura, but the person using it may be worried, frustrated, or in pain. The experience could not feel like filling out a tax form or watching a machine calculate a score.
It needed to feel calm, curious, and attentive.
The complexity belongs beneath the surface. The user should simply feel that Aura is listening—and that every question is bringing them closer to an answer.
Accomplishments that I’m proud of
I built Aura solo as a genuine end-to-end product, not a collection of mockups and not a carefully scripted chatbot demonstration.
Aura can:
- Turn anatomical pain selection into a focused candidate pool
- Rank plausible pain generators using structured evidence
- Select adaptive questions based on their separation value
- Change the questioning path as the candidate pool changes
- Recalculate the complete reasoning state when an answer is revised
- Preserve supporting, conflicting, unsure, and unknown evidence
- Present the strongest supported pattern alongside meaningful alternatives
- Reveal how the user’s answers shaped the result
- Generate a practical Care Card for the next conversation
I am proud of the interface, the body experience, and the visual polish.
But the achievement I am proudest of is the part users cannot immediately see:
Aura genuinely reasons through a changing candidate pool.
Every question has a purpose. Every answer affects the investigation. Every candidate must survive contact with the user’s actual evidence.
The final explanation is not medical-sounding prose attached to a predetermined result. It emerges from the path the user created through the assessment.
That makes the experience feel alive.
Two users can select the same body area, begin with similar candidates, and move in completely different directions because of how they answer. Aura adapts because the underlying evidence changes—not because a scripted demo tells it to.
I built the tool I wanted during years of searching for an explanation: something patient enough to remember every clue, systematic enough to keep the alternatives in view, and clear enough to help me bring the whole story into a medical appointment.
What I learned
I learned that intelligence is not about asking the most questions.
It is about asking the question that changes the picture.
A single high-value question can outperform an entire page of generic form fields. The quality of Aura’s investigation depends on how effectively each question separates candidates—not on how long the assessment appears.
I also learned that structured reasoning and AI are strongest together.
The candidate graph gives Aura boundaries, traceability, and a dependable source of truth. AI gives it flexibility in how people express themselves and how complex reasoning can be explained naturally.
One supplies discipline. The other supplies fluency.
I learned that explainability should not be added at the end. If the system cannot trace a conclusion back through the user’s answers, then it does not truly understand how it arrived there.
And I learned how much one person can build when the tools become genuine collaborators.
Codex allowed me to move between product thinking, architecture, implementation, testing, medical-content structure, design review, and presentation without losing the thread connecting them.
Aura may be a solo project, but it represents an entirely new kind of solo building.
What’s next for Aura
Aura’s current experience proves the core idea:
Pain can be explored through adaptive, traceable deduction instead of a static questionnaire or an unstructured AI guess.
The next step is scale.
I want to deepen Aura’s source-backed presentation graphs, expand its pain-generator coverage across the body, and continue improving how the engine identifies the most separating question.
Every new graph gives Aura another area of the body it can explore with the same focused reasoning. Over time, that creates something incredibly powerful: a structured library of pain presentations that can be searched through conversation.
I also want to develop Aura Pro for clinics.
A patient begins an Aura assessment while waiting at reception. Before the appointment starts, the clinician receives:
- The exact pain geometry
- Relevant personal context
- The patient’s structured responses
- The strongest candidate patterns
- Important competing explanations
- The evidence trail behind the ranking
- A concise Care Card for the conversation
The patient no longer has to reconstruct years of pain from memory in a few pressured minutes. The clinician begins with richer information without spending the appointment collecting every detail from scratch.
Aura performs the catalogue work before the consultation begins.
The medical professional retains the examination, testing, experience, and final judgment—but starts several steps ahead.
That could mean more productive appointments, clearer communication, and fewer people leaving with the feeling that their pain was heard but never truly investigated.
Millions of people live with pain they cannot explain. Many repeat the same fragmented story across appointments, search results, scans, and prescriptions.
Aura could give those people a place to begin.
Not by claiming to replace medicine. Not by pretending every pain has an easy answer.
But by patiently doing what the system so often lacks time to do:
Remember every clue. Keep asking the most useful question. And never lose sight of the person searching for an answer.
Log in or sign up for Devpost to join the conversation.