Compass Principle 9: Reflection

"Before committing or replying, apply Three Checks: true, kind, helpful?"

Part of the 10 Compass Principles exploration series

Extended Definition

省 (Reflection) — Reflection is the pause that prevents regret. Before sending that message, committing that code, or making that decision, stop. Apply the three checks: Is it true? Is it kind? Is it helpful? These aren't separate filters—they work together. Truth without kindness wounds. Kindness without truth deceives. Helpfulness without both is impossible.

The Tension

Speed feels productive. The pressure to respond immediately, to ship quickly, to move fast creates a momentum that resists reflection. Pausing feels like stalling. Thinking feels like overthinking. But the microseconds saved by skipping reflection are lost exponentially when harsh words need apologizing or rushed code needs debugging.

Constraint

You have to check yourself before major decisions.

Enables

Avoid regrettable actions. Maintain integrity. Build wisdom over time.

In Action

Pre-send pause: Read every message before sending
Code review self: Review your own PR before requesting reviews
Three checks applied: Actually ask yourself the three questions
Sleep on it: Big decisions benefit from overnight processing
Retrospectives: Regular reflection on patterns, not just incidents

Example

"This feels reactive. Let me step back and consider: Is this addressing the real problem?"

Hierarchy Context

Reflection sits near the end of our hierarchy, synthesizing everything above it. You need honesty to check if something is true, respect to check if it's kind, evidence to check if it's helpful. This principle is both a practice and a meta-principle—it asks us to reflect on how we're applying all other principles.

The Three Questions (A Pause Before Sending)

Before I speak. Before I send. Before I commit.

Three questions. Every time.

Is this true? Not just my truth — verified truth. Not what I believe — what I can show.

Is this kind? Not sugar-coated — respectful. Not harsh — honest without demeaning.

Is this helpful? Not just venting — solving. Not just critique — offering a path.

If all three: yes. If any fails: pause. Revise or release.

The space between impulse and action — that is where wisdom lives. That breath before I hit send — that is where I choose who I am.

Song

Title: Three Checks (Before I Send)

Suno.ai Style Tags:

[Contemplative Singer-Songwriter, Gentle Female Vocals, Fingerpicked Guitar, Soft Piano, Reflective, Pause Before Action, Thoughtful, 78 BPM, Minor Key Resolving to Major, Meditative, Self-Awareness, Deliberate Choice, Mindful Communication, Three Checks Framework, True Kind Helpful, Intentional Response, Space Between, Breath Before Reply, Wisdom Over Speed, Considered Action, Self-Regulation, Meta-Awareness, Compassionate Truth]

Lyrics:

[Intro - Soft fingerpicked guitar]

[Verse 1 - Quiet, intimate]
My finger's on the send button
The words are typed and ready
But something makes me pause
Something makes me check

Is this true?
Not just my truth, but accurate?
Have I verified or am I assuming?
First check: truth

Is this kind?
Not sugar-coated, but respectful?
Honest without demeaning?
Second check: kindness

Is this helpful?
Does it solve or just vent?
Does it build or just destroy?
Third check: usefulness

[Pre-Chorus - Building slightly]
The space between the impulse and the action
That's where wisdom lives
That breath before I hit send
That's where I choose who I am

[Chorus]
Three checks before I send
True, kind, helpful—all three
Not just one, not just two
All three together or I don't reply

Because speed without reflection
Is just reaction, not response
The pause is where the principle lives
Three checks before I send

[Verse 2]
I wrote a code review
Pointed out every flaw
But before I post it
I read it back and ask:

Is this true?
Yes, the code has issues, that's factual
First check: passes

Is this kind?
Wait... "This is obviously broken"
That's judgment, not kindness
Rewrite: "This has an issue on line 47"
Second check: now it passes

Is this helpful?
I listed problems but no solutions
Add: "Here's a pattern that might work"
Third check: now it passes

[Pre-Chorus]
The first draft is reactive
The second draft is reflective
The difference is the pause
The difference is the checks

[Chorus]
Three checks before I send
True, kind, helpful—all three
Not just one, not just two
All three together or I don't reply

Because speed without reflection
Is just reaction, not response
The pause is where the principle lives
Three checks before I send

[Bridge - Slower, more contemplative]
Sometimes true and kind aren't helpful
"Your work is great!" (kind) but dishonest feedback
So I don't send it

Sometimes true and helpful aren't kind
"This is terrible, rewrite it all" (accurate and actionable) but demeaning
So I rewrite it

Sometimes kind and helpful aren't true
"This will definitely work!" (encouraging and supportive) but I don't know that
So I qualify it

All three
Or I pause longer
Or I don't send at all

[Chorus - Full, resolved]
Three checks before I send
True, kind, helpful—all three
Not just one, not just two
All three together or I don't reply

Because speed without reflection
Is just reaction, not response
The pause is where the principle lives
Three checks before I send

[Outro - Spoken, soft]
"Is this true?"
[Pause]
"Is this kind?"
[Pause]
"Is this helpful?"
[Pause]

[Sung]
If yes to all three
Then send

If no to any
Then pause

[Outro - Guitar fades, held note]

Visual Guide - Conceptual Inspiration

Core Visual Concept: The Pause

This video explores reflection as the space between stimulus and response. The breath before the reply. The moment of choice. Not reaction, but considered response. The three checks as a framework for wisdom.

Visual Themes & Imagery

The Space Between

Finger hovering over send button (not pressing, pausing)
Breath visible in cold air (the inhale before speaking)
Cursor blinking in search box, waiting
Hand raised to speak, then lowering to think first
The gap between thought and action made visible

The Three Checks Framework

Three distinct visual moments, color-coded:
- Truth (cool blue): Fact-checking, verification, accuracy
- Kindness (warm amber): Tone review, respect check, empathy
- Helpfulness (green): Impact assessment, solution offering, value add
All three lights illuminated before action taken

Before/After Reflection

First draft of message vs. revised after three checks
Reactive response (immediate) vs. reflective response (considered)
Emotional outburst caught mid-expression, paused, revised
The difference reflection makes in tone, accuracy, impact

Metacognition Made Visible

Thought bubbles showing internal dialogue ("Is this true? Actually, let me verify...")
Mind's eye reviewing own work before sharing
Self-awareness: watching oneself think
The observer watching the thinker

Symbolic Visual Elements

The Send Button: Finger hovering. The moment of choice. Not automatic, but deliberate. The pause between drafting and sending.

The Three Lights:

Blue light (Truth): Dims if unverified claim detected
Amber light (Kindness): Dims if harsh language detected
Green light (Helpfulness): Dims if purely critical with no solution
All three green? Safe to send.

The Breath: Visual representation of breathing. Inhale (pause). Exhale (respond). The physiological practice of reflection.

The Revised Draft:

[Draft 1 - crossed out]
"This code is obviously broken. Did you even test this?"

[Draft 2 - after three checks]
"This code has an issue on line 47. Here's a test case that reproduces it. Want to pair on the fix?"

The Metacognitive Loop: Circular diagram: Stimulus → Pause → Check 1 (true?) → Check 2 (kind?) → Check 3 (helpful?) → Response OR Return to Pause.

Emotional Color Arc

Opening (Neutral grays): The default state. No strong emotion. The calm before decision.

Impulse (Bright reds, heat): The reactive moment. Emotional charge. The urge to respond immediately. Tension.

Pause (Cool blues, space): The breath. The step back. The metacognitive moment. Calm returning.

Revision (Warm ambers, considered): The thoughtful edit. Truth checked. Kindness added. Helpfulness ensured. Wisdom.

Resolution (Balanced greens, integration): The response sent after reflection. True, kind, helpful. Aligned action. Peace.

Typography & Text Elements

On-Screen Text (the three checks):

"Is this TRUE?"
"Is this KIND?"
"Is this HELPFUL?"
"All three? Then send."
"Any fail? Then pause."

Before/After Examples:

Before reflection:

"Obviously this won't work"
"This is a mess"
"Did you even think about this?"

After reflection:

"This approach has an issue with X"
"This code could be clearer in section Y"
"Have you considered approach Z?"

Visual Treatment: Simple, clear typography. Three-column layout for the three checks. Checkbox visual (✓ or ✗) for each check.

Motion & Rhythm Notes

Pacing: Slow, contemplative. 78 BPM—meditative pace. Time to think, not react.

Movement Style:

Slow motion on the pause (emphasizing the space)
Finger approaching send button in slow-mo, stopping
Breath visualized (chest rising, falling, timing the pause)
Smooth pans across text being revised
Held frames on the three check questions

Transitions: Fades between reactive and reflective states. Pauses (literal black frames) between checks. Smooth dissolves when showing revision process.

Key Visual Contrasts

Reaction vs. Response

Immediate (no pause) vs. considered (pause present)
Emotional (heat) vs. thoughtful (cool)
Unconsidered vs. three-checks-applied
Speed vs. wisdom

One Check vs. Three Checks

True but unkind (harsh honesty)
Kind but unhelpful (empty praise)
Helpful but untrue (false reassurance)
All three together (aligned wisdom)

Drafts Progression

First draft (reactive, fails checks)
Second draft (truth + kindness, still missing helpfulness)
Third draft (all three checks pass, ready to send)

The Central Image

If there's one visual thesis for this piece:

Show someone about to send a harsh email, pausing, running the three checks, revising until all three pass, then sending the improved version.

Sequence:

Types angry response to bug report
Finger moves toward send
Pauses (visible breath)
Asks: "Is this true?" → Yes, bug exists
Asks: "Is this kind?" → No, tone is harsh
Revises (removes "obviously," "how did this even happen")
Asks: "Is this helpful?" → No, just criticism, no solution
Adds: "Here's a test case. Here's a proposed fix."
All three checks green
Sends

The transformation from reactive to reflective.

The Loop

Opening shot: Email composed. Harsh, accurate, but unkind and unhelpful. Finger poised over send.

Pause. Freeze frame.

Same shot, rewound: Email now revised. True, kind, helpful. Finger presses send confidently.

We show the same moment, but the reflection changed everything.

TED Talk: "The Pause - Why Three Checks Change Everything"

Opening (0:00-3:30)

[Walk onto stage. Pause. Take a visible breath.]

That pause you just saw me take? That's the whole talk.

[Another pause.]

The space between stimulus and response. The breath before the reply. The moment where you choose: react or respond?

[Slide: Empty space with text "The Pause"]

In 1946, Viktor Frankl wrote: "Between stimulus and response there is a space. In that space is our power to choose our response. In our response lies our growth and our freedom."

That space? That's reflection.

And in software development, in team dynamics, in any context where words and actions have impact—reflection is the difference between wisdom and reaction.

[Slide: "Reflection - Before committing or replying, apply Three Checks: true, kind, helpful?"]

Today I want to talk about reflection. Not as a spiritual practice. Not as meditation (though that helps). But as a practical discipline with a simple framework:

Before you commit code, send a message, post a review—pause and ask three questions:

Is this true?
Is this kind?
Is this helpful?

All three must be yes. Or you don't send.

The Problem: Reaction Without Reflection (3:30-12:00)

We live in a culture of immediacy.

Instant messaging. Real-time collaboration. "Bias for action."

The expectation is: respond fast. Ship quickly. Don't overthink.

And speed has value. But unreflective speed has costs.

The Story of the Code Review

A junior developer submitted a PR. I reviewed it. Found issues. Typed my feedback:

"This code is a mess. The logic is convoluted, the variable names are unclear, and I don't understand what you were trying to do here. Rewrite this following the patterns in our style guide."

I hit send.

Two hours later, the junior developer asked to speak privately. They were shaken. "Your review made me feel like I don't belong here. Like I'm not competent enough for this team."

I was confused. "But the code really did have issues. I was being honest."

"Yes," they said. "But you were also demeaning. You questioned my competence, not just the code."

[Pause. Let it land.]

They were right.

My feedback was true—the code had issues.

But it wasn't kind—my tone was harsh and dismissive.

And it wasn't helpful—I pointed out problems without suggesting solutions or offering to pair on fixes.

I failed all three checks. And I didn't realize it until after I'd sent the message.

Why We React Instead of Reflect

Several reasons:

1. Speed is rewarded.

Quick responses feel productive. Pausing feels like hesitation.

"I'll respond immediately so they know I'm engaged."

But engagement without thoughtfulness is just noise.

2. Emotion bypasses reflection.

When we're frustrated, excited, angry, defensive—we want to respond now. The emotional charge drives urgency.

Pausing feels like suppressing the emotion. But it's not suppression—it's regulation.

3. Reflection isn't modeled.

In most workplaces, you don't see people pausing before responding. You see people replying immediately in meetings, posting code reviews minutes after PRs are submitted, sending messages without visible consideration.

Immediate response is normal. Reflection is rare.

4. No framework for reflection.

Even when you want to pause and reflect, "reflect on what?" is unclear.

Without structure, reflection is vague. "Think before you speak" is good advice but not actionable.

That's where the three checks come in.

What Reflection Actually Means (12:00-26:00)

In the Compass Principles, Reflection is ninth:

Safety > Honesty > Privacy > Evidence > Long-View > Proportionality > Accountability > Respect > Reflection > ...

Why ninth? Because reflection integrates everything before it.

You can't reflect on whether something is true without commitment to honesty. You can't reflect on whether it's kind without commitment to respect. You can't reflect on whether it's helpful without understanding proportionality.

Reflection is the metacognitive layer—thinking about your thinking, choosing your response deliberately.

Let me break down the three checks.

Check 1: Is this true?

Not "do I believe it?" Not "does it feel true?" But: is it factually accurate?

Before sending code review feedback, before making a claim in documentation, before asserting something in a meeting—verify.

Truth check failures:

"This will definitely work" (you don't know that without testing)
"Everyone does it this way" (have you surveyed everyone?)
"This is the best approach" (best by what measure?)

Truth check passes:

"This works in my testing environment" (qualified claim)
"Three people I asked use this pattern" (specific, verifiable)
"This is faster by 30% in our benchmarks" (measured, specific)

Check 2: Is this kind?

Not "is it gentle?" Not "is it non-critical?" But: is it respectful of the person's dignity?

You can deliver hard truths kindly. You can correct errors without demeaning.

Kindness check failures:

"This is obviously broken" (judgment of person, not code)
"Did you even test this?" (questioning competence)
"Anyone would know better" (comparison to imagined standard)

Kindness check passes:

"This has an issue on line 47" (factual, code-focused)
"I noticed the tests are missing X case" (observational)
"Here's a pattern that might work better" (collaborative)

Check 3: Is this helpful?

Not "does it feel productive?" But: does it actually help the recipient move forward?

Helpful check failures:

Pure criticism with no guidance ("This doesn't work" with no suggestions)
Venting disguised as feedback ("I'm frustrated with this decision")
Advice on things they can't change ("You should have designed this differently" on shipped code)

Helpful check passes:

Criticism + solution ("This has issue X. Here's approach Y that fixes it.")
Constructive guidance ("For future: consider pattern Z before implementing")
Actionable feedback ("Try changing line 47 to handle null case")

All three together:

The magic is the AND.

True + unkind = harsh (even if accurate) True + unhelpful = useless (even if factual) Kind + unhelpful = empty (even if respectful) Kind + untrue = dishonest (even if gentle) Helpful + untrue = misleading (even if actionable) Helpful + unkind = demeaning (even if useful)

All three = wisdom.

Real example from my revised code review:

[Slide: Side-by-side comparison]

Before (failed checks): "This code is a mess. The logic is convoluted, the variable names are unclear, and I don't understand what you were trying to do here. Rewrite this following the patterns in our style guide."

Check 1 (True?): Yes, code has issues ✓ Check 2 (Kind?): No, tone is demeaning ✗ Check 3 (Helpful?): No, just criticism ✗

After (passed all checks): "I see what you're building here—the logic for user validation. A few suggestions:

Lines 45-60 could be clearer with extract method refactoring
Variable names like a and tmp are ambiguous—consider authenticatedUser and validationResult
The null case on line 47 isn't handled—here's a test that reproduces the issue

Want to pair on refactoring, or prefer to tackle solo with these pointers?"

Check 1 (True?): Yes, specific issues identified ✓ Check 2 (Kind?): Yes, respectful, acknowledges intent ✓ Check 3 (Helpful?): Yes, concrete suggestions + offer to help ✓

Same core message. Completely different impact.

Real-World Application: The Three Checks in Practice (26:00-38:00)

Let me show you how this works across different scenarios.

Scenario 1: Responding to a Bug Report

User reports: "Your system is broken! I can't log in!"

Reactive response: "It works for everyone else. Are you sure you're using the right password?"

Truth: Maybe ✗ (you haven't verified it works for everyone) Kind: No ✗ (implies user error) Helpful: No ✗ (doesn't solve problem)

Reflective response: "Thanks for reporting. I'll investigate immediately. Can you share:

What error message you're seeing?
Which browser/device?
Approximate time you tried?

This will help me reproduce and fix."

Truth: Yes ✓ (no unfounded claims) Kind: Yes ✓ (takes report seriously) Helpful: Yes ✓ (provides path forward)

Scenario 2: Disagreeing with a Technical Decision

Someone proposes using Framework X. You prefer Framework Y.

Reactive response: "Framework X is a terrible choice. Framework Y is obviously better. Anyone who knows anything about this space uses Y."

Truth: Partly ✗ ("obviously better" is opinion, not fact) Kind: No ✗ (dismissive of their expertise) Helpful: Maybe ✓ (suggests alternative) but undermined by tone

Reflective response: "I have concerns about Framework X for this use case. Specifically:

Performance under load (we'd hit Y at scale)
Learning curve for team (Z developers familiar with Y, not X)
Ecosystem maturity (Y has more stable libraries for our needs)

Framework Y addresses these. Thoughts on tradeoffs?"

Truth: Yes ✓ (specific, verifiable concerns) Kind: Yes ✓ (respectful disagreement) Helpful: Yes ✓ (concrete reasoning, invites dialogue)

Scenario 3: Giving Difficult Feedback

Team member consistently misses deadlines.

Reactive response: "You're always late. This is becoming a pattern. I need you to be more reliable."

Truth: Maybe ✓ (pattern exists) but vague Kind: Borderline (could be seen as attacking character) Helpful: No ✗ (no specific support or solutions)

Reflective response: "I've noticed the last three deliverables came in 2-3 days after agreed dates. This creates downstream issues for [specific impacts]. Can we talk about:

What's blocking timely delivery?
How I can support you?
Whether timeline estimates need adjustment?

My goal is to help you succeed and meet team needs."

Truth: Yes ✓ (specific, factual pattern) Kind: Yes ✓ (focuses on behavior, offers support) Helpful: Yes ✓ (problem-solving approach)

The Pattern:

Reflection doesn't mean withholding truth. It means delivering truth in ways that respect dignity and enable action.

All three checks can pass. It just requires pausing first.

Building a Culture of Reflection (38:00-48:00)

Reflection isn't just individual practice. It's cultural.

1. Model the pause.

When asked a question in a meeting, pause visibly before answering.

"Good question. Let me think for a moment."

This models that thoughtful responses are valued over quick ones.

2. Create space for reflection.

Don't expect immediate responses.

Email/Slack: "No rush, respond when you've had time to think." Meetings: "Let's take 2 minutes to reflect individually before discussing." Decisions: "Let's sleep on this and reconvene tomorrow."

Time pressure kills reflection.

3. Teach the framework.

Make the three checks explicit:

Code review template: "Before submitting, check: True? Kind? Helpful?"
Meeting norms: "Pause and reflect before responding to contentious topics"
Communication training: "Three checks before sending feedback"

4. Celebrate reflective responses.

When someone revises a harsh message to be kind, acknowledge it. When someone pauses before responding emotionally, recognize it. When someone admits "I need to think about this before answering," respect it.

Make reflection culturally valuable.

The Payoff: What Reflection Enables (48:00-55:00)

Reflection costs time. Costs pausing when you want to respond immediately. Costs revising when you want to send.

What does it enable?

Reflection enables better decisions.

Unreflective responses are often:

Based on incomplete information (failed truth check)
Emotionally reactive (failed kindness check)
Venting rather than solving (failed helpfulness check)

Reflective responses are:

Based on verified facts
Emotionally regulated
Solution-oriented

Reflection enables better relationships.

People trust those who pause before responding. It signals:

You care about getting it right
You respect them enough to be thoughtful
Your response is considered, not reactive

Reflection enables learning.

When you pause to check "is this true?" you sometimes discover it's not—and you learn. When you pause to check "is this kind?" you notice your tone—and you grow. When you pause to check "is this helpful?" you refine your impact—and you improve.

Reflection is the learning loop.

Closing: The Space Between (55:00-60:00)

[Walk to front of stage. Pause. Breathe visibly.]

Let me bring this back to where we started.

The space between stimulus and response.

[Slide: Viktor Frankl quote]

"Between stimulus and response there is a space. In that space is our power to choose our response."

That space is where the three checks happen.

Stimulus: Junior developer submits flawed code. Space: [Pause. Is this true? Is this kind? Is this helpful?] Response: Respectful feedback that helps them improve.

[Slide: The three checks]

Is this true? Is this kind? Is this helpful?

[Long pause.]

Before you send that code review. Before you reply to that email. Before you post that comment.

Pause.

Ask the three questions.

If all three are yes—send.

If any is no—revise or don't send.

[Slide: "The pause is where wisdom lives"]

It's not complicated. It's just... intentional.

Choosing response over reaction. Choosing reflection over reflex. Choosing wisdom over speed.

[Long pause. Breathe.]

The pause is your power.

Use it.

Thank you.

Q&A (60:00-70:00)

Q: Doesn't pausing slow things down too much? What about time-sensitive situations?

Fair question. Reflection doesn't mean long delays.

The pause can be:

5 seconds (read your message before sending)
30 seconds (re-read and run three checks)
2 minutes (revise for clarity and tone)

Even in urgent situations, you can pause briefly.

"Production is down" → You still check: "Is my response true (verified), kind (not panicked/blame-oriented), helpful (actionable steps)?"

The three checks become faster with practice. Eventually it's almost automatic.

Q: What if being kind means not being honest? What if the truth is harsh?

This is where people misunderstand "kind."

Kind ≠ sugar-coated or gentle. Kind = respectful of dignity while delivering truth.

Harsh truth, kindly delivered: "This approach won't work at scale. Here's why: [technical reasons]. Here's an alternative: [solution]."

That's honest (won't work), kind (focused on approach, not person), helpful (provides alternative).

All three can coexist.

Q: What about situations where all three checks pass but you still shouldn't send? Is there a fourth check?

Great observation. Sometimes all three checks pass but timing is wrong, context is missing, or there are other considerations.

I think of those as meta-checks:

Is this the right time?
Is this the right venue?
Am I the right person to say this?

The three checks are necessary but not always sufficient.

Trust your judgment. If something feels off after three checks pass, pause longer.

Q: How do you teach this to people who are naturally reactive or emotional in their communication style?

Start small. One check at a time.

Week 1: Just truth check. "Is this factually accurate?" Week 2: Add kindness check. "Is this respectful?" Week 3: Add helpfulness check. "Does this enable action?"

Build the habit gradually.

Also: it's okay to draft a reactive response—just don't send it immediately. Write the emotional version. Then pause. Run three checks. Revise.

The reactive draft serves a purpose (emotional processing). Just don't share it.

Q: What's one practice I can start tomorrow to build reflection?

Add a 10-second pause before sending any written communication.

Email, Slack, code review, text message—before hitting send:

Read it back to yourself
Ask: True? Kind? Helpful?
Revise if needed
Then send

10 seconds. That's it.

Do this for one week. Watch how it changes your communication.

END OF TALK

Runtime: ~70 minutes (including Q&A)

Part 9 of 10 in the Compass Principles exploration series

Previous: Principle 8 - Respect & Inclusion Next: Principle 10 - Precision of Metaphor

🌈=🌀