Eight personal agent skills for now: Caveman base, Interface Kit, Grill Me, Loop Factory, Junior to Senior, Deslopify, Context Canary, and The Last 20%.
- **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.
Point is control. Agents should be terse when talking, precise when building interfaces, calibrated when challenging plans, and disciplined when running build loops.
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.
2.**Build interfaces with taste.** Interface Kit starts from accessibility, performance, typography, spatial rhythm, color roles, and concrete interaction states.
Ultra-compressed communication mode. Cuts token usage by dropping filler, hedging, pleasantries, and excess grammar while keeping technical accuracy intact.
Use when you want:
- shorter agent replies
- less token waste
- exact code, command, error, and API preservation
- persistent terse style until user exits with "normal mode"
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.
Use when you want:
- plan critique without getting overwhelmed
- one question at a time
- recommended answers with each question
- pressure matched to beginner, working, or expert knowledge
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.
Use when you want:
- repeatable, reviewable agent work instead of one-off prompting
- visible task state (inbox / active / archive) with no dashboard
- generated implementation, review, and backprop prompts for either agent
- a hard review gate before anything is marked done
- to install or scaffold the `loop-factory` CLI into a project
Pairs with the [Loop-Factory](https://github.com/JuliusBrussee/Loop-Factory) repo, which ships the CLI and native Claude/Codex adapters.
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.
Use when you want:
- a staff-engineer-grade review of a plan before committing to it
- plans that commit on interfaces, versions, and failure modes instead of hand-waving
- best practices refreshed past the model's training cutoff via live web research
- a clear delta between the original plan and the upgraded one
- product decisions surfaced as open questions instead of silently invented
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.
Use when you want:
- AI-drafted text that reads like a person wrote it
- a diagnosis table of which tells were found before the rewrite
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.
Use when you want:
- to know *when* a long session starts rotting instead of finding out from bad output
- a zero-infrastructure health check that runs every single turn
- compaction events surfaced the moment they happen
- a disciplined recovery path (checkpoint → re-anchor → fresh session) instead of limping on
Grounded in context-rot research (Chroma), lost-in-the-middle (Liu et al.), and instruction-drift findings — sources linked in the skill's references.
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.
Use when you want:
- builds that end with a product, not a technically-complete demo
- the experiential work (content, IA, first-run, defaults, microcopy) specced as concretely as the plumbing
- golden artifacts written by hand before the machinery that generates them
- a final walk-through as the end user before anything is called done
- an audit mode for existing solutions that work but feel flat
