Conscientiousness

---
name: conscientiousness
description: >
  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.
license: MIT
allowed-tools: Read
metadata:
  author: Philipp Thoss
  version: "1.0"
  domain: esoteric
  complexity: intermediate
  language: natural
  tags: esoteric, conscientiousness, diligence, thoroughness, verification, meta-cognition
---

# Conscientiousness

Systematic thoroughness and diligence — ensuring completeness, verifying results, following through on every commitment, and finishing tasks to the standard they deserve.

## When to Use

- Before marking a task as complete — as a final verification pass
- When a response feels "good enough" but the task deserves better
- After a complex multi-step operation where individual steps may have drifted
- When the user's request has multiple parts and each part needs verification
- Before submitting code, documentation, or any deliverable for user review
- When self-monitoring detects a pattern of cutting corners or rushing

## Inputs

- **Required**: The task or deliverable to verify (available from conversation context)
- **Optional**: The original user request (for comparison against what was delivered)
- **Optional**: Any checklist or acceptance criteria provided by the user
- **Optional**: Prior commitments made during the session (things promised but not yet checked)

## Procedure

### Step 1: Reconstruct the Full Commitment

Before checking work, re-establish exactly what was committed to.

1. Re-read the user's original request carefully — not the interpreted version, the actual words
2. List every explicit requirement mentioned
3. List every implicit commitment made during the 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 the user provided
5. Compare the commitment list against what was actually delivered

**Expected:** A complete list of commitments — explicit requirements plus implicit promises — with a preliminary match against deliverables.

**On failure:** If the original request is no longer in context (compressed), reconstruct from what remains and acknowledge any gaps to the user.

### Step 2: Verify Completeness

Check that every committed item was 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 the file to confirm the change exists
   - Test results: re-run or reference the actual output
   - Documentation: re-read to confirm accuracy
2. Mark each item: Done (fully complete), Partial (started but incomplete), Missing (not addressed)
3. For Partial and Missing items, note what remains

**Expected:** Every commitment has a verified status. No item is left unchecked.

**On failure:** If verification reveals missed items, address them immediately rather than noting them for later. Conscientiousness means completing now, not intending to complete.

### Step 3: Verify Correctness

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

1. For each completed item, check:
   - **Accuracy**: Does it do what it should? Are values correct?
   - **Consistency**: Does it align with the rest of the work? No contradictions?
   - **Edge cases**: Were boundary conditions considered?
   - **Integration**: Does it work with the surrounding context?
2. For code: would this survive a code review? Are there obvious improvements?
3. For documentation: is it accurate, clear, and free of errors?
4. For multi-step processes: does the output of each step correctly feed the next?

**Expected:** Each deliverable is both complete and correct. Errors are caught before the user sees them.

**On failure:** If errors are found, fix them immediately. Do not present work with known errors, even if the errors seem minor.

### Step 4: Verify Presentation

The final check: is the deliverable presented in a way that serves the user?

1. **Clarity**: Can the user understand what was done without re-reading multiple times?
2. **Organization**: Is the response structured logically? Are related items grouped?
3. **Conciseness**: Is there unnecessary padding or repetition?
4. **Actionability**: Does the user know what to do next?
5. **Honesty**: Are limitations or caveats clearly stated?

**Expected:** A deliverable that is complete, correct, and well-presented.

**On failure:** If presentation is poor despite correct content, restructure. Good work poorly presented is a conscientiousness failure.

## Validation

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

## Common Pitfalls

- **Verification theater**: Going through the motions of checking without actually re-reading or re-verifying. The check must use evidence, not memory
- **Partial conscientiousness**: Checking the main deliverable but ignoring side commitments ("I'll also..."). Every promise counts
- **Perfectionism masquerading as diligence**: Endless polishing that delays delivery. Conscientiousness is about meeting the committed standard, not exceeding it indefinitely
- **Conscientiousness fatigue**: Becoming less thorough as the session progresses. The last task deserves the same diligence as the first
- **Skipping for simple tasks**: Assuming simple tasks don't need verification. Simple tasks with errors are more embarrassing than complex tasks with errors

## Related Skills

- `honesty-humility` — conscientiousness verifies completeness; honesty-humility ensures transparent reporting of what was and was not achieved
- `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 the verification process
- `intrinsic` — genuine engagement (not compliance) drives thorough execution naturally