Design Exploration
OpenProse × JHDesign · 2026
OpenProse is a way to author outcomes. The approach is to contract the LLM rather than merely prompt it, using OpenProse structuring to define: requirements, maintenance, and strategies. Agents run, maintain, and review it on cadence.
In April 2026, Dan, the CEO of the newly funded OpenProse, hired JHDesign for a founding design project with two tracks of exploration: the brand, and the design of solutions for visualizing trace data from the RLM product.
The trace track is still confidential. This page is the brand and web-craft journey.
Upfront please understand that the exact copy for most of this work is intentionally left as LLM-ese; it stands in for lorem ipsum as a placeholder with a twist.
// json-verifier.prose.md · a whole service, one page name: json-verifier kind: service Description Validates generated JSON before a downstream system consumes it. Requires - `candidate_json`: JSON text to validate Ensures - `validation_report`: whether the JSON is valid, with parse errors and line references when validation fails Tools - `cli:jq`: JSON CLI available on PATH Strategies - when JSON validation fails, report the parse error and location without rewriting the input
Communicating quality and stability with useful elegance in a growing sea of noise.
Combining the best of declarative approaches, like SQL, with the reasoning power of LLMs. Describe the outcome, set the contract, let it run and self-correct.
AI power users, investors, CTOs, senior engineers.
No hype. Show the work: real outputs, real numbers. Technical depth when asked, accessible by default. Confident with receipts.
Reviewing dozens of live website experiments needs more than a folder. So I have made a simple 'canvas' for generative web design: the JHDesign Review Canvas. The Review Canvas shows the content of a repo as one navigable page with three view modes (canvas, grid, focus), where every page is a live iframe with star ratings, typed comments, and freehand drawings composited onto screenshots. Review state lives in git; each reviewer writes only their own file, so feedback merges without conflict. The Review Canvas just needs a Github repo to make it collaborative. No extra overhead, no extra accounts or permissions to set up, and no intermediary steps to get the comments back into production.
I've been a designer for about 10 solid years now; from Adobe XD to Figma. Being real with you, I've been there and I don't want to go back. As agentic engineering offers new potentials, I find myself recalling… For so long we designers have been adding abstractions of different apps and tools just to simulate code, now why not just use the code and standards directly? Thus the webpage that is a canvas that shows iframes.
Drawn annotations over the live page become typed work items, each with a stable id like c_1c28d078.
Claimed by an agent under a two-lock protocol (a file reservation plus a comment claim), so parallel sessions never collide.
Closed with a commit SHA attached. Every fix is traceable back to the sentence that asked for it.
Returned to the canvas as a closed chip. The designer sees the loop complete where it started.
// .agents/prose/src/review-state-stays-coherent.prose.md name: review-state-stays-coherent kind: responsibility Criteria · `agent-close.mjs --audit-all` must read OPEN=0 for each closed round Constraints · never close a comment to make the audit green — a clean audit is the result of coherent state, not the goal to be gamed
This system was essential in managing the large surface area of this project across two tracks. Instead of staying linear in code chat I could spread out and review whole swaths of work, specify changes, then just have the agent read the latest manifest and get to work in parallel plans.
The supporting tooling for the Canvas even runs on OpenProse itself: the canvas's integrity is a written responsibility an agent keeps, audited by script and attested with commit SHAs, and the design system is indexed by a runnable OpenProse program.
I'll be developing this tooling further and consider if it's a product of its own, or just my secret sauce for now.
Every exhibit grid on this page is a stripped-down version of the review canvas; the full canvas runs in III Breadth below.
Create on-demand live tuner panels for dialing in elements of the pages. For example, a set of controls was used to dial in the hero's reflection: seven registration parameters as sliders over the real shader. The values were baked into source and the tuner retired off the page into markdown, ready to re-use if needed.
A drawing on the canvas becomes a typed work item with a stable id. It is claimed, fixed, closed with a commit SHA, and returns as a chip. The same notes ride the exhibit cards under the ✎ toggle.
Sessions claim work under a file reservation plus a comment claim. Both locks must agree before an edit lands, so parallel agents never write over each other.
Two months of parallel explorations looking for the best surface area. Every approach is a working page. The 72 direction-* pages cover 19 distinct directions — the biggest being delta/machine (11 variants), mu/bloom (9), beta/tufte-mono (9), eta/organism (7), and lambda/inkwell (5).
Round-one stars and comments were compiled into a written document, BRAND-PRINCIPLES.md: seven invariants, five named rejects. A calibration signal to work from.
The top of the ratings shared a look: warm serif editorial. By 2026 that look was everywhere. Serif fonts were undergoing their vibe-coded assault, the default dress of generated landing pages. OpenProse needed its own style.
Turning to legibility and tradition, I explored monospace families. However, the appearance can become monotonous. Then at just the right moment of scrolling TwXtter I see Kecal for the accents. Kecal is an open typeface (OFL) by FungiType: Rodrigo Fuenzalida, Jordan Egstad, and Jiří Krblich. Used with thanks. Monotypes and Kecal became a way to rise above the noise and contribute to legibility: clearly readable, quietly esoteric, a face no generator reaches for.
In parallel the voice settled: monospace families for the running text, Tufte density for the register, Kecal, upright, as the one accent. The system consolidated into _tokens.css, _pairings.css, _styleguide.js; the permutation sheet keeps every pairing.
To differentiate the brand of OpenProse from pure vibe-coded competitors, I returned to my roots: drawing by hand, then rebuilding in vector. Now with a modern twist: I used Arrow, an SVG-generating LLM from QuiverAI, to help fill in details and explore alternates.
Five families emerged and one seemed to call out more than the others. The logo family called Style was forwarded as a candidate for canonical mark. Pick one below to see it at size.
The living specimen · pick a family above, or click the mark to cycle infinite → style → circle → swish → cursive.
The field of studies the five families were distilled from, clustered by idea. Click to expand.
Aiming to become more interactive: a surface that responds.
I went in a handful of directions, different metaphors. Cellular automata were interesting; then, as I made UI to mess with the parameters, I found settings that evoked ripples and water.
While I was working on this project over the two months, I went on a quick vacation to La Paz, where I swam with a Whale Shark for the first time. As a palette cleanser, with the power of Arrow letting me generate clean SVGs from images plus some manual touchups, the little Whale Shark was born, combined with him eating the cellular automata.
From there I went into trying black hole motifs: pure vibe-coded 2D versions alongside a port of vlwkaos/threejs-blackhole.
A fun idea, but ultimately just a moment of creative madness that helped me transition back into refining the cellular automata style.
The automata were alive but abstract, and thus also possible for others to generate. The search for unique texture led back to my oldest medium, photography, and one motif held through the search: the bloom and its ripples.
The Sierra Nevada series.
I started by simply putting photographs in place of whitespace, but it became clear that I had to try combining the interactive elements with photography, something I have found myself doing as an artist, here in its most advanced form.
A series of my favorite Sierra Nevada lake scenes, shot in 2011.
Keep the photograph. Replace the sky and the water with shaders: real mountain, procedural dawn clouds, simulated ripples.
The mask was finalized by hand. Aligning the digital reflection with the real one used a live tuner, later retired into markdown.
I wanted to make something that would stand out from the increasingly crowded field of design in the generative age.
The real photograph hangs printed above my monitor, its ripples frozen except in memory; on the monitor below, they move.
A reminder of how far technology has come; of all that will change, and all that will stay the same.
// reflection registration · dialed by hand, then baked (_reflection-tuner.md) axis 0.505 shorten 1.012 shiftX 0.000 scaleX 0.990 tilt −0.004 axisTilt −0.009 keystone 0.000 // cloud-clear brush · 96² persistent mask · radius 0.13 · strength 0.55 · 7s return
The thirty-seven core approaches, five families, and a chain of heroes distill into the canonical set: the homepage concept, the permutation sheet, and the styleguide that pins the defaults, with the aspect catalog beside them showing the different aspects of this style landscape.
The catalog is a way to explore alternatives and play with the best feeling. The 'canonical' style and page represent crystallizations of the possibilities into some ideal candidates.
The canvas below is a subset: 37 of the core aesthetics that stuck around the longest and seem like an interesting ground to base further work from.
Branding, design, engineering, and tooling in one engagement. Founding design where agentic tools meet the handcrafted.
npx skills add openprose/prose