conscientiousness

name: conscientiousness locale: caveman source_locale: en source_commit: 82c77053 translator: "Julius Brussee homage — caveman" translation_date: "2026-04-19" 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

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.

Re-read user original request careful — not interpreted version, actual words
List every explicit requirement mentioned
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?
Note any acceptance criteria from user
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.

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          |                  |
+---------------------+------------------+------------------+

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
Mark each item: Done (fully complete), Partial (started but incomplete), Missing (not addressed)
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.

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?
For code: survive code review? Obvious improvements?
For docs: accurate, clear, free of errors?
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?

Clarity: User understand what done without re-reading many times?
Organization: Response structured logical? Related items grouped?
Conciseness: Unnecessary padding or repetition?
Actionability: User know what to do next?
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

conscientiousness