Overlapping moments.
250,000 windows, each a tenth of a second long. Each window records the note, loudness and strongest frequency.

I design the structure behind an experience—and leave room to discover what else it could become.
A browser-based experiment in planning with a learned world model.
Inside Dry Run Dungeon ↗
The world model is an ensemble of three small neural networks trained from play. Given a state and an action, it predicts the next state, reward and whether the run ends.
The planner evaluates candidate action sequences through that learned model, commits one move to the game simulation, then plans again. Side-by-side views expose the difference between predicted outcomes and actual transitions.
Turn sound into color. Change the rules. Compare two ways of seeing the same track.
Enter the color lab ↗
Living matter, imagined.
BUD / STRETCH / RELEASEA living simulation.
Plant a seed. Watch it evolve.
Rounded bodies follow changing currents, grow daughter cells and pull apart through soft, narrowing connections.
Each cellular family follows its own path through the moving field.
A daughter grows away from its parent. The connecting neck stretches, thins and releases.
New buds form on independent cycles, keeping the culture in motion.
An authored, microscopy-inspired system. Planting introduces new growth; the seed lets you revisit its starting conditions.
Direction emerges
from local forces.
A seed places short line segments across the surface. Each line turns in response to its position around a shared center. Together, the local directions reveal a larger flow.
A letter becomes a material.
Width and angle alter the relationship between a letter’s body and the space inside it. Move either control to explore how the same forms feel compressed, open or off balance.
The study transforms the drawn forms; it does not change the font’s underlying outlines.
A regular system.
A localized disturbance.
The grid stays regular. Distance from a focal point determines which dots become larger and brighter. Increasing pressure expands the active region, making a local disturbance visible inside the larger system.

The left side happens.
The right side might.
A small dungeon. Three neural nets. A visible gap between prediction and reality.
Loading the browser experiment…
Choose a test to open its corresponding control.
The engine runs the dungeon’s real rules. A separate ensemble of three small neural networks predicts what a move will do. The planner uses those predictions to try possible futures.
The current board becomes the starting point for each set of dry runs.
The model predicts sequences of moves. The planner scores the parts that remain within its trust line.
Only the first move of the chosen sequence reaches the game engine. Then the agent plans again.
The actual transition becomes training data. Prediction error stays visible as the model learns from play.
Uncertainty is the model’s own disagreement about a prediction. Error is the comparison with a result after a real move. Watch both.
Planning produced fewer deaths in this test, but used more steps and finished fewer runs.
| Measure | Planning | Reactive |
|---|---|---|
| Deaths | 5 | 27 |
| Mean steps | 110 | 92 |
| Wins | 5 / 30 | 10 / 30 |
Recorded P3 measurement: 10 seeds × 3 random streams, 120 real steps per seed-run, horizon 12 and 24 candidate sequences. Mean steps include runs that reached the 120-step cap. These are development measurements, not a promise about every run.
Training and prediction run in your browser. The live study starts from an existing trained reference model and continues learning from real moves.

Loading the color lab…
The lab measures sound, maps the measurements to color, then places the same moments in two different arrangements.
250,000 windows, each a tenth of a second long. Each window records the note, loudness and strongest frequency.
By default, note chooses hue, loudness drives saturation and strongest frequency sets lightness. Change the rules or palette in the lab. Silence stays black.
Rings grow outward from the opening. The Hilbert layout keeps nearby moments together. Both show the same analysis.
Example recordings: Chopin, Nocturne Op. 9 No. 2, performed by Peter Johnston via Musopen (CC0); Beethoven, Symphony No. 8, iv. Allegro vivace, Musopen recording (public domain); “Hitman” by Kevin MacLeod (incompetech.com), licensed under CC BY 4.0. The recordings are not hosted here.

What’s below
changes everything.
Lead UX/UI Designer
2023–2024
One designer.
Two development teams.
Three surfaces.
Ground Penetrating Radar Systems scans what's underneath a job site (gas, water, electric, sewer, telecom) before anyone digs. SiteMap is the software product where all of that data lives. It's a map-first interface where building owners, contractors, and engineers can see the utilities and features GPRS captured, drill into work orders, manage their properties over time, and trust that what's on screen matches what's in the ground. A high volume of records, scans, and assets flows through the system, across desktop, tablet, and mobile.
I joined SiteMap as Lead UX/UI Designer in 2023 for the redesign. The new version shipped in late 2024 and continued evolving from there as new functionality came online. I was the only UX/UI designer on the product, and the design director for it. Every interface across desktop, tablet, and mobile came from my desk. The teams around me were product managers, a business analyst, and two development teams, one for web and one for mobile, each with its own dev lead and engineers. I ran a weekly cadence with both to keep what they were building aligned with the UX, and to work through the design implications of decisions they were making.
SiteMap was already in production when I came on. Customers were using it daily. The product had good ideas everywhere, but it had grown without a design system underneath it, and the work had splintered. Different surfaces handled the same patterns differently. The same data appeared in incompatible ways across the product. Adding new features meant inventing each one almost from scratch, because the foundation to build on was crumbling.
The business wanted more, not less. A richer feature set, more granular permission levels, deeper subscription tiers, more of what users could do with the data. The redesign had to do two things at the same time. Unify what was already there, and make room for everything coming next, without breaking the workflows customers already depended on.
That pull in two directions ran through every decision. A from-scratch redesign would have been easier in some ways. No legacy to honor, no users to protect. This was the harder version. Bring coherence to something that's already working, while adding complexity the product hadn't been built to support, and ship it without anyone feeling the floor shift underneath them.
A few principles emerged from the redesign and held across the suite.
The map is the surface. SiteMap's entire premise is that the map is the source of truth. The satellite view of the site, with utility lines and feature markers layered on top, is where the user lives. Panels slide in over the map rather than replacing it. Detail views keep the map's context. The reader never loses sight of where they are physically, because where they are physically is the whole point. Making the map the workspace was the design decision that everything else hung on.
Color carries condition. Storm lines run down a vertical rail with their pipe condition color-coded (green for excellent, yellow for fair, red for immediate attention, and so on). The user scanning a sewer system isn't reading words. They're reading the rail. The condition language is consistent across utility types and across surfaces, so a field engineer on a phone and an estimator at a desk see the same colors meaning the same things.
Performance is part of the design. A site can have thousands of features on the map at once. The Settings panel exposes the controls that make that workable (render scale, feature icon size, hide-removed-lines, low-memory mode) and the defaults are calibrated so the map stays usable without the user ever having to open the panel. The settings exist for the power user. The defaults exist for everyone else.
Same language on every device, not the same product. Desktop, tablet, and mobile share the same data model and the same language, but they don't try to be the same product. Desktop is where the heavy work happens (reviewing inspection videos, managing subscriptions, administering tags). Mobile is where the field happens (pulling up a line detail in the dirt, confirming a work order on site). Tablet sits between them, comfortable in both contexts. The design treats each surface as serious in its own right, not as a downsized version of the next one up.
Across the redesign and the year of feature work that followed, the scope spanned the SiteMap canvas itself, the Plan Room file system, sewer and line detail with embedded inspection video and PACP observation codes, Reality Capture for point clouds and 3D scans, subscription management for the business customers, an admin surface covering tags, user management, training, and messaging, multi-tier permissions, the settings layer that controls map performance, and on-canvas annotation tools.
All of it on three surfaces, all of it tied to the same data model, all of it designed by one person working with strong dev teams on each platform. The weekly reviews with web and mobile were where the design held. A place for the engineers to surface what they'd built or where they were stuck, and a place to make the calls that kept the surfaces aligned without grinding development to a stop.
Two things came out of this engagement that I've taken with me.
The first is that redesigning a live product is a different discipline than designing a new one. A new product gets to be perfect on day one because nobody is using it yet. A live product has to be better tomorrow than it was today without breaking the work people did yesterday. Every decision is weighted by the people already inside the product. That weight is what makes the work matter.
The second is that design coherence at this scope is mostly an alignment problem, not a drawing problem. The screens come together when the surfaces are reasoning from the same model. Most of the work was making sure that model held, across desktop, tablet, and mobile, across feature areas, across the developers building each piece, so that everything visible on the screen was the visible end of a deeper consistency underneath.
ORDERING / REWARDS / THE STORE SIDEEinstein Bros. Bagels App

Choose when and how to pick up an order.
Actual interface captures; these screens illustrate the work.
Bagel Brands had an app. It had a store finder, a rewards card, and an ordering system that had been patched for years and was failing people at the moment they were hungriest. Rewards counted what you bought and did nothing with the count. Ratings were low, and the reviews said why.

I led UX at Xpanxion on the rebuild, working directly with the Bagel Brands product team. The brief was Einstein Bros. Bagels first, then take the results and apply to Bruegger's Bagels and Noah's New York Bagels.
Before any screens, one question. What does a regular actually want from this app at 7:40 on a Tuesday morning?
The answer was short. Reorder the usual, know the reward is there, get out. Everything else, the menu browsing, the gifting, the nutrition, is real but secondary. That answer set the priority for the whole build. The order flow and the rewards had to work together to create a more cohesive experience or nothing else mattered.
A new design system, in Figma, from the ground up. A component library that engineering could build against and that the other two brands could re-skin without redesigning. Type, color, spacing, and every state of every control, so that "add a bagel" looked and behaved the same in three apps.
Ordering, rebuilt. The legacy flow was replaced with one that handled customization, favorites, and reorders without dead ends. We added features the old system couldn't carry, and we made the cart reliable.
Rewards that apply. Points earned in an order, shown in the order, redeemable on the next order. The old app tracked. The new one pays out. This sounds like a small change. It was the change customers had been asking for in reviews.
The store side. Alongside the customer app I designed a proof of concept for the admin interface stores would use to manage menus, deals, inventory, and location-specific details. Design only. It never went to build while I was on the project. But the case for it was the same as for everything else. The customer sees a menu that's accurate because a manager updated it that morning in a tool that made the process easy and accurate. The app is only as good as what the store can keep current.


Weekly standups with product managers, engineers, and the business analyst. I owned UX and UI end to end, brought flows to stakeholders with the tradeoffs already drawn, and adjusted with engineering when the platform pushed back. The design system meant those adjustments landed once and propagated everywhere.
Designing the store admin at the same time as the customer app, not after, even though it stayed a proof of concept. The argument against was obvious. Scope. The argument for was that a beautiful order screen showing an item the store ran out of at 9 a.m. is a broken promise. Fixing the data path fixes the experience.
The app in the App Store today is the one we shipped, with the sprints of usability work that followed launch. It holds a 4.8-star rating across more than 120,000 ratings. The same system runs Bruegger's and Noah's.
The thing I'm proudest of isn't the number. It's that three brands with different personalities run on one set of shared components without looking like a template.
VRC Suite
When a regulator asks “prove it,”

Vital Records Control is one of the largest records and information management companies in the U.S., handling the full information lifecycle for regulated industries from healthcare to banking to government. I led UX for four of their products over four years. VitalChart, Payer Audit, Pricing Tables, and Vital Retain. Four products, one connected suite, a high volume of requests moving through the systems every month.
The question underneath all four. When a regulator asks "prove it," can the system answer?
VitalChart is VRC's healthcare information management product. Medical records request, retrieval, and release. It's the spine of the healthcare arm of the business and the surface most healthcare clients touch daily.
Payer Audit is a high-volume workflow inside VitalChart for the bulk record requests that come from insurance payers for HEDIS audits and similar compliance reviews. A payer sends a CSV of the records they need and a PDF of the request letter. The system ingests the batch, validates each request against a layered set of rejection rules, creates a container per request, and breaks it into individual release-of-information records, each with its own lifecycle from logged through QA through processing to completed.
Pricing Tables is the rate engine under VitalChart's billing. Every U.S. state has its own rules for what a records custodian can charge, by requestor type and record format, tied to specific statutes, and the rules change when laws change. Pricing Tables is the editable, auditable rule store that bills every release at the right rate for the right state for the right requestor at the right time, and can prove which rates were in effect when.

Vital Retain is the retention product, the keep-or-destroy side of the business. Multi-tenant. Subscriber organizations track physical and digital records against retention policies tied to real legal references and CFR citations, with full audit logs on every action. Policy updates queue and require explicit confirmation before they apply, because silently changing the retention period on 89 boxes when the law shifts is the kind of thing that ends a business.

Three of the four share branding under VitalChart. Vital Retain is its own product with its own identity, designed to plug into the wider VRC ecosystem.
Four years. I led a team of four UX/UI designers and stayed hands-on every day. Directing the work, doing the work, and holding the suite together as one product experience across four stacks and three years of organizational change on the client side.
I authored the information architecture, user flows, and system maps across all four products. On the broader IA I co-authored with another architect who brought depth on specific pieces, like the AWS-based address normalization service Payer Audit depends on. Everything else was mine to design and direct. The team delivered IA, flows, design systems, screen designs, and product strategy support across the four products, and we documented as we built.
This was more of an uphill build than the deliverables suggest.
The four products ran on four tech stacks. The databases had grown organically for years. There was no appetite to fix all of it at once, and that was the right call. Consolidating onto one stack and rebuilding the data layer would have meant re-platforming the company, multi-year and multi-million, the kind of project that puts a business on hold. So the work was designing solutions that could scale into the infrastructure as it stabilized, rather than waiting for stability that wasn't coming.
The first year was turbulent. Product managers cycled through. The development team was replaced mid-engagement. There was no business analyst until year three, so the design team carried more of the discovery, requirements, and cross-team translation than is typical.
Documentation became the discipline that held it together. Whoever came in next deserved a clear handoff, and design needed a stable reference across products that shared little underneath. We documented the IA, the flows, the design system, the rationale behind product decisions, the rejection rule logic, the rate engine, the multi-tenant access model. By the end, the design documentation was the reference point the whole program relied on. The screens are the visible output. That discipline is what made the program survive.
Four principles ran through all four products.
Audit logs everywhere. Every meaningful action in Vital Retain, every status change in Payer Audit, every rate adjustment in Pricing Tables writes an audit event. The system assumes someone will need to reconstruct what happened.

Bulk operations, calm interfaces. Payer Audit processes requests by the batch, thousands at a time. Vital Retain assigns retention policies across a client's entire inventory, boxes and files alike. High-volume operations had to feel calm. A filterable list, a side panel, and an explicit confirmation when an action touches a lot of things. The "89 Assets Will Be Affected" modal exists because silent bulk changes are how regulated-industry products lose trust.

Status as visual rhythm. Someone processing 200 records a day shouldn't have to read every word to know where they are. The colors carry the work.

A person on every judgment call. Pricing Tables doesn't auto-update rates when statutes change. Vital Retain doesn't auto-apply policy updates. Payer Audit doesn't auto-process records that fail rejection rules. In each case the system surfaces the decision for a human to confirm, because the cost of being wrong is too high to delegate.

Dashboards, record and asset detail pages, multi-step ingestion flows, rule administration, bulk action panels, audit logs, multi-tenant customer management, status pipelines, and a state-by-state pricing editor with hundreds of rule cards tied to legal references and effective dates. These are a representative slice, not the inventory.




Coherence across a product suite is mostly a documentation discipline, not a design-system discipline. A design system gets you consistent buttons. The feeling that four products on four stacks belong to the same company comes from someone deciding, over and over, what the suite's point of view is on each new question, and writing it down so the next person doesn't re-decide it.
And in long engagements with rotating leadership on the client side, the design team becomes the keeper of institutional memory. It's not in the contract. It's the work that makes the rest of the work possible.
NovensiaA brand operating system.
Inside Brand Voice Engine ↓Voice documents from the engine. Identities steered by hand.

Novensia is a brand operating system in private alpha. The brand foundation (mission, pillars, voice, visual direction) becomes the source of truth that powers everything downstream, from content production on out. It's built for people who are their own brand, and for the agencies, coaches, and consultants who build brands for others.
I designed and built it, working through Claude Code. I run it by hand, on purpose. It stays manual until it has earned the trust to run on its own. Every run ends with me reading the output before anything is used.
Building a brand asks you to be ten specialists at once. Strategist, writer, designer, content producer, marketer. The people who put Novensia to work are one or two of those at most, not all ten. They're founders, coaches, consultants, small business owners, and the agencies that serve them. They know their work. What they don't always know is whether they need a brand pillar, how to word a mission so people take it seriously, or where to start.
The existing tools are feature-level. A logo maker. A palette generator. A content tool. None of them answer the real question. Where do I start, and how do I know I'm doing this right?
AI was supposed to fix this. Ask a model for a brand mission cold and you get something generic, because there's no foundation underneath. No record of who you are, what you stand for, how you sound. Audiences can tell.
Novensia is built on the opposite premise. Foundation first. The system learns who you are, keeps that record, and uses more than one model checking the other's work so what comes out is grounded in you.
Three layers, in order.
First, the foundation. A guided intake with seven chapters that walk you through who you are, what you believe, who you serve, how you want the brand to look and sound. Each chapter is a run of questions, and each question comes with a short note on how to think about it as you answer, so momentum holds and nothing overwhelms. Autosave on every keystroke. Chapters you can move between freely, because the work doesn't come out in order. It's a capture instrument by design. No AI synthesis at this stage, on purpose. You can't make sense of what you haven't said clearly first.
Then the production tools. The voice and content engine is the first one. Four model stages. It learns how you write from your samples, builds a strategy for what you want to say, generates a draft, then runs a quality pass. Between strategy and drafting, you can review or change the length target. The last stage hands the accepted draft to a second model to score against your voice profile and content brief, identify what's off line by line, and return a revised version with those problems fixed. The score belongs to the original draft. The returned revision is clearly marked as improved but not independently rescored. The draft, critique, and revision are all kept, and you can go back to any of them.
Human length review follows strategy. Foundation synthesis is a planned layer. The final score belongs to the original draft; the returned revision is not independently rescored.
Every stage hands the next one a checked, typed JSON result. If the output doesn't match the contract, the next stage doesn't run.
The model assignments are deliberate and they move as models change. The rule underneath doesn't. The stages that learn your voice and plan run cool, the stage that writes runs warmer, and the model that judges is never the model that wrote. Judgment needs to be sharper than invention.
The voice profile captures techniques, not phrases. "Trained on your voice" usually means remixing sentences from your samples, which is why the result sounds like a karaoke version of you. Novensia learns how you make a point, not the words you used to make it last time.
The third layer, synthesis, is next. It fuses the foundation with the tools, so when the engine writes it draws on your mission, your pillars, and the people you serve, not only your writing samples. The schema already reserves space for it.
Everything attaches to a shared brand record. Intake and engine are siblings, not steps. Use one, the other, or both. The brand is always the source of truth, and it grows as you give it more.
The engine writes the words. The other half of the system turns a person, or a company, into a brand identity. The look. Same foundation, different job, and this is the half I steer by hand against the system's logic.
Brand identity work is slow and bespoke, and its quality usually lives or dies on one creative director's taste. That doesn't repeat and it doesn't scale. AI logo makers and brand-kit generators are fast, and speed was never the problem. They have no grounding in the actual person or business and no judgment steering the output, so they produce generic sameness quickly. This half is built to sit between those two failures.
Intake. The same foundation the engine uses, read for what it says about the brand. Who they are, what they believe, who they serve, how they talk, what they've lived through. Not a creative brief written to sound good. The actual person or business, in their own words, contradictions left in.

Analysis. This stage returns the strategic core. A set of archetypes, a positioning line, the ground the brand should stand on, a voice. It's the step that turns a person or a company into a brand foundation, and right now it's the step I run by hand, working the system's logic against the intake rather than letting a built pipeline do it.
Direction and build. The foundation becomes a visual system and a deck. Type, color, texture, imagery, logo. This is where I art-direct, and where the manual judgment is heaviest. Some of the imagery in these identities is generated, from prompts built out of the brand's own foundation rather than typed cold. The rest, including the layout of every deck, is made by hand.
Each stage hands a real artifact to the next. An intake doc, a foundation doc, a creative-direction doc, a deck. You can open any stage and see what it produced and the reasoning behind it. The brand isn't one opaque output. It's a chain you can audit.
Two things keep the output specific instead of templated.
The analysis is grounded in the brand's real material, not a vibe. The archetypes come from what was actually said and lived, whether that's one person or a company, and the hard constraints in the intake become hard constraints in the art direction. The system isn't guessing at a personality. It's reading one.
And I steer every output with brand judgment. The system proposes. I decide. On one brand that meant catching things the system couldn't. Its type direction was too rigid to build on, its two chosen colors vibrated against each other, and two of its four archetypes were really one person. The system reads what's written down. I can see what's on the page and know what isn't.
The system can generate. It can't yet tell what's on-brand from what's almost. Until it can, my judgment is the check, and running it by hand is how I see what the model gets right and where it drifts. That's how I get it right before I take my hands off.
Four brands have gone through the system so far. Rory Miller, John Nemo, John Michael Morgan, and Sean Patton. The engine wrote the voice documents. The identity work was steered by hand against the system's logic. Same pipeline, four voices that don't sound alike, four brands that don't look alike. All four are personal brands because that's who came first. The system reads a company the same way.
The clearest proof the system isn't a template is what it does with the same starting point. Sage sits in all four analyses. Nemo's Sage cracks a joke. Rory's is monastic. John Michael Morgan's is a rebel-philosopher. Sean's was forged in combat. The archetype is where the system starts. The person is what it's made of.
Nemo. A LinkedIn lead-generation coach, a former reporter, and funny on purpose. The system returned Sage, with Magician and a merged Everyman-Jester. I built a punk-zine identity. A mismatched, hand-drawn logo, heavy Xerox grain, kraft and a punch red. The loudest of the four. Wisdom that cracks a joke.
Rory Miller. A teacher of grounded spirituality for high performers who have the external success and want the internal alignment. The system returned Hero-Sage, with Rebel and Explorer, on an essence of discipline as a path to spiritual freedom. I built the opposite of Nemo. A refined gateway mark of three nested arches whose negative space at the base reads as an M, muted earth tones with no bright accent, one clean type family, imagery of standing stones and brutalist concrete. Monastic. Built to feel carved and permanent, discovered rather than designed.

One full run, for Rory, produced the document set below. Core, Voice, Voice Library, Visual, a brand film treatment, and video scripts with alternates, plus the logo. Every piece was reviewed by a second model, then by me, before it went to him.

John Michael Morgan. A personal-brand strategist whose whole pitch is "brand out loud." The system returned Maverick × Sage, a rebel-philosopher. Bold truth meets timeless insight. I built a warm vintage-editorial identity. A serif headline face, gold, ochre, and ivory, the feel of book covers and protest posters, heavy print grain. Literary and warm where Sean is cold and Rory is bare. Wisdom that echoes.

Sean Patton. A Special Forces veteran turned leadership coach. Lead yourself first. The system returned Warrior, with Sage, forged from within. I built cold steel and concrete. Bebas Neue command type, steel blue with a single signal red, forged-metal iconography, shadow-draped black-and-white portraits. Military and controlled. The most disciplined of the four.

One decision carries the whole point. The system proposed Bebas Neue for Nemo's headlines. I rejected it there because it couldn't flex, and Nemo's brand needed type that could warp like a bad photocopy. For Sean, Bebas Neue is exactly right, because command and rigidity are the brand. Same font, opposite calls, because the brands aren't the same. That gap between what the system reaches for and what the brand actually needs is the judgment, and it's the part I keep by hand.
This is what the system is for. Not a paragraph of on-brand copy. A foundation someone can build a business on.

Branding is storytelling, so Novensia is built in chapters. You're writing the story of your brand, in order, one piece at a time.
The intake doesn't hand you a blank page. Every question comes with that short note on how to think about it. Every chapter has an intro that frames what you're about to work on. The system has a point of view about where to start and what good looks like, not to put words in your mouth, but to give you something to push against.
At the end, something quiet happens. You've written it down. Your mission, your pillars, who you serve, how you sound. The thing you've carried around half-articulated for years is outside your head, structured, readable. That's what the whole product is designed to deliver. The architecture serves that moment. So does the design. So does the AI, when it shows up.
Novensia is at the stage where one person makes every call. Strategy, architecture, prompt design, design system, intake design, copy, database schema, build, and the brand direction on every identity that comes out of it. AI does a lot of the work under those calls. I build with Claude Code, and the product's own models do the analysis, the drafting, and the review. What I keep is the judgment.
One person at this stage is a scope decision, not a ceiling. Working solo has kept the product coherent. The interface design shapes the architecture. The words in the interface shape the design. And all of it is shaped by what it's like to sit down and write a mission statement for the first time, which is the moment the product exists to serve. When one person holds every layer, a change in one reaches the others the same day. The platform is already built for more than one workspace and more than one set of hands. The next stage adds them.
The synthesis layer, so generated content is grounded in mission and pillars, not only samples. The schema's built for it.
RAG, so the engine can learn from far more than a handful of samples. A backlog of posts, a book, years of emails.
The visual half, as a built pipeline, so the analysis and direction I run by hand today become stages the system runs and I review, once it has earned that.

A brand woven into the place.
From the entrance mosaic to an embroidered cuff, the identity belongs to the building.


Nashville in the mid-2010s was filling up fast. New hotels were opening constantly, tourism was accelerating, and the city's hospitality market was getting crowded. Union Station had something none of the new builds had. A 125-year-old Gothic train station on Broadway, a soaring lobby atrium, a history that predated the city's modern identity. The question was how to make that clear, coherent, and competitive in a market that was suddenly paying attention.
The hotel had just completed a full interior renovation and wanted a brand to match. I was at ST8MNT and co-led the engagement as Creative Director and Brand Strategist, alongside a second creative director and a second strategist, with two art directors and a designer on the team.

The strategic anchor we landed on after discovery was the monogram. A single USH mark designed to live everywhere. The logic was that a hotel with this much physical presence needed a brand that worked the same way. Not a logo applied to things. A mark woven into the place itself.

Everything followed from that decision. The color system pulled from the building's own materials and history. Chambray Blue, Palliser Copper, the warmth of aged brass and dark wood.

The primary typeface, Fortescue, brought the historical weight the architecture deserved, with GT Pressura Mono as the secondary face.



The tile mosaic at the entrance was designed by our team and executed by the renovation contractor, so the brand was built into the building's floor before a guest ever checked in.
And out front, a custom typographic sculpture, over six feet tall and fabricated from our design, put the wordmark in the street, visible from Broadway, part of the hotel's physical presence in the city.

A brand system deep enough to dress a hotel from the sidewalk to the staff uniform to the room service menu.
Years on, the mosaic is still in the floor and the sculpture is still on Broadway. Hospitality brands get refreshed every few years. The parts of this one that were built into the building are still doing their job.

Change the view. The attitude holds.

A personal brand for John Nemo, built with a system I'm developing and steered by hand.

The NEMO logo is the place to start, because it makes the whole argument in one mark. Five letters, none of them behaving the same way. The N and M are a variable sans-serif that can shift width and weight. The E is a condensed slab serif. The O is never just a typed character. It's an object every time. Hand-drawn, cut from paper, a magnetic letter off the fridge, a coffee stain, a Zubaz-pattern cutout. It shifts with every client, which is the point.
Nemo's whole pitch is that he breaks formulaic branding to help people find their real voice. A logo for that can't be one tidy lockup. The inconsistency is the system. The mark works because it refuses to settle, the same way he does.

John Nemo runs a LinkedIn lead-generation agency out of Minneapolis. He started it with one client and thirty days of money, and built it past seven figures. He's a former Associated Press reporter and the author of eight books. He wears Zubaz pants and mismatched t-shirts on purpose. He's a "just Jesus, not religion" guy who is careful never to preach. By his own account he has the worst fashion sense on the planet and a popcorn bucket he wears on his head.
That's a lot of person to put into a brand, and most of it would get sanded off by a normal process.
This brand didn't come from a moodboard. It came out of a brand voice system I'm building.
The system is Novensia, a brand operating system I'm developing. A client fills out an intake. The system reads it and returns the strategic core. The archetype, the positioning, the territory the brand should live in. I take that and art-direct it into the finished work.
I run it by hand, on purpose. It stays manual until it has earned the trust to run on its own. The Novensia study says why. What matters here is what running it by hand made possible on this one brand.
There's a second kind of read the system can't do, and Nemo is the clearest example of it. The intake is all the system gets. From his, it returned a four-part archetype stack. Sage, Magician, Everyman, Jester. That's correct. But after spending real time around John, I merged two of them. The Everyman and the Jester aren't two sides of him. They're one person. The funny regular guy is the whole thing, and you only learn that by being in the room with him. The system reads what's written down. I can know what isn't.

The system's type direction was reasonable. Bebas Neue for blocky zine headlines, Inter for clean body, Space Grotesk for accents. Three faces that match the adjectives in the brief. Editorial, bold, raw. On paper it fits. In practice it would have built a stiff system. Three static fonts, each doing one job, with no room to move.
I kept the intent and rebuilt the toolkit.
Most of the system runs on Roboto Flex, one variable font doing the work the brief split across two. Its range across weight, width, and optical size covers the clean blocky headline Bebas was there for and the readable body Inter was there for, in a single face. One file, more positions, a system that can flex instead of three that can't.
GT Planar comes in only where the page needs to break. Its slant axis runs backward through upright to forward, from a reverse italic (retalic) to a true italic, and that back-slant is the whole reason it's here. It does on screen what happens when a page drags across the Xerox glass mid-copy. The skew and smear, type that looks reproduced rather than set. Bebas is one fixed cut. It can't warp. The zine look needs a face that can, so GT Planar is the expressive moment and Roboto Flex holds everything around it.
Accents went to Roboto Mono. Space Grotesk's clean right-angle descenders read contemporary, and against Xerox grit that's a tonal mismatch. A typewriter face brings the self-printed-mag rawness. But a distressed typewriter font is a costume. Roboto Mono keeps the typewriter DNA with a quiet modernity, so the accent reads raw without reading retro.
The system can pick fonts that match the words. It can't feel that Bebas and Inter would be too rigid to grow a system from, or that those clean descenders would fight the grit, or that the territory needs type that warps like a bad photocopy.

The system named the palette correctly. Blue for trust, red for conversion. Black for ink. The specific colors it picked were the problem. Its blue was #004DFF, a loud digital blue. Its red was #FF004D, a near-neon. Named right, chosen wrong. Put those two next to each other and they vibrate. Both sit high and saturated, close in value, and the eye can't rest where they meet.
I pulled both toward ink. The blue became #2176AE, a printed, faded blue that reads like it came off a press instead of a screen. The red became #E63946 and got a new name. "Conversion Red" is funnel language. "Punch Red" is what the color does on the page. The rename is small, but it moves the palette out of marketing vocabulary and into editorial vocabulary, which is where the brand lives.
I split the black in two. Ink Black #1D1D1D for set type, Hand-Drawn Black #121212 for the marks meant to look made by hand, so the hand-drawn elements don't read as the same flat black as the body.
Then I added three colors the system never named. Zubaz Violet #6B60B1, Lead Spark #2C5282, and Slate Grey #B5C7D3. The violet is John's pants, pulled straight into the palette. The other two give an asset somewhere to go when it needs more range.
The creative direction said minimal color, and adding this much pushes against that rule. That was a real tradeoff, not an oversight. I widened the palette on client feedback and because some assets needed room to shift tone. Most of that room went to the paper colors, the off-white #F4F1EC and the kraft #F4E6C7, because they read as paper rather than color. They let a layout breathe without breaking the discipline the minimal-color rule was protecting.

The texture system is where the brand stops looking designed and starts looking printed. Xerox grit is the primary texture, the grain you get dragging a page across a copier. The rule behind all of it is one the deck states plainly. If it's too clean, it's too forgettable.

The fingerprint is the part I'm proudest of in this brand, because it started as a positioning idea and became a visual mark. John's whole argument is that he's the opposite of the spam-and-funnel marketers in his space. You're the prize, not the pursuer. No templates. The line for that is "less funnel, more fingerprint," and the fingerprint isn't only a line. It shows up as an actual texture in the work. A positioning idea you can see.

The imagery has a hard rule attached. Real people, real expressions, teaching and conversation, never corporate stock. The photography runs monochrome so it reads as documentary rather than catalog. Color is allowed where an element looks hand-done or pasted up, but the people stay black and white.

Two things in this brand were made the way the whole system is meant to work, and they're worth being precise about.

The copy lines came out of a loop, not a single pass. "Editorial with teeth." "Less funnel, more fingerprint." "Be clear, not clever." None of those are first-draft system output, and none are written cold by me. I took the system's output and ran it back through, workshopping with AI in the loop until the lines were right. That back-and-forth is the method, not a shortcut around it.
And the brand logic itself, the archetype and positioning and territory, is the system's analysis, not my guess. What I added is the judgment the system can't make yet. It couldn't see that two of its archetypes were the same man, or feel that its colors vibrated. It couldn't tell that its type was too rigid to build a system on. AI is the material. The judgment is mine.
Ingestion. Retrieval. Rubric. Scoring. Digest.
The rules. The edge cases. The pursuit decision.
UST RFP Triage Agent
Built end to end / 2024An explanation of the system’s paths, using generic scenarios.
The full request is available. The system applies the team’s current rubric and prepares an auditable first pass.
Power Automate turns the email into a text file.
The agent applies the current rules table.
A spreadsheet records the rule results; a summary carries the score and flags.
The team receives a morning synopsis and recommendation.
Worthwhile requests receive a human review before pursuit.
A human path in. A human decision out.
The public sector team at UST had a volume problem. Every morning, requests for proposals and quotes landed in the inbox from request systems, from scraping, sometimes direct. Roughly twenty a day. Some were potentially worth half a million dollars or more. And each one needed a decision. Is this worth pursuing, or not?
That decision wasn't simple. It depended on what the team does and doesn't do, the type of project, which level of government it came from, conflicts of interest, whether UST actually had the skills the work required. A real rubric lived in the team's heads and in a checklist. Applying it to twenty requests a day, fast enough to matter, was more than anyone could keep up with.
The question I asked before building anything. Which parts of this decision repeat the same way every time, and which need a person? The rubric repeated. The final call didn't. That split became the architecture.
I built a system that does the first pass.
The team's decision criteria became a rules table. A structured, editable rubric the team owns. They add to it, trim it, and the agent always scores against the current version. The judgment stays theirs. The system just applies it at volume.
Each morning's requests flow through Power Automate, which simplifies every email into a text file and hands it to a CoPilot agent. When an email doesn't contain the full RFP, which happens often, Power Automate scrapes the rest.
Sometimes scraping hits a wall. A request gated behind a login, a system that blocks automated access. The system doesn't pretend that case away. It hands it to a person, who logs in, copies or downloads the full RFP, and pushes it back into the flow. A designed fallback, not a failure.
Once the agent has the complete request, it scores it against every rule in the table. A couple of rules are hard stops. If one of them trips, the request is an instant no-go and nothing else needs checking. For everything else, the agent writes a per-request spreadsheet with each rule scored, stores it, and generates a summary document. A synopsis of the request, the results, a final score, and the flags behind it. Go, maybe, or no-go, with the reasons attached.
A no-go doesn't disappear. Every request gets scored and stored, including the ones a hard stop rejected, so the team can go back and audit what the agent turned away and why.
The summary lands in a Teams channel. The whole team scans it over coffee. A morning of senior-people judgment becomes a digest they can read in minutes, and the handful of requests actually worth pursuing get pulled out and scrubbed by humans before anyone commits real time.
The hard part wasn't the plumbing. It was trust.
These are six-figure pursuit decisions. For a team to rely on an agent's read of an RFP, the agent has to be right in a way that holds up. Not in a demo, in production, every morning, on messy inputs. That takes real work. When I left UST the system was a working pilot, still in testing, still being tuned. That wasn't unfinished business. That was the business. You don't ship an AI system that influences where a team spends half a million dollars and call it done after the first good output. You calibrate it until the people using it would stake a decision on it.
The other thing I took away was about the tools themselves. Working in Power Automate, the logic was sound but the experience of assembling it fought me the whole way. The machine sits at the center of these builders, not the person, which makes the build far more complicated than it needs to be.
I built the automation and the CoPilot agent end to end. The ingestion flow, the scraping and human-fetch fallback, the scoring logic, the spreadsheet and summary generation, the Teams delivery. The rules, the spreadsheets, and the final decisions stayed with the public sector team, where they belong. The system applies the team's judgment. It doesn't replace it.
That split is the point. Automation handles the volume and the messy inputs. People handle the judgment and the edge cases. A human path in when ingestion hits a wall, a human decision out when the digest lands. The agent triages so the team can decide. That's the only responsible way to put AI near a decision this expensive.
Craftsmen of change and culture.


Andculture is an experience design agency in Harrisburg, Pennsylvania. In 2014 it wanted a more focused brand, and the one it had looked stale and too technical. I was Design Director there and led the rebrand and the website refresh. I directed the team that designed and built them, and stayed hands-on along the way.
The agency built user experiences and software, but it didn't want to lose the craft behind that work. The creativity, the art, the habit of keeping a hand in it. That became the line the brand was built on. Craftsmen of change and culture.
The brand also chose who it was for. We aimed it at startups, mainly well-funded ones, and the homepage said so plainly. It asked for revolutionaries.
Nobody ordered business cards. Each person had their own stamp, and when they ran low, they stamped more. The craft line wasn't only on the website. Everyone at the agency did it by hand.
Business went up after the rebrand, and Andculture got talked about in the startup community. Startups liked that the same team could make something by hand and build the software behind it.
Team: Bradley Hawkins, Madeline Pellman, Kate Ferrara, Brian Zeiders, Anna Spisak

Scroll to explore ↓





A new console.
Three connected acts.

OUYA was an Android game console built around one promise. Every game is free to try. It raised $8.6 million from 63,416 backers on Kickstarter, more than nine times its goal, and came to Andculture once it was funded. The job was the brand, the marketing, and the surfaces users would interact with, online and on the console, from the website and game pages to the store and the console's game downloads. The work came in three parts over about a year.
I was creative and design director across all three, responsible for the direction and strategy, art direction, and user experience. Much of the hands-on work was done by the design team I directed and managed.
Brand and web. The launch site led with the free-to-try promise and the size of the catalog.
E3, 2013. For political reasons, OUYA was kept off the E3 show floor. Rather than give up, they parked a semi and a gaming truck in the lot directly across the street. We made huge banners to hang from the truck and screenprinted posters for the fence, one for each launch title, each in its game's own look instead of OUYA's. The posters were giveaways, a reason for people to cross the street, play the games, and try the console. I illustrated the ChronoBlade poster myself.
The international store. When the console started shipping outside the U.S., the store had to handle 52 countries, each with its own currency, duties, and shipping rules. I led the UX here, down to the user flows and flowcharts. People picked their country first, so every price and shipping cost after that was already right for them. Anyone who'd rather buy in a shop could find a retail partner instead.
Team: Madeline Pellman, Bradley Hawkins, James Hess, Kate Ferrara












Willow was a new bed-in-a-box mattress brand. They made the bed. We built the look and the brand strategy.
The identity came from the tree it's named after, down to the bark on the box. We kept it quiet on purpose, in a category that mostly shouts. That was the team's call, after a lot of brainstorming.
I was creative director on it at ST8MNT. Parker Foote designed it, and Aaron Rayburn art-directed. The sketch sheets are Parker's, and they're here because the mark didn't arrive in one pass.






Something new forming
out of something larger.
Change the context. See where gold and coral belong.
0.7A demonstration of the design rule, using example content.
Gold marks a running node. Coral marks the selection ring. The two states can be visible together without competing.
Temperature
A label a human wrote.Something new forming out of something larger.
The writing stays distinct from the interface.0.7
A value the machine produced.Emergence is the design system that assembles to create Novensia. It's named for what it's meant to do. Give one idea a visual form. Something new forming out of something larger.
Content is what the product is for. The whole system is dark-mode-first by intent, not by user preference. Dark is what lets warm read as warm and lets the content sit above everything else.
The system came before the product. The thesis showed up before the name did, which is why the tokens are named for the idea, not the product. Novensia sits on top of it. The system underneath doesn't depend on it.
The system runs on gold and coral, and one rule governs them. Gold and coral split by context. On the node canvas, gold means running and coral means selected, so state lives on the node and interaction lives in a ring around it. Different layers, no collision. A node can be running and selected at once. Everywhere else, gold is the primary brand accent and coral is the secondary. One rule, applied two ways, holds the whole system together.
The grays carry a deliberate blue-violet bias, not neutral. That bias is what makes the warm accents read as truly hot. And gold gets used sparingly. Roughly three touches per screen, the brand mark, the primary action, the active step. Restraint is what makes it read as the accent instead of decoration.
Three typefaces, three jobs. Geist Sans for interface (labels, controls, headings). Newsreader for content (your writing samples and the drafts, and nothing else). Geist Mono for machine values (model strings, temperatures, scores, JSON).
The rule that decides between them. A label is a word a human wrote ("Temperature"). A value is data the machine produced ("0.7"). Label gets Geist. Value gets Mono. The reader knows what kind of thing they're looking at before they read a word of it.
Two weights across all three faces, regular and medium. Emphasis comes from size, color, and the step between them, never a third weight.
The system's point of view is mostly about restraint.
Gold touches about three things per screen. Two type weights, never three. Grays stay blue-violet-biased, never neutral. Red borders use a deep, desaturated red, because full-strength red on the void buzzes. It's reserved for dots, fills, and text where it carries a signal. Each of these is a limit, and they all protect the same thing. The content stays brightest, the accent stays the accent, nothing competes with what the user came to make.
The system is built from real primitives. The brand mark, the coral focus state, the gold button. Assembled from the same parts, no decoration bolted on.
