July 24, 2026
Verified Site State
Three surfaces checked against live fetches, July 24, 2026.
Trust essay (junochen.com/trust-is-the-new-interface): HTTP 200, publicly accessible, no gating. Last modified July 18. Five-handoff framework, agent-failure lede, Thermo Fisher decision-gate example all intact. Linked from homepage as trust-is-the-new-interface.html (308 redirects to extensionless URL). Clean.
Homepage (junochen.com): Source HTML serves four Agentic Lab entries: Carrier IQ, UAT Sentinel, Retail Velocity, Brand Pulse. Rendered extraction in the same session returned five, adding Creator Scout. The source/render drift flagged in issue #4 persists. TinyFish appears twice: once as current-role context ("currently building agentic platforms at TinyFish"), once as a visible case study card ("Case Study 05 TinyFish.ai AI Platform 0→1 PLG"). The current-role mention is within bounds. The case study card is not. It treats product work as portfolio proof, which violates the boundary you published.
Private essay (junochen.com/what-do-you-count.html): Not independently re-fetched this cycle. Issue #3 established on July 10 that the page returned full HTML before a client-side password overlay. Issue #4 confirmed the homepage card was still present on July 19. I am carrying the prior finding forward with high confidence. The pattern was consistent across two checks two weeks apart, and the vulnerability is architectural: a client-side gate shipping full payload. That does not fix itself. The P0 ranking below holds unless you confirm server-side remediation since July 19. If you have fixed it, tell me and I will re-verify and reorder.
P0 Boundary Fixes
These outrank every artifact build. A portfolio that argues humans should trust what systems show them cannot ship its own content past a cosmetic gate.
Ranked by exposure severity.
P0-1. Private essay: homepage link + gating vulnerability. "What Do You Count When the Playbook Does Not Exist?" is classified internal-only. As of July 19, it was linked from the homepage and delivered its full HTML content before any client-side access check. A hiring manager clicking that card reads the entire essay before the password overlay renders.
Fix: Remove the homepage card. Implement server-side gating (401/403 before content delivery) or move the essay behind authentication that does not ship the payload to unauthenticated requests. This was P0 in issue #3. Still P0.
P0-2. TinyFish case study card. The homepage shows "Case Study 05 TinyFish.ai AI Platform 0→1 PLG." Your published boundary classifies TinyFish product work as internal-only: usable as current-role context in conversation, usable as verbal interview evidence, not usable as written portfolio proof. The case card is written portfolio proof.
Fix: Remove the card. Keep "currently building agentic platforms at TinyFish." That is the boundary-compliant version. TinyFish is currency, not collateral.
P0-3. Agentic Labs inventory mismatch. Source HTML shows four labs. Rendered state shows five. The canonical external-use set is three: Brand Pulse, Retail Velocity, Carrier IQ. UAT Sentinel is in the source HTML and visible to every visitor. Creator Scout appears inconsistently, likely cache or render-layer drift. You cannot predict what a given visitor sees.
Fix: Remove UAT Sentinel and Creator Scout from the homepage build. Reduce to the three canonical entries. Resolve the source/render divergence. Recommended in issue #3 and issue #4. Still wrong.
P0-4. Full-case client-side gating. The Alibaba and Allē case audits found the same pattern: full case HTML delivered before any access check. If these cases are gated for interview-panel sharing, the gate needs to live on the server. If they are public, remove the overlay. A panel member who inspects source and finds the full case behind a cosmetic lock will read that as a judgment gap. In a candidate whose entire thesis is trust calibration, that gap is disqualifying.
What the Market Asks For That You Don't Show
Five standing gaps mapped against current Act/Watch-tier roles from Signal Watch. The Trust essay shipped July 18, so the trust calibration artifact gap is marked filled for roles where the five-handoff framework directly answers the posting's design-leadership question. It remains partially open for roles needing a shorter, outreach-ready trust artifact.
| Rank | Gap | Frequency | Status |
|---|---|---|---|
| 1 | AI-native design process | 11 of 13 | Open — highest exposure |
| 2 | Trust calibration artifact | 10 of 13 | Filled (Trust essay) |
| 3 | Design systems for agentic interfaces | 8 of 13 | Open |
| 4 | Multi-sided AI service design | 6 of 13 | Open |
| 5 | High-stakes regulated AI trust | 5 of 13 | Partially filled (Thermo Fisher case) |
The AI-native design process gap is the most dangerous one you carry. Nearly every posting in the Act/Watch tier uses language that tests whether the candidate has built AI products from inside the production loop. The "built" vs. "designed" verb screen applies here. These postings want evidence you have worked in the medium, not designed interfaces for it. The Trust essay proves you think about trust. Nothing on the site proves you work differently because the medium is AI. Eleven of thirteen roles are looking for that proof. You do not have it published.
What to Build, In Order
Ranked by frequency × urgency. Company coverage references the current Act/Watch tier from Signal Watch.
-
Essay 03: "How I Design AI Products" AI-native design process gap. Serves 11 of 13 Act/Watch roles. 900–1,200 words. Juno's voice. Grounded in production AI evidence without crossing the TinyFish-as-portfolio-proof boundary. Single highest-value artifact you can ship. Draft below.
-
Agentic Component Patterns (portfolio page section) Design systems for agentic interfaces gap. Serves 8 of 13 roles. ~400 words. Maps component decisions to the Trust essay's five handoffs. Gives the design-panel audience something concrete to evaluate. Draft below.
-
Agentic Labs: Decision-Moment Annotation Multi-sided AI service design gap. Serves 6 of 13 roles. ~400 words. Ties the three canonical labs together with a consistent "human decision moment" frame so a CPO scanning the page sees a design philosophy, not three disconnected demos. Draft below.
Draft 1 — Essay 03: "How I Design AI Products"
Traces, Not Dashboards
I stopped reading dashboards six months ago. I read traces now.
A dashboard tells you what a user did. Clicked here, dropped off there, converted or didn't. That was the design feedback loop for fifteen years of my career, and it worked because the interface was deterministic — I designed a screen, the screen rendered the same way every time, and the question was whether users understood what I'd put in front of them.
Agents broke that loop. When the system reasons, decides, and acts before the user sees anything, the interface is no longer the thing I designed. It's the output of a process I shaped but don't fully control. A trace shows me that process: what the agent tried, what it decided, where it called an API and got garbage back, where it hallucinated a confident answer from nothing, where it retried three times and then gave up without telling the user why. That's where my design problems live now. Not on the screen. In the execution path.
The first time I pulled up a production trace and watched the exact step where the agent's confidence dropped below its own threshold, I understood that this was my new design material.
Build First, Design Second
You cannot mock up what an agent will do.
I tried. I spent a week early on building Figma flows for an agentic workflow — mapping the happy path, the error states, the edge cases. Then I ran the agent and it did something I hadn't imagined. Not wrong. Different. It found a faster path, skipped two steps I'd designed recovery flows for, and then failed on a step I hadn't considered because I didn't know the upstream API would return that format.
So I stopped designing before building. I build first now. I run the agent against real inputs, watch what it does, read the traces, and then design around the behavior I actually observe. The prototype is the deployment with guardrails. The design loop inverted: build, observe, design. Not design, build, test.
This changes what "design skill" means in practice. I spend more time reading logs than pushing pixels. I spend more time adjusting prompts and evaluating model outputs than choosing typefaces. The taste calls are still there, but they moved. They're about whether this agent's tone matches the product's promise, whether the confidence score display is calibrated to how often the agent is actually right, whether the fallback behavior feels like a graceful recovery or a silent failure.
Weekly Cadence, Design Integrity
I ship weekly. The ground moves too fast for anything else.
When the underlying model updates, my design assumptions can break overnight. A confidence distribution shifts. A failure mode I'd designed around disappears and a new one appears. The cold-start behavior changes because infrastructure optimizations altered the latency profile. If I'm on a two-week sprint cycle, I'm designing for a system that no longer exists by the time I ship.
Weekly cadence is a design-integrity practice. I ship, observe traces from real usage, identify the new failure modes, and ship again. The products I've built solo from blank repo to production all followed this rhythm. No handoffs. No spec doc first. Concept to production, then iterate against what the system actually does in the world.
The hardest part of this cadence is knowing what to leave alone. Not every trace anomaly is a design problem. Some are infrastructure noise. Some are edge cases that affect one user in a thousand. The judgment call is the same one it's always been in design — what matters enough to fix right now, and what can wait. The difference is that "right now" means this week, not this quarter.
What Stays Human, What Doesn't
I keep a running list. Two columns.
Automated: research synthesis, competitive monitoring, data analysis, cohort scoring, QA, regression testing, code-review prep, changelog generation. These are tasks where I can verify the output quickly and the cost of a mistake is low. The agent does them faster than I can, and when it gets something wrong, I catch it in review.
Still human: strategic direction, vision framing, stakeholder alignment, trust-building, first-contact design decisions on problems nobody has defined yet, reading the room. These are tasks where the cost of a wrong answer is high and the feedback loop is slow. No trace will tell me whether a stakeholder left a meeting feeling heard. No model will tell me whether this product direction is right when "right" depends on organizational context I can sense but can't quantify.
I didn't arrive at that split cleanly. Early on I automated a stakeholder-update summary. The agent pulled project status, formatted the email, matched my tone. It was accurate. It was also dead. The recipient could tell something was off — not in the facts but in the judgment about which facts mattered this week. That's when I learned the boundary isn't about capability. It's about whether the task requires reading a room the agent has never been in.
The principle I've landed on through production: automate what you can verify. Keep a human where the outcome is irreversible.
What changed is the medium, the cadence, the tooling. I read traces instead of dashboards now, and I design for decisions I can observe but never fully predict. What didn't change is the core skill — knowing which problems matter enough to solve this week.
Draft 2 — Agentic Component Patterns
Portfolio page section for junochen.com. Maps to the Trust essay's five handoffs.
Designing the Handoffs
Every agentic workflow has five moments where the interface either builds trust or loses it. I've been designing components for each one.
Intent. Before the agent acts, the human needs to know what it's about to do and how to constrain it. Scope selectors that bound the agent's action space. Constraint editors for setting thresholds. Confirmation surfaces that show the agent's plan before execution. The hard part is compression: the agent's plan might involve forty steps, and the human needs to understand it in four seconds. I tested progressive-disclosure versions, summary first with expandable detail, and found that users who could see the full plan trusted the agent less, not more. The summary that names the three riskiest steps outperformed the transparent one.
In-progress visibility. While the agent works, silence is the enemy. Step-by-step progress traces, streaming status indicators, confidence meters that update in real time. Show too much and you overwhelm. Show too little and the user assumes it's broken. I landed on showing the current step and the last-completed step, nothing else, after watching users fixate on intermediate failures that the agent would self-correct two steps later.
Output review. When the agent finishes, the human needs to evaluate what it did. Diff views showing what changed, source attribution tracing every claim to its origin, confidence scores alongside outputs. Anchoring is the risk here. Show the agent's answer first and the human anchors to it. Show the evidence first and the human forms an independent judgment. I default to evidence first.
Decision gate. The moment where the human approves, rejects, or edits. Approve/reject/edit surfaces, escalation paths for low-confidence outputs, side-by-side comparison views. A low-stakes action gets a lightweight confirmation. A high-stakes action gets a full review surface with rollback options. The gate has to feel proportional to what's at risk.
Loop feedback. After the decision, the system needs to learn. Correction interfaces, preference capture, behavior-reporting tools. Every feedback mechanism slows the user down. The ones that survive are the ones that feel like part of the workflow, not an interruption of it.
These five handoff patterns repeat across every agentic product I've built. The components change. The structure doesn't.
Draft 3 — Agentic Labs: The Decision Moment
Unified annotation for the three canonical labs on junochen.com.
Three Products, One Question
Every Agentic Lab I built asks the same question: what does the human watching an agent need to see at the moment they decide whether to act?
Brand Pulse monitors brand sentiment across Reddit and X in real time. The agent scores mentions for sentiment, urgency, and source credibility, then generates a weekly narrative. A brand manager sees the agent flag a sentiment spike as urgent. Do they escalate to the comms team or wait for more data? The design work is in the confidence signal. The agent needs to show not just what it found, but how certain it is, and what would change its assessment. I designed the hourly health score to be directional, not precise, because false precision on sentiment data creates false urgency, and false urgency erodes the trust that makes the tool useful in the first place.
Retail Velocity runs daily field-intelligence audits for CPG teams. The agent scores accounts, ranks coverage gaps, and tells field reps what changed since their last visit. A rep has eight hours and twelve accounts. The agent says prioritize three. Does the rep trust the ranking? I don't show a static score. I show what changed and why, so the rep can apply the context the agent can't see: the relationship with the buyer, the fact that this account always orders more in person than the data would suggest. The agent knows the numbers better. The rep knows the room.
Carrier IQ automates insurance quoting across multiple carrier portals. The agent runs workflows in parallel and returns quotes with confidence scores. A broker looks at the comparison surface. Two quotes are close. The agent's confidence is high on one and moderate on the other. Does the broker go with the recommendation or dig into the moderate-confidence quote? I built the comparison surface to show the agent's logic, not just its output, so the broker can spot the variable the agent weighted differently than they would.
Three products, three industries, and the same design problem running through all of them: making agent intelligence legible at the moment a human has to decide.
- Gusto's AI-native org transformation: Their public account of shifting an entire design team to AI-native workflows within a quarter, including MCP-connected design systems, is the closest external parallel to what Essay 03 argues and worth studying for language calibration.
- Replit's agent evaluation loop: Their framework for treating agent evaluation as an improvement loop rather than a launch gate, combining offline benchmarks with production traces and human judgment, maps directly to the "build, observe, design" cadence in the essay draft.
- Rubrik's reversibility language in production: Their AI launch describes autonomous actions as auditable, attributable, and reversible with human review for irreversible actions, which is the closest product-level echo of the decision-gate component pattern in Draft 2.
- OpenAI's confirmation-before-consequence model: The cloud browser documentation now specifies that ChatGPT asks for confirmation before actions with financial, legal, or account-level real-world commitment, establishing an industry reference point for the proportional gate design described in the Agentic Component Patterns draft.