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

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

If fail: 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.

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

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

If fail: 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?

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

If fail: 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?

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

If fail: 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

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