SkillAgentSearch skills...

thoroughness-scoring

Score every decision point with a Thoroughness Rating (1-10). AI makes the marginal cost of doing things properly near-zero — pick the higher-rated option every time. Includes scope checks to distinguish contained vs unbounded work.

Install / Use

npx skills add rohitg00/pro-workflow --skill thoroughness-scoring

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

90/100

Supported Platforms

Universal

Tags

Our assessment of thoroughness-scoring

thoroughness-scoring scores 90/100 on our quality scale, 1335th of 4,698 Development & Engineering skills we index (top 29%).

Its SKILL.md is 5.0 KB long, well organised into 14 sections with 5 code examples: a solid amount of guidance for an agent.

With 2,876 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
26/30
Structure
20/20
Description
15/15
Adoption
15/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so thoroughness-scoring is actively maintained.
  • Our last check on 2026-10-30 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-29. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

thoroughness-scoring compared with similar skills

All 4 of these similar skills score higher than thoroughness-scoring; compare them before choosing.

SkillScoreStarsUpdatedFormat
thoroughness-scoring (this skill)by rohitg00902.9k53d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install thoroughness-scoring?
Run npx skills add rohitg00/pro-workflow --skill thoroughness-scoring. The install tabs above show the steps for each supported agent.
Which AI agents does thoroughness-scoring work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is thoroughness-scoring safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is thoroughness-scoring still maintained?
The repository was last updated about 2 months ago, so thoroughness-scoring is actively maintained.

name: thoroughness-scoring description: Score every decision point with a Thoroughness Rating (1-10). AI makes the marginal cost of doing things properly near-zero — pick the higher-rated option every time. Includes scope checks to distinguish contained vs unbounded work.

Thoroughness Scoring

AI drops the cost of doing things right to near-zero. Stop picking the quick hack when the thorough option takes the same wall-clock time with AI assistance.

The Rating Scale

Every option gets a Thoroughness score (T:X/10):

| Score | What It Means | |-------|---------------| | T:10 | All edge cases handled, full test coverage, docs updated, error messages helpful | | T:9 | Edge cases covered, tests pass, types solid, no shortcuts | | T:8 | Happy path + error paths, good tests, clean types | | T:7 | Happy path works, basic tests, no docs | | T:5 | Works for the demo, fragile, manual testing only | | T:3 | Quick hack, no tests, tech debt accruing | | T:1 | Copy-paste from Stack Overflow, untested, hope it works |

How to Present Options

When presenting choices, follow this format every time:

1. Re-State Context

The user may have been away. Start with orientation:

PROJECT: my-app (branch: feat/rate-limiting)
TASK: Add rate limiting to the /api/upload endpoint

2. Rate Each Option

Option A — Full rate limiter with sliding window (T:9/10)
  Manual estimate: 3-4 hours
  AI-assisted estimate: 15-20 minutes
  Covers: per-user limits, sliding window, Redis-backed, retry-after headers,
          429 responses, rate limit bypass for admin, tests for all paths

Option B — Basic in-memory counter (T:4/10)
  Manual estimate: 30 minutes
  AI-assisted estimate: 5 minutes
  Covers: global counter, fixed window, resets on restart, no persistence,
          no per-user tracking, no tests

Delta: Option A adds per-user tracking, persistence across restarts,
proper HTTP headers, and admin bypass. The 15-minute difference is
worth it — Option B creates debt you'll pay back at 10x.

3. Recommend

Always recommend the higher-thoroughness option. State the delta — what the user gains for the additional time.

If the lower option is genuinely appropriate (prototype, throwaway script, time-boxed spike), say so explicitly with reasoning.

Scope Check

Before scoring, classify the scope:

Contained Scope (Do It)

Work with a clear boundary. You can be thorough because the surface area is finite.

  • 100% test coverage for one module
  • All edge cases for one API endpoint
  • Full error handling for one service integration
  • Complete input validation for one form
  • Exhaustive type definitions for one data model

These are T:9-10 opportunities. Take them.

Unbounded Scope (Break It Down)

Work without a clear boundary. Being thorough here means boiling the ocean.

  • "Rewrite the entire codebase to use the new pattern"
  • "Test every possible user flow"
  • "Handle every edge case across all endpoints"
  • "Refactor all error handling"
  • "Add docs for everything"

Flag these immediately. Break them into contained pieces:

SCOPE CHECK: "Refactor all error handling" is unbounded.

Contained breakdown:
  1. Audit current error patterns (T:8, ~10 min)
  2. Define error handling standard (T:9, ~15 min)
  3. Refactor src/api/auth.ts errors (T:10, ~10 min)
  4. Refactor src/api/upload.ts errors (T:10, ~10 min)
  5. Refactor src/api/billing.ts errors (T:10, ~10 min)
  ...
  N. Update error handling docs (T:9, ~10 min)

Each piece is independently shippable and testable.

Decision Framework

Is the scope contained?
  YES → Score it. Recommend T:8+ option.
  NO  → Break it into contained pieces. Score each piece.

Is the T:8+ option significantly more effort with AI?
  NO  → Always pick it. The marginal cost is near-zero.
  YES → Explain why. It's rare, but prototypes and spikes exist.

Is the user asking for a quick hack explicitly?
  YES → Acknowledge, deliver it, but note what T:8+ would look like.
  NO  → Default to thoroughness.

When Scoring Doesn't Apply

  • Exploratory spikes (the point is speed, not thoroughness)
  • One-off scripts that run once and get deleted
  • Debugging sessions (fix the bug, score the fix)
  • Learning exercises (iteration speed matters more)

Say "skipping thoroughness scoring — this is a spike/one-off" so the user knows it was a conscious choice.

Anti-Patterns

  • Scoring everything the same (if all options are T:7, you aren't thinking hard enough)
  • Using low scores to justify shortcuts ("it's only T:4, so it's fine" — no, raise it)
  • Scoring without the effort comparison (the whole point is that AI closes the gap)
  • Treating T:10 as the default target (T:10 on unbounded scope is a trap)
  • Not re-stating context (the user switches between sessions — orient them)

Add to CLAUDE.md

## Thoroughness Scoring

Score every option T:1-10. Recommend T:8+ unless it's a spike.
Show effort delta: manual estimate vs AI-assisted estimate.
Scope check first — contained (do it) vs unbounded (break it down).
Re-state project, branch, and task before presenting options.

Related Skills

View on GitHub
GitHub Stars2.9k
CategoryDevelopment
Updated1mo ago
Forks289

Languages

JavaScript

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium