I use Claude a lot. When I am reading something in French -- an article, a recipe, a film -- I ask Claude about words I do not know. Claude explains it well. I think: I should write that down. I do not. By tomorrow it is gone.

The problem is not that I lack a vocabulary app. I have tried them. Duolingo turns it into a game. Anki gives you a graveyard of flashcards for words you never actually cared about. Neither touches the two things that matter most in French: conjugation and grammatical gender.

The deeper problem: none of these apps know which words I actually encountered. They give you a list someone else decided was important. But the words worth learning are the ones that show up in your own life -- in the film you watched, the conversation you had, the thing you looked up at midnight.

The right place to capture a word is not a separate app you open. It is the moment you are already in -- the conversation with Claude. I was already asking Claude anyway. I just needed Claude to remember.

MCP made that possible. Connect Melo to Claude and it quietly saves every word you ask about -- the IPA pronunciation, an example sentence, the meaning, conjugation, grammatical gender -- automatically, in the background. No copy-pasting. No switching apps. The word shows up in Melo because you already asked about it. That is the whole interaction.

Built for people who watch French films, read Italian recipes, chat with an AI tutor at midnight.

Sign in with Apple, paste your MCP link into Claude's settings, and that is it.

What is on a word card: Pronunciation, example sentence, conjugation table, grammatical gender. These four and nothing more. English translation is deprioritized -- the goal is to stay in the target language as long as possible.

Gender as color: Masculine and feminine nouns are color-tagged consistently. Gender becomes a visual fact you absorb over time rather than memorize consciously.

Flashcard design: The card tests conjugation, not definition. Most apps ask "what does this mean?" -- Melo asks "how do you use it?" A deliberate departure from the Anki model.

No word lists: Melo does not give you a curated list to work through. It only shows you words you actually encountered. The words worth learning are the ones that already showed up in your life.

The sync UX: The hardest problem was making the Claude-to-Melo connection feel invisible rather than bolted on. The word should feel like it was always there.

Melo is live on the App Store and in submission to Claude's Connector Directory. Download on the App Store, connect to Claude, and ask about any word in French, Spanish, Italian, or Japanese.

Most product design assumes the user is the one taking action. The interface is a surface for human decisions. What happens when the AI is the actor?

At an AI startup in 2025, I designed an AI agent that could manage a user's investment positions on their behalf.

Transparency vs. noise: Showing every AI decision creates log fatigue. Hiding decisions creates distrust.

Control vs. automation: Every intervention UI you add undermines the value of the AI. The upfront configs -- the prompt, the constraints, the operation styles -- need to be expansive and deliberate. Once that step feels owned, the runtime feels earned rather than imposed.

Trust signals: Whether it is a smart contract or any other constraint -- the real safety harness is invisible because users cannot see code. The design challenge is making a technical guarantee feel human: legible limits, not reassuring copy.

The concept: an AI that could safely manage investment positions on your behalf. Hard constraints enforced by smart contracts -- not just UI affordances -- meant the AI could not spend more than you had configured. A genuine architectural safety guarantee, not a design-layer promise.

The interface looked like a messaging app. Deliberately. If you are going to have an AI managing your money, natural language is still the most flexible way to express what you want -- "take profit if we're up 20%" is clearer than any form UI. I used in-chat interactable widgets for quick actions that needed precision: confirm a transaction, check a live market chart, review a position. The chat handled intent; the widgets handled execution.

I art directed the video for this product. It was live action, post-futurist western. The setting sits somewhere between frontier town and near-future city. Characters with 80s silhouettes -- leather, volume, a little theatrical -- inside a world that is clean, architectural, slightly cold. The tension between those two aesthetics was intentional: familiar human warmth inside an AI-managed system.

A fund with no human portfolio manager. An AI agent runs it instead -- allocating and rebalancing 24/7, awake in every timezone. What does a user need to trust a fund they can't call anyone about?

Configuration vs. intent: Traditional fund platforms ask you to configure parameters -- risk tolerance, allocation limits, rebalancing rules. Parameters are precise, but they flatten a strategy no one actually thinks in.

Autonomy vs. oversight: The entire value of the product is that it runs without you. Every checkpoint added before it acts erodes that value -- but zero checkpoints means committing capital to a strategy never actually confirmed.

Trust signals: The real safety harness -- constraints enforced at the contract level -- is invisible because users cannot see code. The design challenge is making a technical guarantee feel human: legible limits, not reassuring copy.

Think of a fund platform where instead of a human portfolio manager running each fund, an AI agent runs it. Users could initiate a vault with a prompt -- an investment style, a risk threshold, a market thesis -- and the agent would allocate and rebalance the vault 24/7 within those parameters.

Early tests showed something genuinely useful: the agent could detect abnormal market signals and exit positions safely ahead of volatility -- something a human manager sleeping in a different timezone simply cannot do. Early performance data showed returns comparable to or higher than equivalent human-managed funds -- at a fraction of the management cost. And because the constraints were enforced at the contract level, the vault was structurally more secure than a human-managed equivalent.

Three views into the working build -- prompt-based vault creation, runtime performance + decision log, and an AI generated onboarding animation.

Prompt-based. Describe a strategy in plain language; the interface extracts the confidence-scored parameters covered above and asks for confirmation, not configuration.

Live vault performance paired with a running log of what the agent did and why -- each rebalance, each exit, timestamped and reasoned. The dashboard shows what changed; the log shows why it was allowed to.

An AI-generated animation sequence introducing the vault concept before a user commits capital -- explaining the constraint model without a wall of copy.

This video was motion graphics -- I designed the product and then built the video myself in After Effects and Cavalry. The systematic visual language was a deliberate extension of the product's logic: structure over character.

In October 2021 I co-founded a startup around a simple but stubborn idea: platforms should not own your information. Your content, your identity, your audience -- these should belong to you, portable across any app, visible to whoever you choose. Not because of ideology, but because the current model is structurally broken. A platform can delete your account and everything you built disappears with it.

The thesis was open information as infrastructure -- a layer beneath applications where your data lives independently of any single platform. We spent three years trying to find the right product shape for that idea, moving from a browser extension to a social identity layer to a search engine. Each product taught us something the previous one could not.

A browser extension that surfaced your online social identity contextually as you browsed. The core product decision was frictionless onboarding through claiming -- you already had content scattered across platforms. The extension let you link existing posts and domains to a portable identity file you owned, without creating anything new or changing how you posted. Content synced automatically in the background.

The zero-friction insight: nothing moves, nothing migrates. The file just starts pointing at what you already made.

60k users in approximately 5 months.

A social identity layer that connected on-chain assets with human-readable profiles. The problem was one profile, wildly different content types -- NFTs, donations, game scores, written posts. Each had a different shape.

The key interaction was the showcase management model. Inspired by iOS homescreen folders: content is clustered by type but drag-to-list and drag-to-hide let users curate exactly what appears on their profile. Listed items surface on the Vitrine. Everything else stays unlisted but accessible.

320k website visitors -- full design system built from scratch.

A pivot toward open information as a browsing and search experience. If your
identity and content should be portable and platform-independent, then so should
the way you discover information. We shipped a web app, then iOS and Android,
then a search engine format -- each iteration trying to find the right container
for the same underlying idea. Deprecated Feb 2024.

iOS + Android shipped -- full mobile design system.

One of the larger design investments was the action icon system -- over 30 icons covering every on-chain and social action type the feed could surface. Each icon uses a combination of shape and background color to encode meaning across two channels, so actions are scannable before reading any text. Shape families are grouped by category: social actions share one visual language, financial actions another, governance a third. The redundancy was intentional -- color alone fails in low-contrast environments, shape alone fails at small sizes. Together they hold.

Kill the form, keep the thesis. Every pivot killed a product but kept the idea. The design work was not wasted -- it taught us what shape the idea needed to be.

Speed is a design constraint. At a small founding team pace I had to design systems that could be built fast and iterated without full rewrites. This made me ruthless about component decisions.

60k users is a signal, not a destination. The identity extension's growth was fast and organic -- but it happened in a specific market moment that did not last. Learning to read that signal early -- and move before the trough -- was the most valuable thing I built in that period. More valuable than any of the products.

The startup's whole thesis was that identity should be open and portable -- readable across platforms, not locked behind a login. That held up online. In person, at an open-house event, it broke down completely. Two people could stand three feet apart with no way to see what the other had built, what they believed, or whether the conversation was worth having. The thing the product solved on a screen didn't exist in the room.

Physical vs. digital: a QR code on a badge is technically the same function, but nobody scans a badge mid-conversation. It needed to feel like a wristband worth wearing, not a barcode.

Instant vs. earned: the tap itself had to be one motion, no app to install, no friction. But the social layer on top of it -- endorsing someone -- needed enough weight that it read as real, not a spam button.

Private vs. performative: an endorsement is public by design. It had to feel like genuine social credit, not a popularity contest.

A custom NFC wristband, worn at three open-house events over two years. Tap it to another attendee's phone and their social profile opens instantly -- the same open-identity system the product ran online, now readable through a handshake. Attendees could endorse each other, which moved them up a live leaderboard running on a screen at the venue.

It was a physical expression of the same identity thesis the product was built on -- and it was the one piece of the whole event that people actually kept playing with.

Two versions came before the final one, and both had a failure mode.

A QR code on an event badge was the obvious first pass -- cheap, no hardware. It failed because looking someone up meant pulling out a phone, opening a camera, and aiming it at their chest. That is a transaction, not a handshake, and almost nobody did it twice.

A dedicated event app was the second pass. It failed faster: nobody installs a one-off app for a single day, and the app-store friction killed adoption before a single tap happened.

The fix dropped both. An NFC wristband works with a phone's existing NFC reader -- no install, no aiming, no separate object to hold. It stays on the wrist for the whole event, so "let me look you up" becomes a literal tap instead of an interruption. The leaderboard gave people a reason to keep tapping past the first one.

Concept, wristband design, and art direction for the physical object and the tap-to-reveal flow. Deployed across three events -- Denver (2023, 3-day format, 1,200+ attendees), Singapore (2024, Google APAC HQ, 1,500+ attendees), and Bangkok (2024, 2,000+ attendees) -- 4,700+ attendees combined.

Every city has wind. Wind has speed, direction, pressure, humidity. None of that is music -- but all of it is data with shape and rhythm.

Windspell asks: what if a city's live weather became a generative instrument? Not a visualization, not a graph. A sound you could actually sit with.

Type a city. The app looks up its coordinates, derives a musical scale from the cultural region, and hashes the city name to a root note. Then it starts polling the weather API.

The visual center of the app is a ring of 72 tick marks -- a physical kalimba model. Nine of those ticks are active tines, each tuned to a scale degree. The ring rotates continuously. Wind speed controls how fast it spins. A needle sits fixed at the live wind direction. When a tine crosses the needle, it gets plucked.

Wind speed is tempo. Wind direction is which note plays. That is the whole mechanic.

14 musical scales are mapped to geographic regions by latitude and longitude bounding boxes -- Aeolian for Nordic latitudes, Hijaz for the Middle East, Yo for Japan, Blues for the American South, Slendro for Southeast Asia. The root note comes from a djb2 hash of the city name modulo 12 chromatic semitones above C3.

Pressure, humidity, and gust data then modulate the audio continuously. High pressure brightens the filter. High humidity stretches the reverb tail. Gusty wind adds harmonic overtone content. Wind direction shifts the stereo pan field.

Chord voicing follows the region's timbre. Cold regions (Arctic, Nordic, Andean) voice an open 4th plus a sparse 6th, with long reverb. Warm regions (European, Mediterranean, Blues) voice a full triad. Bright regions (African, Japanese, Oceanic) use a clean open fifth only.

The result: Cairo and Reykjavik do not sound alike. They use different scales, different root notes, different waveforms, different reverb lengths. The same city sounds different at dawn versus midnight -- the background shader uses a real solar position algorithm, so the lighting shifts with actual sun position.

The wind bed itself is AI-generated. Instead of a fixed sample bank, the app describes the current conditions in natural language -- "steady moderate wind, with rain pattering, natural field recording texture, seamless loop" -- and sends the prompt to ElevenLabs' Sound Effects API, which synthesizes a 22-second loopable clip on demand. Every city/weather state gets its own ambient texture, generated in real time.

Generation is bucketed, not continuous. Wind speed folds into five tiers -- calm through gale-force -- crossed with weather modifiers like rain, snow, and fog. A new clip is only requested when conditions cross into a meaningfully different tier, not on every weather poll, so API usage stays lean. The key never reaches the client -- requests route through a Vercel edge function proxy.

On the client, the clip decodes through the Web Audio API and layers into the synthesis engine alongside the kalimba: blended through a compressor to normalize loudness across independently generated clips, and volume-mapped to live wind intensity on a perceptual power curve rather than a linear one. Each loop crossfades into a fresh iteration a few seconds before it ends -- sidestepping the gap you'd hear from naive loop playback of an MP3.

The resonator form was not the obvious first choice. Five directions were explored -- a breathing circle, concentric orrery rings, radial petals, a Lissajous curve, and soft diffused arcs. The concentric ring model survived because it was the only one that directly modeled the physical mechanics: a ring sweeping tines past a fixed needle is exactly how a kalimba works. The visual and the audio became one system.

Webcam and cloth simulation were scoped early and removed. A fully procedural GLSL shader -- driven by cultural region hue, live weather uniforms, and solar position -- is faster, more reliable, and creates a more distinct visual identity than a background feed.

Three.js for the fullscreen GLSL shader. GSAP for the Resonator ring animation and tine bend physics. Web Audio API for the synthesis chain -- oscillators, bandpass noise, convolver reverb, stereo panning, biquad filter. OpenWeatherMap for live wind data, polled every 60 seconds. ElevenLabs Sound Effects API for the generated wind bed, proxied through a Vercel edge function.

The audio chain runs a continuous drone at half the root frequency and bandpass-filtered wind noise that scales with wind speed. Per-pluck notes layer on top: the main oscillator, a harmony note from the chord voicing, and an overtone oscillator that scales with gustiness. Everything routes through a master gain with a wet/dry reverb split that rebuilds when humidity shifts significantly.