Project N-Studio
Self-initiated, no client
My role Product design and engineering, solo
Thesis, interaction model, system, build
When 2026 – present
Team One person
Platform macOS desktop · Electron
React + TypeScript · local relational store
Status Built and in daily use · not publicly distributed

My Role

N-Studio is a self-initiated product, design and engineering by me, end to end. It began as a personal problem: naming things is a research task disguised as a creative one, and every existing tool answers it with ad-heavy lists and no memory of what you actually like. I designed the product, defined the model, and built it as a packaged macOS application that I run daily. It is not publicly distributed.

  • Product Direction: Defined the thesis, one reusable naming engine for babies, characters, brands, products and pets, rather than seven separate apps with the same mechanics underneath.
  • UX & Interaction Design: Designed the full interaction model: the prompt, the discovery surfaces, the reaction loop, and the keyboard-first navigation that makes high-volume triage feel fast.
  • Design System: Built a token-based system on a pure-black canvas: one typographic scale, one motion vocabulary, one component set shared across every screen.
  • AI Architecture: Designed the AI-driven generation and preference-learning layer: how names are produced, scored, bucketed, and explained back to the user.
  • Engineering: Built the application in React and TypeScript with a relational local data model, packaged for macOS with Electron.

Design Challenges

Naming tools fail in a predictable way: they treat a name as a database row and the user as a browser of lists. The result is infinite scroll with no learning, no context, and no honesty about where a meaning came from. The design problem was not "show more names". It was to build a system that gets sharper the longer you use it.

  • The Blank Page: Filters are a poor front door, they demand you already know what you want. The decision: replace the entire configuration step with a single prompt in plain language, and let the system infer structure from it.
  • Volume vs. Attention: A search returns a hundred names. Designing two discovery modes (a scannable list and a one-name-at-a-time focus view) let people move between triage and consideration without losing their place.
  • Learning Without a Survey: Preferences had to be inferred from behaviour rather than asked for up front. Every like, dislike, favourite and hide feeds a profile the user can read back in plain sentences.
  • Filter Bubble Risk: A recommender that only exploits collapses into near-duplicates. Suggestions are spread across Best match · Similar · New direction · Hidden gem so exploration is built into the result set rather than left to chance.
  • Truth & Confidence: Meanings and origins are readings, not facts. Every name carries a confidence value and a source, and the interface says so instead of implying authority it doesn't have.

One Prompt, Not a Form

The product opens with a question, not a control panel. You describe the name you want in your own words (a single word, or a full brief with meanings, languages and family names) and the system does the structuring. The composer stays in the same position on every screen, so the way you ask never changes as you move through the product.

Two Modes of Discovery

The same result set is readable two ways. List is for triage: a hundred names, meanings inline, reactions one keystroke away. Focus is for consideration: one name at full scale, with its bucket, its score, and the reason it was recommended stated in a sentence. Arrow keys move between names; F, L, D and H react without ever touching the mouse.

A Profile You Can Read

Most recommenders are opaque. N-Studio's preference profile is a screen you can open and argue with: it states what it has learned (origins, styles, themes, endings, syllable counts) names the favourites that anchored each conclusion, shows its confidence, and lets you reset it. Every recommendation carries the same explanation inline: "recommended because you liked Grendor, Istor."

  • Explicit signal: what the brief asked for, in the user's own words.
  • Inferred signal: what the reactions revealed: sound, length, origin, theme.
  • Similarity: proximity to the names already kept, so the stream tightens as the list grows.
  • Bucketing: results deliberately spread across match, similarity, new direction and rarity.

From Shortlist to Decision

Discovery is the easy half. The harder half is converging. Your list holds everything kept, rated and annotated. Compare puts finalists side by side across pronunciation, origin, meaning, rarity, nicknames and compatibility, with a standing caveat that the figures are one reading of fit rather than an objective measure. Registry is where finalists land once a decision is close, and Collaboration lets a second person react independently so agreements and disagreements surface on their own.

The Assistant & the AI Layer

The assistant answers questions about your own shortlist (which favourites are strongest, what a sibling set would look like, what a rarer alternative might be) grounded in the project's data rather than a generic chat. Generation runs against Claude, and the settings screen is deliberately unglamorous: provider, key, model, a connection test, and a plain statement of what each search costs. The key is stored on the device and nowhere else.

  • Modes as configuration: baby, character, pet, brand, product, project and custom are objects, not screens: a new mode is a config entry, and the interface never changes.
  • Relational by design: the local data model maps 1:1 to a server schema, so the prototype can move to a real backend by swapping the store mutators rather than rewriting the components.
  • Honest instrumentation: a generation-health panel reports what the last batch actually returned (usable names, duplicates, and rejects) instead of hiding model behaviour behind a spinner.

The Decision

Every naming tool opens with a filter panel. Removing it was the decision the rest of the product hangs off, and it is the one that costs real money on every search.

The path I took

One plain-language prompt

You describe the name you want in your own words and the system does the structuring. There is no configuration step, the composer sits in the same place on every screen, and a one-word brief and a paragraph-long one both work.

The option I killed

A structured filter panel

Origin, gender, syllable count, starting letter, theme. It is what everyone ships, it is instant, it costs nothing to run, and it tells a new user exactly what the system can do just by existing.

What choosing it cost

Money and legibility. Every search is a model call, so a vague prompt burns real cost and returns noise, where a filter panel would have returned something immediately and for free, which is why the settings screen states the per-search cost plainly instead of hiding it. Dropping the panel also removed the product's main affordance: nothing on screen tells you what it can do. I had to buy that back with worked example prompts and a generation-health panel that shows what the last batch actually returned, and I am still not sure that fully pays for what the filters were doing for free.

How I Knew It Held

This is a self-initiated product with one user, so I am not going to dress up usage data I do not have. What I can show is that I built the instrumentation rather than hiding behind the model.

Generation health
Every batch reports usable names, duplicates and rejects, so bad model behaviour is visible instead of buried under a spinner.
Stated confidence
Meanings and origins carry a confidence value and a source. The interface says a reading is a reading.
Anti-collapse by construction
Results are spread across best match, similar, new direction and hidden gem, so a recommender that only exploits cannot quietly converge on near-duplicates.
Explainability
Every recommendation names the favourites it came from (“recommended because you liked Grendor, Istor”) and the preference profile can be read back and reset.

What was never measured

Nothing about real-world use, because there has not been any beyond me. If I opened this up tomorrow the four things I would instrument are reactions per session before a first favourite, the share of results marked usable broken down by bucket, cost per accepted name, and whether the profile's stated confidence actually predicts acceptance, because a confidence value that does not track outcomes is decoration.

What I would do differently

It is a single-user product with a single user, and that user is me. The preference model has never met someone whose taste I cannot predict, and the confidence values are calibrated against my own judgment, which is the weakest ground truth available. The next honest step is not another feature. It is putting it in front of five people who are actually naming something and finding out which of my assumptions about the reaction loop survive.

Conclusion

Impact: N-Studio turns naming from an endless list into a system that learns. One engine serves every naming context; one prompt replaces every filter panel; every recommendation explains itself. It is the clearest demonstration of how I work now: product thesis, interaction model, design system and AI-driven implementation held by a single person, shipped as a real application rather than a deck.