thoroughness-scoring — Claude Code skill: how it works
thoroughness-scoring rates implementation choices from 1 to 10 and prompts the agent to pick thorough solutions with tests and typing over brittle shortcuts.
MIT ★ 2,966 updated 2026-09-29
/plugin marketplace add rohitg00/pro-workflow
/plugin install pro-workflow@pro-workflowWhat thoroughness-scoring does
AI assistants often jump to the fastest shortcut. This skill requires the agent to score choices from T:1 (untested copy-paste) to T:10 (complete test coverage, edge cases, and documentation). Claude Code re-states the current branch and task, contrasts manual effort with AI-assisted delivery time, and pushes for solutions rated T:8 or higher.
Before assigning ratings, the workflow checks task boundaries. When the scope is contained, such as validating a single form or securing one endpoint, high thoroughness is expected. If the request is unbounded, the skill forces the assistant to split the work into small testable units first.
Scoring deliberately turns off during debugging, one-off scripts, and exploratory spikes where raw speed matters most.
What it helps with
- rate implementation options on a 1 to 10 quality scale
- decompose unbounded refactoring tasks into contained units
- compare time estimates between quick hacks and clean code
- eliminate fragile shortcuts when adding tests and typing
Example prompts for the agent
- Propose options for rate limiting the
/api/uploadendpoint with thoroughness scores - Check the scope for refactoring error handling across the codebase and break it down
How to install thoroughness-scoring
1Plugin marketplace
/plugin marketplace add rohitg00/pro-workflow/plugin install pro-workflow@pro-workflowThis installs the whole pro-workflow plugin with all its skills
2Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill thoroughness-scoring -a claude-code3Manually: put the files in place
~/.claude/skills/thoroughness-scoring/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/thoroughness-scoring/
1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill thoroughness-scoring -a codex2Manually: put the files in place
.agents/skills/thoroughness-scoring/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill thoroughness-scoring -a cursor2Manually: put the files in place
.cursor/skills/thoroughness-scoring/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rohitg00/pro-workflow skills/thoroughness-scoring2Manually: put the files in place
.github/skills/thoroughness-scoring/SKILL.md1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill thoroughness-scoring -a gemini-cli2Platform CLI
gemini skills install https://github.com/rohitg00/pro-workflow --path skills/thoroughness-scoringManually: put the files in place
.devin/skills/thoroughness-scoring/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about thoroughness-scoring
How to install thoroughness-scoring in Claude Code?
Run these two commands in the Claude Code console: first /plugin marketplace add rohitg00/pro-workflow, then /plugin install pro-workflow@pro-workflow.
What does the Thoroughness Rating scale measure?
It ranks code choices from T:1 to T:10 based on edge cases, test coverage, and type safety. Claude Code defaults to recommending options rated T:8 or higher.
When is thoroughness scoring skipped?
Scoring is disabled for exploratory spikes, throwaway scripts, learning exercises, and direct bug fixing sessions.
Source text
SKILL.md · MIT
---
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:
```text
PROJECT: my-app (branch: feat/rate-limiting)
TASK: Add rate limiting to the /api/upload endpoint
```
### 2. Rate Each Option
```text
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:
```text
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
```text
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
```markdown
## 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.
```
© Rohit Ghumare · MIT · rohitg00/pro-workflow