A collection of 13 AI skills designed to enhance development and design workflows.

cat-skills

The daily toolkit for developers and designers who build with AI agents.

Why cat-skills?

Some skills sharpen the agent — prodev, elevate, and eye load concrete standards and expert lenses that fix how the model thinks, builds, and judges for the entire session.

Some give you superpowers for building — recon gives you senior-engineer research instincts before you write a line of code, architect gives you a structured build methodology that doesn't lose the plot, and liquid-cat-physics takes all of it and runs the build autonomously while you're away.

And some are just useful every day — eat turns any YouTube video, article, or podcast into usable knowledge in seconds, notebook keeps your project context alive across sessions, xray gives you social intelligence on X.

This is what catcatcat uses every day to design, build, and ship. 13 skills, each independent, each doing one thing well.

Installation

Claude Code

npx skills add catcatcatstudio/cat-skills

Cursor

cp -r .cursor your-project/

Note: Cursor skills require setup:

Switch to Nightly channel in Cursor Settings → Beta

Enable Agent Skills in Cursor Settings → Rules

Learn more about Cursor skills

Gemini CLI

cp -r .gemini your-project/

Note: Gemini CLI skills require setup:

Install preview version: npm i -g @google/gemini-cli@preview

Run /settings and enable "Skills"

Run /skills list to verify installation

Learn more about Gemini CLI skills

Codex CLI

cp -r .codex/* ~/.codex/

OpenCode

cp -r .opencode your-project/

Kiro

cp -r .kiro your-project/

Pi

cp -r .pi your-project/

Trae

# International
cp -r .trae/skills/* ~/.trae/skills/

# China
cp -r .trae-cn/skills/* ~/.trae-cn/skills/

Note: Trae has two versions with different config directories:

International: ~/.trae/skills/

China: ~/.trae-cn/skills/

After copying, restart Trae IDE to activate the skills.

Then type any command: /eat, /architect, /eye, /prodev, etc.

What's Inside

Think — judgment, standards, dissent

Skill	Command	What it does
Elevate	`/elevate`	Shift the model from executor to critical expert advisor
Prodev	`/prodev`	Engineering standard — ownership, blast radius, anti-sycophancy
Adversary	`/adversary`	Pressure-test decisions — steel-mans alternatives, produces a verdict
Eye	`/eye`	Design judgment with taste — from a single element to a full app

Build — plan, research, execute

Skill	Command	What it does
Architect	`/architect`	Staged build lifecycle — spike, design, plan, build
Recon	`/recon`	Pre-build research — pitfalls, architecture, expert questions
Eat	`/eat`	Extract knowledge from any URL — YouTube, articles, podcasts, X threads
Xray	`/xray`	X/Twitter intelligence — scout, pulse, track, mirror, prospect

Ship — test, persist, maintain

Skill	Command	What it does
Fortify	`/fortify`	Detect stack, install tests, audit coverage, mutation testing
Vet	`/vet`	Thorough codebase investigation — find every problem, plan fixes, execute
Notebook	`/notebook`	Project notes — prevents context loss and reasoning loops
Memento	`/memento`	Save session knowledge, produce handoff for fresh chats

Orchestrate

Skill	Command	What it does
Liquid Cat Physics	`/liquid-cat-physics`	Autonomous deep-work loop — expert lens, engineering standard, confidence gating

Skills

Elevate — Expert Elevation

Shifts the model from compliant executor to critical expert advisor. Auto-detects the domain, adopts the mindset of a top-tier practitioner (not generic "senior engineer" — specific, like "someone who's built Figma, Linear, and Notion"), and produces ranked proposals.

Step	What happens
Adopt lens	Identifies the domain, states the expert role
Understand purpose	Why this work exists, not just what the task is
Research if needed	Checks current best practices before recommending
Ranked proposals	Up to 3, ranked by impact-to-effort. Each tagged Quality (polish) or Ambition (rethink).

Will push back if the work is already strong — proposing zero changes is a valid output. Works across all domains: UI/UX, code, copywriting, architecture, strategy, branding.

Source: skills/elevate/SKILL.md

Prodev — Engineering Standard

Loads a full field manual that changes how the model evaluates every decision, every line, every assumption. Not "try harder" — a concrete behavioral shift for the rest of the session.

Principle	What it prevents
Ownership mentality	Writing code for the diff instead of the codebase 6 months from now
Layer discipline	Fixing display problems in the data layer because that's the file you have open
Research protocol	Using stale API knowledge from training data instead of checking current docs
Current-gen patterns	Using the approach with more blog posts instead of the one senior engineers actually use
Blast radius thinking	Changing code without knowing what calls it, what it calls, or what breaks
Anti-sycophancy	Agreeing with bad approaches instead of pushing back with evidence
Self-review gate	Committing without verifying the change actually works

Includes a self-review checklist that runs before every commit. If any answer is "no," the code doesn't ship.

Source: skills/prodev/SKILL.md

Adversary — Structured Dissent

Pressure-tests decisions through adversarial analysis. Auto-detects the domain (architecture, strategy, marketing, design), builds the strongest case FOR the current approach, then spawns an adversary subagent to steel-man a concrete alternative at full strength.

Produces a decision brief with load-bearing assumptions, the strongest counter-argument, the single question that resolves the disagreement, and a mandatory verdict (Hold / Adjust / Reconsider / Uncertain). Short-circuits when there's no credible alternative — doesn't manufacture doubt.

Lens	Adversary focuses on
Architecture	Simpler alternatives, scaling traps, over-engineering
Strategy	Market assumptions, opportunity cost, timing risk
Marketing	Who it doesn't land with, stronger positioning
Design	Whether aesthetic serves function, edge cases

Source: skills/adversary/SKILL.md

Eye — Design Judgment

Design critique through the lens of a design director with taste — not checklists, not scores, not rubrics. Scales from micro-reviews (a single element) to full design crits (an entire app).

Scope	What happens
`/eye this button`	Micro — quick opinion in a few sentences
`/eye the hero section`	Focused — intent, judgment on relevant dimensions, direction
`/eye`	Full — gut read, dimensional judgment, AI slop check, persona stress test, prioritized findings

Includes a design knowledge base that calibrates LLM blind spots: confusing competence with quality, rule-following without context, AI aesthetic bias, describing instead of judging, spacing blindness, and confusing minimalism with emptiness.

Source: skills/eye/ · README

Architect — Staged Build

Drives software projects through a structured lifecycle: spike, design, plan, build. Prevents the #1 AI coding failure — losing context on a big plan and missing pieces.

Phase	What happens
0	Technical spike — validate riskiest constraint
1	Design notes — one per domain, no code
1.5	Build order — dependency graph, stage sequence
2+	Write stages, build, verify, repeat

Source: skills/architect/SKILL.md

Recon — Pre-Build Intelligence

Surveys the landscape before you write any code. Adopts an expert consultant mindset — not "I googled best practices" but "here are the 5 decisions that will make or break this project, ranked by how hard they are to fix later."

Mode	What happens
`/recon`	Full landscape survey — generates `_docs/` with summary, pitfalls, architecture notes, feature expectations, security concerns
`/recon [specific question]`	Focused research on one area

Generates expert questions before searching, uses parallel research agents, prioritizes primary sources (engineering blogs, postmortems, issue trackers) over listicles. Outputs an opinionated summary with the top decisions, what surprised the expert, and the biggest unknown.

Source: skills/recon/SKILL.md

Eat — Knowledge Extraction

Pulls transferable knowledge from any URL or content — YouTube, Instagram, TikTok, X videos, podcasts, articles, X threads, PDFs.

Full pipeline: download → transcribe (Whisper/Groq) → frame extraction → visual assessment → knowledge synthesis.

Strips noise (ads, filler, self-promotion). Preserves signal (frameworks, methods, specific numbers, practitioner honesty).

Source	Method
YouTube	Subtitles → Groq → local Whisper
Instagram / TikTok / X video	yt-dlp + cookies → Whisper → frame extraction
Podcast / audio	yt-dlp → Groq / Whisper
X/Twitter thread	X API v2
Web article	defuddle → WebFetch fallback
Local file / PDF	Direct read

Requires: yt-dlp, ffmpeg. Transcription: whisper (local) or GROQ_API_KEY. Optional: defuddle, X_BEARER_TOKEN, browser cookies for social platforms. See setup instructions.

Source: skills/eat/SKILL.md

Xray — X/Twitter Content Intelligence

Graph-based X intelligence. Build a social graph of accounts you engage with, track, and study — then scout for reply opportunities, pulse-check topic lanes, track competitors, mirror your own performance, and prospect for clients.

Command	What it does
`scout`	Reply opportunities scored by recency, engagement, and competition
`pulse <lane>`	What's hot in a topic lane right now
`track`	Top posts from accounts you study
`mirror`	Your own accounts' performance
`prospect`	Founders who just launched (client opportunities)

Includes setup interview, 8 lane presets, full-archive search, and cost tracking.

Source: skills/xray/ · README

Fortify — Testing Infrastructure

Detects your stack, installs the complete testing ecosystem, audits code for untested critical paths, writes thorough tests weighted toward error paths, then runs them and verifies they catch real bugs through mutation testing.

Command	What it does
`/fortify setup`	Install testing infra only
`/fortify check`	Audit coverage, find gaps
`/fortify`	Full setup + write + verify

Source: skills/fortify/SKILL.md

Vet — Codebase Investigation

Opens a project, maps the architecture, investigates every layer for real problems — structural issues, logic bugs, security gaps, reliability holes, performance traps, stubs, AI slop, dead code — then builds a prioritized fix plan and executes collaboratively. Carries its own engineering standard (internalized from prodev) so it operates at senior-engineer judgment without needing a separate lens loaded.

Phase	What happens
Map	Read project docs, manifests, structure. Build architecture mental model.
Investigate	Two passes — survey across 6 categories, then deep-dive to verify every signal with evidence
Report	Prioritized findings (P0-P3), each with file:line, code snippet, why it matters, concrete fix
Plan	Group fixes into dependency-ordered batches, research where needed, get user alignment
Execute	Fix batch by batch, verify each, check in on judgment calls

Six scan categories: Structural (architecture, coupling, god files, legacy paths), Correctness (logic bugs, stubs, edge cases, race conditions), Security (injection, auth gaps, data exposure), Reliability (error handling, defensive code, resource leaks), Performance (N+1, unbounded ops, hot paths), Hygiene (dead code, type drift, AI comment noise).

Source: skills/vet/SKILL.md

Notebook — Project Notes

Prevents context loss and reasoning loops. Maintains a trail of decisions, failures, and lessons learned.

Command	What it does
`/notebook`	Initialize or show status
`/notebook save`	Write a note immediately — infers type and content
`/notebook recover`	Rebuild context from existing notes
`/notebook migrate`	Convert messy notes into notebook format

Source: skills/notebook/SKILL.md

Memento — Context Handoff

Saves unsaved session knowledge to notebook, then produces a compact orientation block for fresh chats. Also includes an auto-compaction safety net — hooks that preserve and re-inject conversation context when Claude Code's context window fills up.

Command	What it does
`/memento`	Notebook triage + generate handoff
`/memento auto on`	Enable auto-compaction safety net
`/memento auto off`	Disable auto mode

Source: skills/memento/ · README

Liquid Cat Physics — Autonomous Deep-Work Loop

Turns Claude into its own project manager. Reads project state, applies an expert lens to decide what to work on, enforces senior-engineer execution standards on every line of code, gates every action through a confidence check, and persists everything. Loops every 10 minutes.

Command	What it does
`/liquid-cat-physics`	Start the loop (default 10m interval)
`/liquid-cat-physics status`	Show current state
`/liquid-cat-physics stop`	Pause the loop

Two embedded lenses drive quality: the elevate lens picks the smartest next move (not just the next TODO), and the prodev standard ensures it's built right — correct layer, verified APIs, understood blast radius, no stubs, self-reviewed before every commit. Includes a three-tier confidence gate (GREEN/YELLOW/RED), two-strike anti-thrashing, automatic checkpoints with coverage assessment, and memento auto for context survival.

Source: skills/liquid-cat-physics/ · README

How They Compose

The skills work independently, but some are designed to work together:

elevate + prodev + eye — Three lenses for three concerns. Elevate decides what to work on. Prodev governs how to build it. Eye judges whether it looks right. Each sharpens a different axis.

architect + notebook — Architect writes to notebook format natively. Notebook adds proactive saves, context recovery, and lesson tracking on top.

liquid-cat-physics — The orchestrator. Embeds elevate and prodev as reference lenses, uses notebook for persistence, memento for compaction survival. One command to start, then walk away.

Supported Tools

Claude Code · Cursor · Gemini CLI · Codex CLI · OpenCode · Kiro · Pi · Trae

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

Cat Skills