<Devsly/>
NotebookLM Watermark Remover
Remove the NotebookLM watermark from PDF slide exports — free, unlimited, and 100% in your browser.
View
NotebookLM Video Watermark Remover
Remove the NotebookLM watermark from every frame of your MP4 and auto-trim the end card — free and unlimited.
View
Gemini Watermark Remover
Remove the Gemini (Veo) sparkle watermark from every frame of your AI-generated MP4 — free and unlimited.
View
MCP https://devsly.io/mcp MCP Tools Best Skills API Docs

Keyboard Shortcuts

Navigation

Quick Search
⌘ / Ctrl + K
Toggle Dark Mode
⌘ / Ctrl + D
Close Dialogs
Esc

Tool Actions

Execute / Process
⌘ / Ctrl + Enter
Clear Input
⌘ / Ctrl + Shift + C
Copy Output
⌘ / Ctrl + Shift + X

Editor

Select All
⌘ / Ctrl + A
Undo
⌘ / Ctrl + Z
Redo
⌘ / Ctrl + Shift + Z

Updated 1mo ago

by codybrom

clairvoyance

ESP for AI Coding — Agent skills on the philosophy on software design, grounded in decades of engineering experience.

View on GitHub (opens in a new tab)

20 GitHub stars (20)

+8 in 30 days

Stars gained per day · daily snapshots since Sep 30
Stars gained per day, Sep 30 to Nov 17: +8 in total; the busiest day was Nov 8 with +2 stars.Oct 1: 0 starsOct 2: 0 starsOct 3: 0 starsOct 4: 0 starsOct 5: 0 starsOct 6: 0 starsOct 7: 0 starsOct 8: 0 starsOct 9: 0 starsOct 10: 0 starsOct 11: 0 starsOct 12: 0 starsOct 13: 0 starsOct 14: 0 starsOct 15: 0 starsOct 16: 0 starsOct 17: 0 starsOct 18: 0 starsOct 19: 0 starsOct 20: 0 starsOct 21: 0 starsOct 22: +1 starsOct 23: 0 starsOct 24: 0 starsOct 25: +1 starsOct 26: 0 starsOct 27: 0 starsOct 28: 0 starsOct 29: 0 starsOct 30: 0 starsOct 31: 0 starsNov 1: 0 starsNov 2: 0 starsNov 3: 0 starsNov 4: +1 starsNov 5: 0 starsNov 6: 0 starsNov 7: 0 starsNov 8: +2 starsNov 9: +1 starsNov 10: 0 starsNov 11: 0 starsNov 12: 0 starsNov 13: 0 starsNov 14: +2 starsNov 15: 0 starsNov 16: 0 starsNov 17: 0 stars
Stars gained between daily snapshots
PeriodNew stars
Oct 10
Oct 20
Oct 30
Oct 40
Oct 50
Oct 60
Oct 70
Oct 80
Oct 90
Oct 100
Oct 110
Oct 120
Oct 130
Oct 140
Oct 150
Oct 160
Oct 170
Oct 180
Oct 190
Oct 200
Oct 210
Oct 22+1
Oct 230
Oct 240
Oct 25+1
Oct 260
Oct 270
Oct 280
Oct 290
Oct 300
Oct 310
Nov 10
Nov 20
Nov 30
Nov 4+1
Nov 50
Nov 60
Nov 70
Nov 8+2
Nov 9+1
Nov 100
Nov 110
Nov 120
Nov 130
Nov 14+2
Nov 150
Nov 160
Nov 170
  • 16 skills (16 skills found in its SKILL.md files)
  • 0 forks (0 forks)
  • 1mo ago last update (Last updated 1mo ago)

Install

Skills CLI

npx skills add codybrom/clairvoyance

Asks which skills and agents to install. Just one: npx skills add codybrom/clairvoyance --skill abstraction-quality — add -g for every project.

Claude Code

git clone https://github.com/codybrom/clairvoyancecp -r "clairvoyance/skills/abstraction-quality" ~/.claude/skills/

Copies the abstraction-quality skill into ~/.claude/skills/ for every project (use .claude/skills/ for one project). Repeat for the other skills listed below.

Plugin

/plugin marketplace add codybrom/clairvoyance

Run inside Claude Code if the repository ships a plugin marketplace, then pick plugins from /plugin.

Skills can run code on your machine — read the SKILL.md first.

What it does

In the author's own words, from each skill's SKILL.md.

  • abstraction-quality

    Evaluates whether abstractions provide a genuinely different way of thinking or are structurally shallow. Use when adjacent layers feel redundant, wrappers add boilerplate without depth, or an abstraction feels leaky. Not for a single module's interface-to-implementation ratio (use deep-modules) or information leakage across boundaries (use information-hiding).

    skills/abstraction-quality/SKILL.md on GitHub (opens in a new tab)
  • code-evolution

    Evaluates whether changes to existing code maintain or degrade design quality. Use when the user asks to review a diff or PR (for example before merging it), or asks about recently modified files, to judge whether each change looks designed-in or bolted-on. Not for scanning design smells (use red-flags) or assessing overall design investment (use strategic-mindset).

    skills/code-evolution/SKILL.md on GitHub (opens in a new tab)
  • comments-docs

    Reviews comment quality and documentation practices: the four comment types, comments-first workflow, and comment rot. Use when reviewing comments or docs, when comments just repeat the code, or when something is hard to describe in a sentence. Not for naming or code obviousness (use naming-obviousness).

    skills/comments-docs/SKILL.md on GitHub (opens in a new tab)
  • complexity-recognition

    Diagnoses whether complexity exists and where it comes from, using the three-symptom, two-root-cause framework. Use when code feels harder to work with than it should but the specific problem is unclear. Not for scanning known design smells (use red-flags) or evaluating a module's depth (use deep-modules).

    skills/complexity-recognition/SKILL.md on GitHub (opens in a new tab)
  • deep-modules

    Measures module depth: whether the interface is simple relative to the implementation behind it. Use when an interface has too many parameters or methods, many small classes each do too little, or methods just forward calls. Not for whether adjacent layers provide different abstractions (use abstraction-quality) or merging/splitting modules (use module-boundaries).

    skills/deep-modules/SKILL.md on GitHub (opens in a new tab)
  • design-it-twice

    Generates and compares at least two fundamentally different design alternatives on concrete criteria before committing. Use when the user asks to design something twice, or before committing to any significant design of classes, modules, APIs, or architecture. Also use when asked how to structure or architect a feature, or when writing the design or alternatives section of an RFC, design doc, or…

    skills/design-it-twice/SKILL.md on GitHub (opens in a new tab)
  • design-review

    Orchestrates a structured design review, running the other skills as a diagnostic funnel from complexity triage to a full red-flags sweep. Use when the user asks for a comprehensive or prioritized design assessment of a file, module, or PR. Not for an open-ended "anything off here?" or "take a look at this" prompt that names no review goal (use red-flags), a plain diff review before merge or anal…

    skills/design-review/SKILL.md on GitHub (opens in a new tab)
  • diagnose

    Routes a vague symptom or complaint to the most relevant Clairvoyance skill via a decision tree. Use when someone describes a problem but doesn't know which skill to reach for. Not for a comprehensive review (use design-review) or a checklist scan (use red-flags).

    skills/diagnose/SKILL.md on GitHub (opens in a new tab)
  • error-design

    Reviews error handling and exception design, applying the "define errors out of existence" principle. Use when reviewing error handling, when a module throws too many exceptions, or when callers must handle errors they shouldn't need to know about. Not for general caller-burden complexity (use pull-complexity-down); this skill is specifically for exception and error-condition strategy.

    skills/error-design/SKILL.md on GitHub (opens in a new tab)
  • general-vs-special

    Evaluates whether interfaces are appropriately general-purpose. Use when checking interface generality, when if-branches or parameters serve only one caller, or when getters/setters expose internal representation. Not for information leakage across boundaries (use information-hiding) or auditing configuration parameters (use pull-complexity-down).

    skills/general-vs-special/SKILL.md on GitHub (opens in a new tab)
  • information-hiding

    Checks for information leakage across module boundaries, including temporal decomposition and false encapsulation. Use when modules change together, implementation details leak across boundaries, or structure follows execution order rather than knowledge ownership. Not for merge/split decisions (use module-boundaries) or interfaces over-specialized for one caller (use general-vs-special).

    skills/information-hiding/SKILL.md on GitHub (opens in a new tab)
  • module-boundaries

    Evaluates where module boundaries are drawn and whether modules should be merged or split. Use when deciding whether to combine or separate two modules, when modules are tightly coupled, or when a change to one forces changes to another. Not for depth within a single module (use deep-modules) or abstraction-layer quality (use abstraction-quality).

    skills/module-boundaries/SKILL.md on GitHub (opens in a new tab)
  • naming-obviousness

    Reviews naming quality and code obviousness via the isolation test, scope-length principle, and consistency audit. Use when names feel vague, something is hard to name (a design signal, not a vocabulary problem), or behavior isn't obvious on first read. Not for comment quality or documentation (use comments-docs).

    skills/naming-obviousness/SKILL.md on GitHub (opens in a new tab)
  • pull-complexity-down

    Checks whether complexity is pushed to callers or absorbed by implementations — the direction complexity flows. Use when callers must do significant setup, handle errors the module could resolve, or configure things they don't understand. Not for module depth (use deep-modules), knowledge leakage (use information-hiding), or exception strategy once an error must surface (use error-design).

    skills/pull-complexity-down/SKILL.md on GitHub (opens in a new tab)
  • red-flags

    Scans code against 17 design smells (the book's 14 named Red Flags plus 3 process-stage signals) and produces a structured diagnostic report. Use when the user asks for a red flags or design smell scan, asks to check code against a checklist, is evaluating unfamiliar code, or asks open-endedly whether anything is off in a named or pasted file, class, or function, or asks you to look it over. Not…

    skills/red-flags/SKILL.md on GitHub (opens in a new tab)
  • strategic-mindset

    Assesses whether code reflects strategic or tactical thinking, including the 10-20% investment rule and tactical-tornado patterns. Use when evaluating design investment, when code was written under time pressure, or when working code consistently degrades the system. Not for judging whether a specific diff looks designed-in or bolted-on (use code-evolution).

    skills/strategic-mindset/SKILL.md on GitHub (opens in a new tab)

Review before you install

A skill is a set of instructions and scripts your agent will follow, and it can run code on your machine. Read the SKILL.md and any scripts first — this listing is not a security review.