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.
Three tiers, ten skills, rendered in this site's own design tokens. Flip the Classic / Expressive / Editorial toggle and the diagram re-themes itself.
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.
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.
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.
Each kind of judgment in its own lane. That separation is itself a judgment.
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.
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.
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.
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.
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.
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.