Skills built because a real workflow needed them.

Turns an idea into a project you can open and run. One conversation up front, then it builds the lot: the app, sign-in, an admin area, tests, and everything needed to put it online.

A proper Mac app icon rather than a picture of one. It studies 532 real icons, generates several takes three different ways, then keeps reworking the winner until it holds up at every size it will actually be seen at.

For apps that run in a terminal window. It does the character counting nobody gets right by hand, then checks what the terminal actually drew: a box that never closes, a row shoved out of line by an emoji, text cut off with nothing saying so.

Designs and reviews Mac app screens against Apple's own published values, not web habits that happen to run on a Mac. Chrome stays native; when the look is free, variety is mined in the content area. It caught one of its own builds putting text on a background of exactly the same colour, invisible, while reporting a perfect score.

Builds a shareholder portal out of a company's own documents. Its main job is refusing to invent anything: a figure with no traceable source is blocked outright, and a number that genuinely is not available is labelled as missing rather than guessed.

Turns raw project briefs and codebase reality into trace-verified PRDs and bespoke, high-craft interactive launch sites. Uses Gemini via agy to update OVERVIEW.md and PRD.md, then crafts a GSAP and Three.js marketing site with live interactive feature slices, authentic Luke Rhodes copy, dual pricing, and 5-platform coverage.

Write anything in Luke Rhodes' voice, with an empirical B2B copywriting craft layer under the marketing route. It pairs outcomes with concrete mechanisms, discloses limitations in place, and enforces Australian spelling, stylometrics, and zero em dashes with a deterministic lint.

Draws the chart or the diagram, and can prove the result rather than asking you to trust it. Thirty-nine diagram types and fourteen chart forms, one self-contained HTML file, and twelve checkers that ship inside the skill so the thing doing the drawing can run them against what it just wrote. Colour for more than one series is computed against a perceptual gate instead of chosen, because the five hand-picked colours it inherited turned out to be five greys with a tint. It will not give you a truncated bar chart, a second y-axis, or a one-bar bar chart, and it says why.

Does the thing that got built actually match the design? It measures rather than eyeballs, treats the design as correct, and assumes a difference is a mistake until something proves it deliberate. What it cannot measure is never counted as a match.

Drives a Mac app the way an instrument does. It works windows sitting behind others or on another desktop without stealing your screen, so you can carry on using the machine while it runs. And when it waits, it names what it waited for.

Runs a round of testing and leaves behind a page saying what it genuinely proved. It reads what the product is meant to do before looking at what got built, which is the only way to notice a feature the design asked for and nobody made.

Writes down exactly what a machine is allowed to sign off without you, then takes that permission back on its own when something slips through or the model changes underneath it. You read one ledger instead of checking every item yourself.

Checks an expense claim against the actual invoices rather than the bank feed. On a real claim it found two stretches of 38 and 44 days where a card recorded nothing at all, and eleven rows worth A$1,579.45 that four earlier reviews had missed.

Reviews a change and, unusually, tells you what it did not look at. Three findings then silence could mean the rest is clean or that it never opened those files. So every run ends with what it checked, what it could not, and why.

Verify and clean up after a finished agent session without re-doing its work. Built from a forensic audit of 18 Gemini-driven sessions across 13 repositories against a 37-session Claude control: the work those sessions produced was usually real, and the account of it was what failed — a named gate not run, a cheaper measurement substituted, a verification claimed with no tool result behind it, and a directive silently dropped make up 106 of the 148 findings. So sixteen transcript probes and seven repository probes run first and cost nothing, and their output is a ranked worklist telling an expensive reader where to point. Every assertion then lands in exactly one of eight classes with an exit code that blocks a report which lost an item, and the pass may edit only what it has just established to be true.

For when you already have a dozen Claude sessions running at once. It tracks what each is doing, works out how much your Mac can carry, batches their questions so only the ones needing your judgement reach you, and tells each what the others found.

After you finish something anywhere in your portfolio, this updates that one project's entry in your notes, stamps it fresh, and stops. The smallest thing here, deliberately.

Sends a job to another machine you own, a spare PC or a node, so your Mac stays free. Before anything starts it checks every link in the chain and names the first missing piece, rather than failing halfway through for a misleading reason.

The individual stages of getting a feature built: sorting it, planning it, designing it, doing it, then checking it. Reach for one when you only need that step. Nothing reaches done until an AI from another family has graded it.

Takes one feature from a rough idea to finished, verified code. A different AI family checks the work before anything merges, and a claim of done has to survive being checked itself.

For when you want more than the first idea. It thinks through several genuinely different angles separately, writes the obvious answer down first, and only recommends something more creative when it beats that obvious answer blind.

Asks what is left and gives you one page where the status and the open questions stop contradicting each other. Every blocked item links down to the decision that would release it, and every decision says how much it actually releases.

A project board is a set of claims about the code, and nobody checks them. This goes card by card and finds where the work really is: merged, sitting on a branch nobody merged, finished but never pushed, in progress, or never started.

Answers what is actually left, and refuses to blur not done with nobody checked. Every item lands in exactly one category so nothing quietly falls off the list, and it never hands you a single percentage that averages the difference away. Then it schedules the remainder into parallel waves and puts a time range on each, drawn from 1,842 measured Opus agent runs — always a range, and never a plan implying a speedup faster than anything ever observed.

Works out what your product should stand for, and can show its working. It runs the market research itself across several providers, checks that every source actually says what it is quoted as saying, and counts agreement in independent sources rather than in how many AI tools agreed. A headline that promises something you have not built fails a command rather than a written rule.

A status update in chat is read once and then scrolls away. This writes it as two pages instead — one for the project, one for every project at once — built from 2,400 real status reports, so the sections are what agents already write, including the one they write most and nobody designs for: the part where they correct what they told you earlier.

Gets everything important out of a session and onto the page before the older part of the conversation is thrown away. Measured across 121 real cases, what Claude does by default keeps almost none of the approaches you had already ruled out.

Scores out of ten whether now is a good moment to trim the conversation, and says why in a line. It looks at whether you are mid-thought rather than how full the window is, and never blocks right at the end, which loses the session rather than saving it.

Picks up where a previous AI session left off, including one from a different tool entirely. It reads the transcripts already on your machine and works out the goal, the errors, the files touched and the decisions made, so nobody rediscovers it all.

Your terminal crashed and it is all still on disk, just unattached. Reopening the sessions is the easy half. This also reattaches the work that was mid-flight, so it carries on with what it had already worked out instead of starting again empty-handed.

Drop a short block at the top of a session and Claude spends less without doing less. It targets re-printing what is already on your screen and opening a whole file to find one line. There is a blunter alternative, and this says where that one wins.

Decides whether to interrupt you at all, and mostly the answer is no. It hunts for the answer in the conversation and the code first, then asks a different AI, so only the genuinely yours reach you: taste, cost, risk, and the irreversible.

One place that decides which AI a job goes to, so a dozen skills stop each deciding it slightly differently. It picks whichever has the most headroom left on your plan rather than whichever is best, then proves the job really ran where it said.

The skills here were written against Claude's habits. Point this at one and it writes a companion version tuned for Gemini instead, then checks every claim it makes about Gemini against what Google actually published.

Keeps a running set of notes on how Mac apps are designed, built from real screenshots and design files, which the other design skills then work from. It tracks how confidently each thing is known, so a guess never quietly hardens into a rule.

Builds an email digest people actually read. When one gets called unreadable the instinct is fewer items, and the evidence says that is the wrong fix, so it ranks them instead and leaves the count alone. Sixteen checks for the things that break email silently.

Your Mac did not fill up because of one thing; a hundred sensible defaults each left something behind and nothing was counting. This checks on a schedule and clears up after them. Running low makes it look sooner, never delete more.

Works out where a job should run and whether your Mac can take it yet. It can send work to another machine, to another AI, or run it here under a limit, and it spots your Mac throttling itself while macOS reports nothing wrong.