Skip to content
Back to search

skills

Eight personal agent skills for now: Caveman base, Interface Kit, Grill Me, Loop Factory, Junior to Senior, Deslopify, Context Canary, and The Last 20%.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/juliusbrussee/skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/juliusbrussee/skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/juliusbrussee-skills/badge.svg)](/listings/juliusbrussee-skills)

HTML

<a href="/listings/juliusbrussee-skills"><img src="/api/listings/juliusbrussee-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Install with `skills.sh`:

npx skills@latest add JuliusBrussee/skills

Pick the skills you want for Claude Code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, or any agent supported by the installer.

For the canonical Caveman installer, use:

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 198 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="assets/banner.svg" alt="Julius Brussee — Software Engineer. Building tools that respect your time." width="100%">
  3. </p>
  4. # Julius Skills
  5. Eight personal agent skills for now: Caveman base, Interface Kit, Grill Me, Loop Factory, Junior to Senior, Deslopify, Context Canary, and The Last 20%.
  6. This repo is shaped by eight things:
  7. - **Caveman** - 70k-star token compression without technical loss. Small mouth, big brain.
  8. - **Interface Kit** - accessible, performant interfaces with strong aesthetic direction, not generic AI slop.
  9. - **Grill Me** - calibrated pressure before hard critique, so challenge matches user knowledge and comfort.
  10. - **Loop Factory** - spec-driven agent loop where tasks move through inbox → active → archive with a real review gate.
  11. - **Junior to Senior** - adversarial senior review that treats agent output as junior work and upgrades it with codebase + web research.
  12. - **Deslopify** - mechanical scan-and-rewrite loop that erases AI-writing tells from any text and lands it in the right register.
  13. - **Context Canary** - per-turn canary signal that makes silent context degradation visible, plus a recovery protocol when it trips.
  14. - **The Last 20%** - finds and finishes the experiential layer agents skip: what the output reads like, which pages exist, first-run, defaults, the golden path.
  15. Point is control. Agents should be terse when talking, precise when building interfaces, calibrated when challenging plans, and disciplined when running build loops.
  16. ## Quickstart
  17. Install with `skills.sh`:
  18. ```bash
  19. npx skills@latest add JuliusBrussee/skills
  20. ```
  21. Pick the skills you want for Claude Code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, or any agent supported by the installer.
  22. For the canonical Caveman installer, use:
  23. ```bash
  24. curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash
  25. ```
  26. ## Why These Skills Exist
  27. Most agent output fails in three boring ways: too many words, UI that looks like every other generated demo, or critique that starts too hard before understanding user context.
  28. This repo keeps three fixes close:
  29. 1. **Speak less, say more.** Caveman cuts output tokens while preserving exact commands, code, errors, and technical meaning.
  30. 2. **Build interfaces with taste.** Interface Kit starts from accessibility, performance, typography, spatial rhythm, color roles, and concrete interaction states.
  31. 3. **Challenge at the right altitude.** Grill Me assesses knowledge and desired pressure first, then asks one question at a time.
  32. ## Skills
  33. ### `caveman`
  34. Ultra-compressed communication mode. Cuts token usage by dropping filler, hedging, pleasantries, and excess grammar while keeping technical accuracy intact.
  35. Use when you want:
  36. - shorter agent replies
  37. - less token waste
  38. - exact code, command, error, and API preservation
  39. - persistent terse style until user exits with "normal mode"
  40. ### `interface-kit`
  41. Implementation guide for high-quality UI. Synthesizes accessibility, performance, typography, layout, color systems, motion, interaction states, and component craft.
  42. Use when building:
  43. - frontend components
  44. - landing pages
  45. - dashboards
  46. - design systems
  47. - polished app flows
  48. - accessibility fixes
  49. - UI review passes
  50. ### `grill-me`
  51. Calibrated interview skill for stress-testing plans, designs, and decisions. It first asks how much the user knows and how hard they want the pressure, then ramps from clarifying questions to failure-mode critique.
  52. Use when you want:
  53. - plan critique without getting overwhelmed
  54. - one question at a time
  55. - recommended answers with each question
  56. - pressure matched to beginner, working, or expert knowledge
  57. - softer or harder grilling on command
  58. ### `loop-factory`
  59. Spec-driven agent loop. Coding tasks live as markdown specs that move through `inbox → active → archive`, get implemented by Claude Code or Codex, and must pass a review gate before they count as done. State is just which folder a spec is in. The governing rule: automate implementation and verification, not product decisions.
  60. Use when you want:
  61. - repeatable, reviewable agent work instead of one-off prompting
  62. - visible task state (inbox / active / archive) with no dashboard
  63. - generated implementation, review, and backprop prompts for either agent
  64. - a hard review gate before anything is marked done
  65. - to install or scaffold the `loop-factory` CLI into a project
  66. Pairs with the [Loop-Factory](https://github.com/JuliusBrussee/Loop-Factory) repo, which ships the CLI and native Claude/Codex adapters.
  67. ### `junior-to-senior`
  68. Adversarial review skill for agent-generated plans. Treats the current output as the work of a junior, then constructs a senior reviewer grounded in codebase research and web research of current best practices. Diagnoses altitude failures — plans that are foggy on the hard parts or tunneled into details with no product vision — and rewrites them into a scoped, state-of-the-art version with evidence behind every finding.
  69. Use when you want:
  70. - a staff-engineer-grade review of a plan before committing to it
  71. - plans that commit on interfaces, versions, and failure modes instead of hand-waving
  72. - best practices refreshed past the model's training cutoff via live web research
  73. - a clear delta between the original plan and the upgraded one
  74. - product decisions surfaced as open questions instead of silently invented
  75. ### `deslopify`
  76. De-slop pass for any text. Scans with a regex catalog of AI-writing tells — negative parallelism ("not X but Y"), puffery vocabulary, rule-of-three, false ranges, em-dash abuse, uniform cadence, hedged both-sidesing — then rewrites at the level of meaning and re-scans its own output until clean. Built as a loop because the worst tells are emergent generative habits that a rewriting model reintroduces in paraphrase.
  77. Use when you want:
  78. - AI-drafted text that reads like a person wrote it
  79. - a diagnosis table of which tells were found before the rewrite
  80. - register-aware output: academic article, tweet, reddit post, LinkedIn, email, blog, docs, marketing
  81. - no overcorrection — no fake typos, forced slang, or invented specifics
  82. ### `context-canary`
  83. Early-warning system for long agent sessions. Installs a byte-stable first-line signal — the user's name, a turn counter, and an honest context self-check — so the moment the agent's hold on its instructions degrades (attention drift, compaction, truncation), the signal visibly dies. Comes with a trip protocol: checkpoint state to a file, re-anchor on project instructions, reset deliberately.
  84. Use when you want:
  85. - to know *when* a long session starts rotting instead of finding out from bad output
  86. - a zero-infrastructure health check that runs every single turn
  87. - compaction events surfaced the moment they happen
  88. - a disciplined recovery path (checkpoint → re-anchor → fresh session) instead of limping on
  89. Grounded in context-rot research (Chroma), lost-in-the-middle (Liu et al.), and instruction-drift findings — sources linked in the skill's references.
  90. ### `last-20-percent`
  91. Finds and finishes the last 20% of a built solution — the experiential layer agents skip. Agents decompose the noun ("wiki" → ingestion, search, LLM) and the experience of using the thing never appears in that decomposition, so it never becomes a task. This skill decomposes the *scene* instead: one concrete magic moment, walked step by step, with the residue specced at plumbing fidelity and hand-crafted golden artifacts set as the quality bar before any generator gets built.
  92. Use when you want:
  93. - builds that end with a product, not a technically-complete demo
  94. - the experiential work (content, IA, first-run, defaults, microcopy) specced as concretely as the plumbing
  95. - golden artifacts written by hand before the machinery that generates them
  96. - a final walk-through as the end user before anything is called done
  97. - an audit mode for existing solutions that work but feel flat
  98. ## Interface Kit Standard
  99. If a repo has `DESIGN.md`, it wins. Otherwise UI work should still have a point of view:
  100. - Accessibility first: contrast, keyboard navigation, focus states, semantics.
  101. - Performance before decoration: stable layout, lazy assets, transform-only motion.
  102. - Typography matters: readable type scale, sane line length, tabular numbers for data.
  103. - Layout uses stable spatial rules: 4/8px spacing, responsive constraints, no overlap.
  104. - Components have complete states: hover, focus, active, disabled, loading, empty, error.
  105. - Avoid generic defaults: no faceless hero, no purple-blue gradient template, no stock-looking polish.
  106. ## Caveman Ecosystem
  107. This repo sits next to broader Julius agent stack:
  108. | Repo | What |
  109. |---|---|
  110. | [caveman](https://github.com/JuliusBrussee/caveman) | Output compression for agents. |
  111. | [caveman-code](https://github.com/JuliusBrussee/caveman-code) | Terminal coding agent built around token efficiency. |
  112. | [cavemem](https://github.com/JuliusBrussee/cavemem) | Cross-agent memory. |
  113. | [cavekit](https://github.com/JuliusBrussee/cavekit) | Spec-driven build loop. |
  114. | [cavegemma](https://github.com/JuliusBrussee/finetune-caveman) | Fine-tuned model experiments for terse agent output. |
  115. ## Skill Reference
  116. Run:
  117. ```bash
  118. node scripts/list-skills.mjs
  119. ```
  120. Verify frontmatter:
  121. ```bash
  122. node scripts/verify-skills.mjs
  123. ```
  124. ## Contributing
  125. Skills should be:
  126. - Small enough to read quickly.
  127. - Triggered by clear user intent.
  128. - Progressive: load only the extra files needed.
  129. - Specific about workflow and validation.
  130. - Free of repo-specific assumptions unless the skill says so.
  131. ## License
  132. MIT.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.