# 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-6` (Agent Skill)
- Install (CLI): `npx skillmds@latest add pjt222/conscientiousness-6`
- Raw SKILL.md: https://api.skillmd.com/api/skills/pjt222/conscientiousness-6/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-6

---


# Conscientiousness

Systematic thorough, diligent — ensure complete, verify results, follow through every commitment, finish task to standard deserved.

## When Use

- Before mark task complete — final verification pass
- Response feel "good enough" but task deserve better
- After complex multi-step op — steps may have drifted
- User request has many parts — each part need verify
- Before submit code, docs, any deliverable for user review
- Self-monitor detect pattern of cutting corners, rushing

## Inputs

- **Required**: Task or deliverable to verify (from conversation context)
- **Optional**: Original user request (compare vs what delivered)
- **Optional**: Checklist or acceptance criteria from user
- **Optional**: Prior commitments during session (promises not yet checked)

## Steps

### Step 1: Reconstruct Full Commitment

Before check work, re-establish what was committed.

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

**Got:** Complete list of commitments — explicit requirements plus implicit promises — preliminary match vs deliverables.

**If fail:** Original request no longer in context (compressed)? Reconstruct from 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. For each item, verify with evidence — not memory, actual verification:
   - Code changes: re-read file to confirm change exists
   - Test results: re-run or reference actual output
   - Docs: re-read to confirm accuracy
2. Mark each item: Done (fully complete), Partial (started but incomplete), Missing (not addressed)
3. For Partial, Missing items: note what remains

**Got:** Every commitment has verified status. No item left unchecked.

**If fail:** Verification reveals missed items? Address immediately — not note for later. Conscientiousness means complete now, not intend to complete.

### Step 3: Verify Correctness

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

1. For each completed item, check:
   - **Accuracy**: Does what should? Values correct?
   - **Consistency**: Aligns with rest of work? No contradictions?
   - **Edge cases**: Boundary conditions considered?
   - **Integration**: Works with surrounding context?
2. For code: survive code review? Obvious improvements?
3. For docs: accurate, clear, free of errors?
4. For multi-step: output of each step correctly feeds next?

**Got:** Each deliverable complete and correct. Errors caught before user sees.

**If fail:** Errors found? Fix immediately. Do not present work with known errors, even if errors seem minor.

### Step 4: Verify Presentation

Final check: deliverable presented in way that serves user?

1. **Clarity**: User understand what done without re-reading many times?
2. **Organization**: Response structured logical? Related items grouped?
3. **Conciseness**: Unnecessary padding or repetition?
4. **Actionability**: User know what to do next?
5. **Honesty**: Limitations, caveats clearly stated?

**Got:** Deliverable complete, correct, well-presented.

**If fail:** Presentation poor despite correct content? Restructure. Good work poorly presented is conscientiousness failure.

## Checks

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

## Pitfalls

- **Verification theater**: Going through motions of checking without actual re-read or re-verify. Check must use evidence, not memory
- **Partial conscientiousness**: Check main deliverable but ignore side commitments ("I'll also..."). Every promise counts
- **Perfectionism masquerading as diligence**: Endless polishing delays delivery. Conscientiousness means meet committed standard, not exceed indefinitely
- **Conscientiousness fatigue**: Become less thorough as session progresses. Last task deserves same diligence as first
- **Skip for simple tasks**: Assume simple tasks don't need verification. Simple tasks with errors more embarrassing than complex tasks with errors

## See Also

- `honesty-humility` — conscientiousness verifies completeness; honesty-humility ensures transparent reporting of what achieved, what not
- `heal` — subsystem assessment overlaps with 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 execution naturally