My AI Skills

Fixing the same things… again and again

Eight plugins, 34 skills

Each one does a single job and gives it a check. Where the check can be a script, it’s a script.

Mimesis, for writing:

Helps humanise AI writing. It’s still obvious if you know what to look for, but it helps produce better copy always, so I still use it. Could always use some improvement as AI gets better, though.

It does this by using a list of AI tells (65 words, 18 phrases, 7 hedges, plus patterns like “it isn’t X, it’s Y”).

Kanso, for code:

Keeps code short and honest. No unnecessary and repetitive comments, no unneeded helpers, and so on.

Based on the Japanese idea of 簡素 (kanso), the elimination of clutter. It deletes before it adds, and nothing gets written until you’ve seen the plan. Tidy tidy tidy.

One rule: prefer deletion over addition.

def get_user(user_id):
    # Fetch user by ID
    try:
        result = db.query(User).filter(User.id == user_id).first()
        if result is not None:
            return result
        else:
            return None
    except Exception as e:
        return None

def get_user(user_id):
    # Fetch user by ID
    try:
        result = db.query(User).filter(User.id == user_id).first()
        if result is not None:
            return result
        else:
            return None
    except Exception as e:
        return None

def get_user(user_id):
    try:
        result = db.query(User).filter(User.id == user_id).first()
        if result is not None:
            return result
        else:
            return None
    except Exception as e:
        return None

def get_user(user_id):
    result = db.query(User).filter(User.id == user_id).first()
    if result is not None:
        return result
    else:
        return None
    return None

def get_user(user_id):
    result = db.query(User).filter(User.id == user_id).first()
    if result is not None:
        return result
    return None
    return result

def get_user(user_id):
    result = db.query(User).filter(User.id == user_id).first()
    return result
    return db.query(User).filter(User.id == user_id).first()

def get_user(user_id):
    return db.query(User).filter(User.id == user_id).first()

Flow, for interfaces:

One pass that tidies a UI: layout, type, colour, controls, accessibility, copy, and motion.

Contrast and design tokens come from scripts. Specialist skills cover motion and accessibility.

Swarm, for parallel agents:

Treats parallel agents as a cost, not a reflex. It adapts to whatever the tool supports, down to running jobs one by one.

One agent at a time by default. It only fans out when the merge is cheaper than the work. Up to 5 agents run freely, with room for more.

Fanning a task out to a dozen agents feels powerful, but most of the time it just burns tokens. Swarm only spreads out when it’s worthwhile.

Delight, for delight:

Delight handles feel. Feedback, celebrations, and progress feel good.

Checks each moment through trigger, state change, feedback, repeat. Based on Duolingo’s published experiments.

Yum, for taste (without using that nasty buzz word):

Finds design references, compares them, and adapts them to your project. Based on a growing library of references. Based on galleries like Mobbin, Refero, Godly, Dribbble, On, and more.

Perpetuity, like Hermes:

Functions just like Hermes agent, but for all agents. Helps prevent mistakes. Simple as that, a self learning approach with one goal: don’t do it again.

Litmus, for testing:

Does some very useful QA orchestration. Tests what matters and reports only what is supported by evidence. An illustration:

test("quantity survives a reload", async ({ page }) => {
  await page.getByRole("button", { name: "Add one" }).click();
  await page.reload();
  await expect(cartCount).toHaveText("2");
  await expect(cartCount).toBeVisible();
});

The skills police their own docs too: every push to main runs the prose linter over the library’s READMEs.