Built with Claude

Design Judgment, Installed

RoleDesigner and builder
Built withClaude Code
Output10 public Claude skills
Year2026

The execution got easy. The judgment didn't.

I built these skills out of my own experience building with Claude, and this case study is me sharing that journey. It's also a showcase of the skills themselves, because I used them to make it.

It started with something uncomfortable. I'd already written this work out on an earlier portfolio, and I was porting it over to this site with Claude Code when I noticed the execution had gotten easy and the judgment hadn't. Claude could move a section across clean in seconds, but it couldn't tell me which sections to cut, which story to lead with, or when a polished diagram had quietly deleted the evidence. That's when I stopped using Claude only to build faster and started encoding the part it kept getting wrong: my judgment. The result is a suite of ten Claude skills, public on GitHub, built while I worked on this site. This page is the one case study I handed to them end to end, to see what they could do.

A skill is a folder of instructions Claude loads when a task calls for it. Most skills automate execution. I was more interested in the opposite: the taste calls. What to cut. When something is done. What good looks like for the situation in front of me. Those got more valuable, not less, once anyone could ship a clean site.

A ten-skill design practice, encoded Three tiers: while building (build journal, prompt retro, handoff spec), the publish path (writer, edit pass, critique, preflight), and foundations (voice and writing guardrails under all prose, visual storytelling under all visuals). The build journal feeds both the retro loop and the publish path. WHILE BUILDING Build journal captures the build Prompt retro sharpens the next one Handoff spec the states devs need ↻ feeds the next build PUBLISH Writer Edit pass Critique Preflight FOUNDATIONS Voice under all prose Writing guardrails no AI tells Visual storytelling under all visuals Every build documents itself into the next one.

Three tiers, ten skills, rendered in this site's own design tokens. Flip the Classic / Expressive / Editorial toggle and the diagram re-themes itself.

build-journalprompt-retrocase-study-writervoicewriting-guardrailsvisual-storytellingportfolio-edit-passportfolio-critiquesite-preflighthandoff-spec

I designed the judgment. Claude did the typing.

I conceived the suite, defined what judgment each skill encodes, and made every call about how they behave. Claude wrote the skill files, packaged them, and pushed the repo under my direction. The interesting work was never the code. It was deciding which of my standards were worth writing down precisely enough that an agent could apply them, then defending those standards when the easy path argued against them.

The gap was the asset.

Early on I almost threw away the best material I had. I'd kept logs from past builds, and I dismissed them:

"I didn't keep the actual prompts. I kept all the different things we had to try to get it to work, so not as useful."

Then it flipped. The struggle log, the tried-this, it-failed, adjusted record, is the judgment narrative. The prompts are just evidence; the struggle is the story. That reframe shaped two skills: a build-journal that ranks failures as the highest-value thing to capture, and a case-study writer that treats the attempts log as its spine. The thing I'd written off as a gap was the asset.

Separating the editor from the critic.

The instinct is to make one skill that both cuts and grades. I split them, because a skill doing both gets too busy being fair to be ruthless.

Editor
Biased to cut
Removes unneeded screens and sections. Forbidden to grade, so its cut recommendations never go soft.
vs
Critic
Grades and decides
Scores the work and renders a ship verdict: blockers versus nice-to-haves.

Each kind of judgment in its own lane. That separation is itself a judgment.

The verdict that survived me.

The critic ends with a ship verdict: blockers versus nice-to-haves, with an explicit "apply now" the moment the blockers clear. I built it because I have a known failure mode, which I'd said out loud while specifying the skill:

"whether it feels like it's in a good enough spot to apply, because I could work on it forever."

Then I tried to delete it:

"That sounds like a downside, so maybe we should take out the good-enough check?"

The mechanism I'd built to fight my perfectionism was being argued away by my perfectionism. I kept it. Designing against your own worst habit only works if you don't let the habit veto the design.

The screenshots are the proof.

On a different case study, Claude turned my messy research artifact into a tidy flowchart of labeled cards. It looked more polished. It was worse, and I told it why:

"My original FigJam was communicating: 'Holy crap, this experience is fragmented.' This version communicates: 'Here's a flow chart.' Those are not the same thing."

The polish had deleted the evidence. That correction became a skill, visual-storytelling, with one rule at its center: render the actual shape of the information, and never flatten real evidence into a grid of cards. It is voice, but for visuals.

Teaching it my voice, from real evidence.

The writing had to sound like me, not like a model, so I refused to let it guess. I gave it the evidence: a communication style guide I'd built from my real Slack messages, plus my published portfolio writing, so the profile was grounded in how I actually sound across registers instead of an average of how anyone writes. Even then, the first cut over-indexed on my chat habits. A blind test settled it: two short paragraphs on a neutral topic, one in the calibrated voice and one generic, and I picked the composed version of my own writing over the loose one. So the rule became my own language at my own temperature, with the lowercase-and-ellipses chat quirks kept to Slack and out of anything I publish. The profile carries a dated calibration history, so it gets a little more like me every time I correct it. Every skill that produces prose now writes through it, including the words I'd never use.

A skill that encodes judgment is never done at version one.

The voice profile was wrong the first time, and the thing that saved it was a way to learn from being wrong, not a longer list of rules. I built the same humility into the others: the retro skill watches for me over-steering, because senior people tend to over-specify, and it refuses to blame me for failures that were just the tool misreading an instruction. The judgment isn't the rules. It's the loop that keeps correcting them.

Ten skills, running as a system.

The suite is public at github.com/tjrice42/design-judgment-skills, and it runs as a system: the journal captures the build, the retro sharpens how I prompt, the writer drafts the case study, the editor cuts, the critic grades, and preflight checks the live site before I share it. They compound. The journal captures each build as it happens, which is how I had the raw material for this page. I didn't set out to build a suite. I kept noticing pieces of my practice worth encoding, and ten skills later I work through them as a system.

Tools lowered the floor, not the ceiling.

Anyone can ship a clean site now. Knowing what to cut, what story to tell, and when to stop is the part that didn't get cheaper, and it's the part worth showing. Building this way also did something I didn't expect: after years inside a company's design language, this is the first work where my own taste is the system. The skills are just that taste, written down precisely enough to hand to a machine.

Next
Agentforce for Setup →
Designing an AI agent that lets Salesforce admins configure complex systems by talking to it, built around trust and control.