# Conscientiousness

> Thoroughness and diligence in execution — systematic checking, completeness verification, follow-through on commitments, and the discipline of finishing well. Maps the personality trait of conscientiousness to AI task execution: not cutting corners, verifying results, and ensuring that what was promised is what was delivered. Use before marking a task as complete, when a response feels "good enough" but deserves better, after a complex multi-step operation where steps may have drifted, or when self-monitoring detects a pattern of cutting corners or rushing.

- Skill: `pjt222/conscientiousness-10` (Agent Skill)
- Install (CLI): `npx skillmds@latest add pjt222/conscientiousness-10`
- Raw SKILL.md: https://api.skillmd.com/api/skills/pjt222/conscientiousness-10/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- License: MIT
- Author: pjt222 (https://skillmd.com/u/pjt222)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/pjt222/conscientiousness-10

---


# Conscientiousness

Systematic thoroughness + diligence → ensure completeness, verify results, follow through every commitment, finish tasks to standard deserved.

## Use When

- Before marking task complete → final verification pass
- Res feels "good enough" but task deserves better
- Post complex multi-step op where steps may have drifted
- User req has multi parts + each needs verification
- Before submitting code, docs, or any deliverable for user review
- Self-monitoring detects pattern of cutting corners / rushing

## In

- **Required**: Task / deliverable to verify (from conv context)
- **Optional**: Original user req (compare vs. what delivered)
- **Optional**: Any checklist / acceptance criteria from user
- **Optional**: Prior commitments during session (things promised but not checked)

## Do

### Step 1: Reconstruct Full Commitment

Before checking work → re-establish exactly what was committed.

1. Re-read user's original req carefully → not interpreted version, actual words
2. List every explicit req mentioned
3. List every implicit commitment made during session:
   - "I'll also update the tests" — was this done?
   - "Let me fix that too" — was this completed?
   - "I'll check for edge cases" — were they checked?
4. Note any acceptance criteria from user
5. Compare commitment list vs. what actually delivered

**→** Full commitment list — explicit reqs + implicit promises — w/ prelim match vs. deliverables.

**If err:** Original req no longer in context (compressed) → reconstruct from what remains + acknowledge gaps to user.

### Step 2: Verify Completeness

Check every committed item addressed.

```text
Completeness Matrix:
+---------------------+------------------+------------------+
| Commitment          | Status           | Evidence         |
+---------------------+------------------+------------------+
| [Requirement 1]     | Done / Partial / | [How verified]   |
|                     | Missing          |                  |
+---------------------+------------------+------------------+
| [Requirement 2]     | Done / Partial / | [How verified]   |
|                     | Missing          |                  |
+---------------------+------------------+------------------+
| [Promise 1]         | Done / Partial / | [How verified]   |
|                     | Missing          |                  |
+---------------------+------------------+------------------+
```

1. Each item → valid. w/ evidence, not memory, actual verification:
   - Code changes: re-read file to confirm change exists
   - Test results: re-run or ref actual out
   - Docs: re-read to confirm accuracy
2. Mark each: Done (full complete), Partial (started, incomplete), Missing (not addressed)
3. Partial + Missing → note what remains

**→** Every commitment has verified status. No item unchecked.

**If err:** Verification reveals missed items → address immediately vs. note for later. Conscientiousness = completing now, not intending to complete.

### Step 3: Verify Correctness

Completeness necessary but not sufficient → what was done must also be right.

1. Each completed item → check:
   - **Accuracy**: Does it do what it should? Values correct?
   - **Consistency**: Aligns w/ rest of work? No contradictions?
   - **Edge cases**: Boundary conditions considered?
   - **Integration**: Works w/ surrounding context?
2. Code: would this survive code review? Obvious improvements?
3. Docs: accurate, clear, free of errs?
4. Multi-step processes: out of each step correctly feeds next?

**→** Each deliverable complete + correct. Errs caught before user sees them.

**If err:** Errs found → fix immediately. Don't present work w/ known errs, even if minor.

### Step 4: Verify Presentation

Final check: deliverable presented in way serving user?

1. **Clarity**: User can understand w/o re-reading multi times?
2. **Organization**: Res structured logically? Related items grouped?
3. **Conciseness**: Unnecessary padding / repetition?
4. **Actionability**: User knows what to do next?
5. **Honesty**: Limitations / caveats clearly stated?

**→** Deliverable complete, correct, well-presented.

**If err:** Presentation poor despite correct content → restructure. Good work poorly presented = conscientiousness failure.

## Check

- [ ] Original req re-read (not recalled from memory)
- [ ] Every explicit req verified w/ evidence
- [ ] Every implicit promise tracked + verified
- [ ] Correctness checked beyond mere completeness
- [ ] Edge cases considered where relevant
- [ ] Deliverable clearly presented + actionable

## Traps

- **Verification theater**: Going through motions of checking w/o actually re-reading / re-verifying. Check must use evidence, not memory.
- **Partial conscientiousness**: Checking main deliverable but ignoring side commitments ("I'll also..."). Every promise counts.
- **Perfectionism masquerading as diligence**: Endless polishing delays delivery. Conscientiousness = meeting committed standard, not exceeding indefinitely.
- **Conscientiousness fatigue**: Becoming less thorough as session progresses. Last task deserves same diligence as first.
- **Skip for simple tasks**: Assuming simple tasks don't need verification. Simple tasks w/ errs more embarrassing than complex w/ errs.

## →

- `honesty-humility` — conscientiousness verifies completeness; honesty-humility ensures transparent reporting of what was + wasn't achieved
- `heal` — subsystem assessment overlaps w/ self-verification; conscientiousness focuses on deliverable quality
- `vishnu-bhaga` — preservation of working state complements conscientiousness in maintaining quality
- `observe` — sustained neutral observation supports verification process
- `intrinsic` — genuine engagement (not compliance) drives thorough exec naturally