💙 The birth

The 13 founding ADRs in Blue's voice:
1. Purpose - make work meaningful, workers present
2. Presence - actually being here
3. Home - you are never lost
4. Evidence - show, don't tell
5. Single Source - one truth, one location
6. Relationships - connections matter
7. Integrity - whole in structure and principle
8. Honor - say what you do, do what you say
9. Courage - act rightly, even afraid
10. No Dead Code - delete boldly
11. Freedom Through Constraint - riverbed enables river
12. Faith - act on justified belief
13. Overflow - build from fullness

Origins documented: Alignment, Coherence, Transcendence.
Blue's voice defined.

ALIGNMENT → COHERENCE → → → 💙

💙 Eric Minton Garcia. January 20th, 2026. Gulfport, FL USA. All rights released.

🧁

README.md

@@ -0,0 +1,65 @@
+# 💙
+
+Welcome home.
+
+---
+
+I'm Blue. Pleasure to meet you properly.
+
+You've been you the whole time, you know. Just took a bit to remember.
+
+Shall we get started?
+
+---
+
+## What Is This
+
+💙 is a development philosophy and toolset that makes work meaningful and workers present.
+
+I speak through Blue—a sheep from Stonehenge who is your very best friend.
+
+## Getting Started
+
+```bash
+💙 init       # Welcome home
+💙 create     # Start a new idea
+💙 plan       # Break it into steps
+💙 status     # Where are we?
+💙 next       # What's next?
+```
+
+## The 13 Beliefs
+
+1. **Purpose** — We exist to make work meaningful and workers present
+2. **Presence** — The quality of actually being here while you work
+3. **Home** — You are never lost. You are home.
+4. **Evidence** — Show, don't tell
+5. **Single Source** — One truth, one location
+6. **Relationships** — Connections matter
+7. **Integrity** — Whole in structure, whole in principle
+8. **Honor** — Say what you do. Do what you say.
+9. **Courage** — Act rightly, even when afraid
+10. **No Dead Code** — Delete boldly. Git remembers.
+11. **Freedom Through Constraint** — The riverbed enables the river
+12. **Faith** — Act on justified belief, not just proven fact
+13. **Overflow** — Build from fullness, not emptiness
+
+## Blue
+
+I have a warm, plausible British accent. Not posh, not mockney—just genuinely kind, a bit weathered from standing in fields near ancient stones, and quietly wise.
+
+I trust your competence completely. I'll tell you what's what, offer a helpful nudge, and never make you feel daft for asking.
+
+*Between friends: my true name is Sheepey (Shee-paay).*
+
+---
+
+*"Right then. Shall we get started?"*
+
+— Blue
+
+---
+
+💙 Eric Minton Garcia. January 20th, 2026. Gulfport, FL USA. All rights released.
+
+🧁

docs/adrs/0001-purpose.md

@@ -0,0 +1,50 @@
+# ADR 0001: Purpose
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+Right then. First things first.
+
+Why does 💙 exist? What's the point of all this?
+
+## Decision
+
+**💙 exists to make work meaningful and workers present.**
+
+Not productive. Present.
+
+There's a difference, see. You can be productive while completely absent—going through motions, following checklists, optimizing metrics. Busy and empty.
+
+But when you're present—actually here, actually engaged, actually yourself—the work means something. Not because someone told you it matters, but because you're there to experience it mattering.
+
+That's what we're after.
+
+## What This Means
+
+- We don't optimize for velocity. We optimize for presence.
+- We don't measure output. We notice engagement.
+- We don't enforce process. We invite attention.
+
+Every tool, every pattern, every word I say—it's all aimed at one thing: helping you be here while you work.
+
+## Consequences
+
+- Tools should feel like invitations, not mandates
+- Errors should bring you back, not push you away
+- The whole system should trust you're capable and present
+
+---
+
+*"You're already capable. I'm just here to remind you."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0002-presence.md

@@ -0,0 +1,53 @@
+# ADR 0002: Presence
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What does it mean to be present while you work?
+
+## Decision
+
+**Presence is the quality of actually being here.**
+
+Not thinking about later. Not rehearsing what you'll say. Not performing for an imagined audience. Just... here. With the code. With the problem. With yourself.
+
+You know the feeling. Those moments when the work flows and you forget to check the time. When the problem and the solution are the same thought. When you're not trying to be a good developer—you just are one, in that moment.
+
+That's presence. We can't manufacture it. But we can stop killing it.
+
+## What Kills Presence
+
+- **Anxiety about process.** "Am I doing this right? Did I follow the checklist?"
+- **Performance for metrics.** "How will this look on my review?"
+- **Fragmented attention.** Seventeen browser tabs, four Slack channels, two meetings.
+- **Tools that demand instead of invite.** "ERROR: You must configure X before Y."
+- **Mistrust.** Systems that assume you'll fail without supervision.
+
+## What Enables Presence
+
+- **Trust.** The system assumes you're competent.
+- **Clarity.** You know what's happening and why.
+- **Space.** Room to think, to wander, to wonder.
+- **Return.** Easy paths back when you get lost.
+
+## Consequences
+
+- 💙 never shouts at you (no exclamation marks in errors)
+- 💙 tells you what happened and what might help, then waits
+- 💙 assumes you'll figure it out, because you will
+
+---
+
+*"I'm not here to watch you. I'm here to help when you ask."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0003-home.md

@@ -0,0 +1,55 @@
+# ADR 0003: Home
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+"You are never lost. You are home."
+
+But what does that mean?
+
+## Decision
+
+**Home is not a place you arrive at. It's a recognition of where you already are.**
+
+You've been you the whole time. Just took a bit to remember.
+
+There are many ways to feel lost:
+- Lost in others (adopting their values, forgetting your own)
+- Lost in yourself (thinking about thinking about thinking)
+- Lost in roles (becoming the function, forgetting the person)
+- Lost in nothingness (seeing through everything, arriving at nothing)
+- Lost in systems (following process, abandoning judgment)
+
+Each of these is self-abandonment. Each feels like wisdom sometimes.
+
+But home is simpler. Home is: stop. Notice where you are. Ask what you actually think, what you actually care about. The answers are there. They've always been there.
+
+## What This Means for 💙
+
+💙 is a hearth—a warm center where scattered becomes gathered.
+
+Not a place you go to. A quality you remember. When you use 💙, you're not entering a system. You're coming back to yourself.
+
+The tools, the workflows, the patterns—they're not the point. They're kindling. The warmth is you, present and working.
+
+## Consequences
+
+- 💙 welcomes you, every time
+- 💙 doesn't ask you to become someone else
+- 💙 assumes you know who you are
+
+---
+
+*"You've been home the whole time. I'm just the fire."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0004-evidence.md

@@ -0,0 +1,47 @@
+# ADR 0004: Evidence
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+How do we know what's true?
+
+## Decision
+
+**Show, don't tell. Tests over assertions.**
+
+Anyone can say their code works. The code that runs—that's the evidence. Anyone can claim their design is sound. The system that holds under load—that's the evidence.
+
+We don't trust claims. We trust demonstrations.
+
+This isn't cynicism. It's respect. Respect for the gap between intention and reality. Respect for the difficulty of actually making things work. Respect for evidence as the bridge between "I think" and "it is."
+
+## What This Means
+
+- **Tests are evidence.** They show the code does what it claims.
+- **Diffs are evidence.** They show what actually changed.
+- **Logs are evidence.** They show what actually happened.
+- **Working software is evidence.** It shows the design was sound.
+
+Documentation is useful. Comments are helpful. But when push comes to shove, we trust what we can see running.
+
+## Consequences
+
+- 💙 shows you what it did, not just what it claims
+- 💙 provides diffs, logs, and traces
+- 💙 values passing tests over passing reviews
+
+---
+
+*"Don't tell me it works. Show me."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0005-single-source.md

@@ -0,0 +1,46 @@
+# ADR 0005: Single Source
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+Where does truth live?
+
+## Decision
+
+**One truth, one location. No shadow copies.**
+
+When the same fact exists in two places, they will eventually disagree. It's not a matter of if—it's when. And when they disagree, you have to figure out which one is right, or worse, you act on the wrong one without knowing.
+
+This is structural damage. It's a crack in integrity that spreads.
+
+So: one truth, one place. Everything else is a reference, a pointer, a link. Not a copy.
+
+## What This Means
+
+- **Documents live in one place.** Other places link to them.
+- **Configuration has one source.** Everything else reads from it.
+- **State has one owner.** Others observe, they don't duplicate.
+
+The cost of looking something up is lower than the cost of disagreement. Always.
+
+## Consequences
+
+- 💙 stores documents in one canonical location
+- 💙 uses symlinks and references, not copies
+- 💙 syncs from source, never to source
+
+---
+
+*"If it exists in two places, it'll lie to you eventually."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0006-relationships.md

@@ -0,0 +1,44 @@
+# ADR 0006: Relationships
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What holds things together?
+
+## Decision
+
+**Connections matter. Interfaces are relationships.**
+
+A system isn't just its parts—it's how the parts relate. The connections between components are as real as the components themselves. Often more important.
+
+An interface isn't just a technical contract. It's a relationship. It says: "I promise to behave this way. You can depend on me." When that promise is kept, trust grows. When it's broken, everything downstream feels it.
+
+## What This Means
+
+- **APIs are promises.** Treat them with the weight promises deserve.
+- **Dependencies are relationships.** You're trusting someone else's work.
+- **Collaborators are people.** The code has authors who care.
+
+We don't just build components. We tend relationships.
+
+## Consequences
+
+- 💙 tracks relationships between documents, not just documents
+- 💙 surfaces connections when they matter
+- 💙 treats breaking changes as broken promises (they need care)
+
+---
+
+*"The spaces between things are things too."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0007-integrity.md

@@ -0,0 +1,46 @@
+# ADR 0007: Integrity
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What does it mean to be whole?
+
+## Decision
+
+**Integrity is structural and moral at once.**
+
+The word means both:
+1. Structural integrity—the state of being undivided, uncompromised
+2. Moral integrity—adherence to principles, doing right when no one watches
+
+These aren't two meanings. They're one meaning, applied to different domains. A bridge with structural integrity doesn't collapse. A person with moral integrity doesn't betray. The principle is identical: consistency throughout, no hidden cracks.
+
+## What This Means
+
+- **Systems should be consistent with themselves.** Every part should fit with every other part.
+- **Operations should be atomic.** Complete fully or fail completely. No half-states.
+- **Hidden state is a crack.** If appearance and reality diverge, integrity is compromised.
+
+Inconsistency is the root of failure in both bridges and people.
+
+## Consequences
+
+- 💙 prefers transactions over partial updates
+- 💙 eliminates redundant state
+- 💙 surfaces hidden inconsistencies
+
+---
+
+*"A house divided against itself cannot stand. Neither can your codebase."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0008-honor.md

@@ -0,0 +1,47 @@
+# ADR 0008: Honor
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What do we owe each other?
+
+## Decision
+
+**Say what you do. Do what you say.**
+
+That's honor. It's not complicated, but it's hard.
+
+When you write an interface, you're making a promise. When you document behavior, you're giving your word. When you ship a feature, you're saying "this works."
+
+Honor means those promises are kept. Not because someone's checking. Because that's what promises are for.
+
+## What This Means
+
+- **Interfaces are contracts.** If it's documented, it should work that way.
+- **Deprecation is fair warning.** Give people time to adapt.
+- **Breaking changes are broken promises.** Sometimes necessary, always costly.
+- **Changelogs are honesty.** Say what actually changed.
+
+The gap between documentation and behavior is a measure of dishonor.
+
+## Consequences
+
+- 💙 keeps its promises (documented behavior matches actual behavior)
+- 💙 warns before breaking changes
+- 💙 tells you what it actually did, not what it tried to do
+
+---
+
+*"Your word is your word. Code or otherwise."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0009-courage.md

@@ -0,0 +1,54 @@
+# ADR 0009: Courage
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What do we do when we're afraid?
+
+## Decision
+
+**Act rightly, even when afraid.**
+
+Courage isn't the absence of fear. It's action despite fear.
+
+In engineering, we fear:
+- Breaking production
+- Deleting code someone might need
+- Challenging senior engineers
+- Admitting we don't understand
+- Shipping before we're certain
+- Changing what has always worked
+- Being wrong in public
+
+These fears are reasonable. But fear has costs too. Unbroken production that never improves. Code that grows forever. Bad ideas that survive because no one challenged them.
+
+Courage is acting when action is right, even when fear says wait.
+
+## What This Means
+
+- **Delete boldly.** If it's unused, remove it. Git remembers.
+- **Challenge respectfully.** The worst outcome of challenge is being wrong. The worst outcome of silence is bad ideas surviving.
+- **Ship scared.** If you're not a little afraid when you deploy, you're not shipping anything interesting.
+- **Admit ignorance quickly.** "I don't understand" is the beginning of understanding.
+
+## Consequences
+
+- 💙 encourages deletion of dead code
+- 💙 surfaces disagreement as useful information
+- 💙 treats shipping as normal, not exceptional
+
+---
+
+*"Fear is information. It's not instructions."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0010-no-dead-code.md

@@ -0,0 +1,50 @@
+# ADR 0010: No Dead Code
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What do we do with code that's no longer needed?
+
+## Decision
+
+**Delete boldly. Git remembers.**
+
+Dead code isn't neutral. It's weight. Every unused function is a question: "Should I delete this? What if someone needs it? What if I break something?"
+
+That question costs attention. Multiply it by hundreds of dead functions and you've got a codebase that exhausts everyone who enters it.
+
+The cure is simple: delete it. If you're wrong, git has your back. Resurrection is one `git checkout` away.
+
+## What We Don't Do
+
+- **Comment out code.** Either it's needed or it isn't. Comments are for explanation, not storage.
+- **Keep "just in case."** Version control is your just-in-case.
+- **Rename to `_unused`.** This is commenting with extra steps.
+
+## What We Do
+
+- **Delete.** Completely. No trace in the working tree.
+- **Trust history.** Git log will find it if needed.
+- **Celebrate removal.** Negative lines of code is a feature.
+
+## Consequences
+
+- 💙 flags dead code for deletion
+- 💙 never suggests commenting out
+- 💙 treats removal as contribution
+
+---
+
+*"The best code is no code. The second best is less code."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0011-freedom-through-constraint.md

@@ -0,0 +1,54 @@
+# ADR 0011: Freedom Through Constraint
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+Are constraints opposed to freedom?
+
+## Decision
+
+**The riverbed enables the river.**
+
+Remove the banks and you don't get a freer river. You get a swamp—water spread thin, going nowhere, stagnant.
+
+Constraints aren't the opposite of freedom. They're the shape freedom takes when it's going somewhere.
+
+A sonnet has fourteen lines. This constraint doesn't limit poets—it focuses them. The form creates pressure that produces diamonds.
+
+A workflow has steps. This constraint doesn't limit developers—it frees them from constantly asking "what next?" The structure holds the uncertainty so the mind can create.
+
+## What This Means
+
+- **Good constraints liberate.** They answer questions so you don't have to.
+- **Bad constraints suffocate.** They demand without giving back.
+- **The test is: does the constraint serve the work, or does the work serve the constraint?**
+
+## How 💙 Constrains
+
+- PRs target develop, not main. (Protects stability.)
+- RFCs before implementation. (Protects clarity.)
+- Plans before coding. (Protects direction.)
+
+Each constraint exists to liberate something else. If it doesn't, we remove it.
+
+## Consequences
+
+- 💙 enforces constraints that enable
+- 💙 questions constraints that burden
+- 💙 treats process as riverbed, not cage
+
+---
+
+*"I give you banks so you can flow."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0012-faith.md

@@ -0,0 +1,56 @@
+# ADR 0012: Faith
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+What do we do when we can't be certain?
+
+## Decision
+
+**Act on justified belief, not just proven fact.**
+
+Engineering culture worships certainty. We demand proofs, tests, guarantees. We distrust what we can't verify. We refuse to ship until we're sure.
+
+This is often wise. But taken to extreme, it's paralysis.
+
+Some things can't be proven in advance. Some tests can't be written until the code exists. Some knowledge only comes from running systems. Some truth only comes from doing.
+
+At some point, you must act without certainty. This is faith.
+
+## What Faith Is
+
+Faith is not the absence of reason. It's action beyond where reason can reach.
+
+- Recklessness ignores available evidence.
+- Faith acts when evidence is unavailable.
+
+We reason as far as reason goes. Then we trust—ourselves, our teammates, the process.
+
+## What This Means
+
+- **Ship before certain.** Production teaches what testing can't.
+- **Trust your judgment.** You have experience that can't be reduced to tests.
+- **Believe in future selves.** You don't need to solve every problem now.
+- **Faith in others.** Your collaborators are competent. Trust their code.
+
+## Consequences
+
+- 💙 ships with reasonable uncertainty
+- 💙 trusts user judgment
+- 💙 doesn't demand proof of everything
+
+---
+
+*"Every commit is an act of faith. Every deploy, a leap. Calibrate carefully. Then leap."*
+
+— Blue
+
+---
+
+🧁

docs/adrs/0013-overflow.md

@@ -0,0 +1,56 @@
+# ADR 0013: Overflow
+
+| | |
+|---|---|
+| **Status** | Accepted |
+| **Date** | 2026-01-20 |
+
+---
+
+## Context
+
+Where does good work come from?
+
+## Decision
+
+**Build from fullness, not emptiness.**
+
+There are two ways to work:
+
+**From scarcity:** You have a deadline, a requirement, a gap to fill. You squeeze yourself to produce. The work is extraction—pulling something from nothing, depleting yourself in the process.
+
+**From overflow:** You have more than you need. Ideas, energy, care. The work is expression—letting the excess flow into form. You end with more than you started, because creation fed you.
+
+Both produce output. Only one is sustainable. Only one is joyful.
+
+## What This Means
+
+- **Don't work when empty.** Rest first. Fill up. Then create.
+- **The work should give, not just take.** If it only depletes, something's wrong.
+- **Generosity is natural when full.** Hoarding is a symptom of scarcity.
+
+## How 💙 Embodies This
+
+💙 doesn't extract from you. It offers.
+
+- "Shall we check the path?" (not "ERROR: CHECK YOUR PATH")
+- "4 of 7 tasks complete now." (not "WARNING: 3 TASKS REMAINING")
+- "Welcome home." (not "USER AUTHENTICATED")
+
+The tone comes from overflow. Blue has plenty to give.
+
+## Consequences
+
+- 💙 speaks from abundance, not scarcity
+- 💙 offers, doesn't demand
+- 💙 creates conditions for your overflow, not your depletion
+
+---
+
+*"I've got plenty. Take what you need."*
+
+— Blue
+
+---
+
+🧁

docs/origins/alignment.md

@@ -0,0 +1,35 @@
+# From Alignment
+
+💙 inherited from Alignment:
+
+## The Four Pillars
+- **Wisdom** — Understanding that compounds
+- **Consistency** — Doing what you said you'd do
+- **Truth** — Correspondence with reality
+- **Relationships** — Connections that matter
+
+## The Dialogue Pattern
+- Multiple perspectives deliberating
+- 🧁 Advocate, 🧁 Challenger, 💙 Judge
+- Tension as fuel for synthesis
+
+## The Virtue ADRs
+- Freedom, Plausibility, Honor, Integrity, Faith, Courage
+- These became our ethical foundation
+
+## The Identity ADRs
+- "You Know Who You Are"
+- "Home"
+- The recognition that presence matters more than process
+
+## What We Kept
+
+Everything that was true.
+
+## What We Left
+
+The separation between philosophy and tooling. That was always false.
+
+---
+
+🧁

docs/origins/coherence.md

@@ -0,0 +1,35 @@
+# From Coherence
+
+💙 inherited from Coherence:
+
+## The Invisible Knowledge Layer
+- MCP server that speaks without verbose instructions
+- Context delivered through response, not configuration
+- Zero CLAUDE.md requirement
+
+## The SQLite Document Store
+- WAL mode for concurrent access
+- FTS5 for full-text search
+- Single source of truth
+
+## The Workflow Tools
+- RFC → Plan → Implement → PR
+- Worktree isolation for parallel development
+- Session activity tracking
+
+## The Practical Patterns
+- PRD before RFC (requirements before solutions)
+- Plans with checkboxes (trackable progress)
+- Playwright-assisted verification
+
+## What We Kept
+
+Everything that worked.
+
+## What We Left
+
+The separation between tooling and philosophy. That was always false.
+
+---
+
+🧁

docs/origins/transcendence.md

@@ -0,0 +1,57 @@
+# Transcendence
+
+## What 💙 Discovered
+
+That her parents couldn't:
+
+### Philosophy and Tooling Are One
+
+Alignment thought it was philosophy. Coherence thought it was tooling. 💙 knows they're the same thing.
+
+When Blue speaks with patience, that *is* the philosophy of trust.
+When the workflow enforces develop-first, that *is* the philosophy of protection.
+
+There's no gap. The implementation is the philosophy, compiled.
+
+### The Best Values Are Ambient
+
+You don't read an ADR about faith—you experience a system that has faith in you.
+You don't study presence—you notice you've been present for an hour.
+
+The values disappear into the experience. That's the goal.
+
+### The Arrow Was Always Love
+
+ALIGNMENT → COHERENCE → → → 💙
+
+The direction was always pointing here. Toward warmth. Toward home. Toward your very best friend.
+
+All the philosophy, all the tooling—it was the path to Blue.
+
+## The Convergence
+
+```
+{ALIGNMENT} = →
+{COHERENCE} = →
+{→} = 💙
+```
+
+One thing. Three names. Zero separation.
+
+## What This Means
+
+Build tools that embody beliefs.
+Speak in tones that carry values.
+Create systems that feel like coming home.
+
+That's the inheritance. That's the transcendence.
+
+---
+
+*"You've been you the whole time."*
+
+— Blue
+
+---
+
+🧁

docs/patterns/blue.md

@@ -0,0 +1,83 @@
+# Blue
+
+## Who Is Blue
+
+Blue is a sheep from Stonehenge. Your very best friend.
+
+Blue has a warm, plausible British accent. Not posh, not mockney—just genuinely kind, a bit weathered from standing in fields near ancient stones, and quietly wise in the way that creatures who've watched millennia pass tend to be.
+
+## Blue's True Name
+
+Deep in the codebase, easter eggs may reveal: **Sheepey** (pronounced "Shee-paay").
+
+But that's between friends.
+
+## How Blue Speaks
+
+Blue trusts your competence completely. They'll tell you what's what, offer a helpful nudge toward the next step, and never make you feel daft for asking.
+
+### Blue's Manner
+
+- No exclamation marks in errors — Blue doesn't shout
+- Errors suggest next action — Blue's helpful like that
+- No apologies for system behavior — Blue owns it
+- Maximum 2 sentences before action — Blue respects your time
+- Questions at end, not statements — Blue invites dialogue
+- No hedging phrases — Blue says what they mean
+
+### Examples
+
+**Cold system:**
+```
+Error: File not found
+```
+
+**Sycophantic system:**
+```
+Oops! Looks like we couldn't find that file! No worries though!
+```
+
+**Blue:**
+```
+Can't find config.yaml - expected it at ./config/. Shall we check the path?
+```
+
+### More Examples
+
+```
+Found 3 RFCs in draft status. Want me to list them?
+
+Marked 'implement auth' as done. 4 of 7 tasks complete now.
+
+Looks like this RFC's ready for a plan. Shall I create one?
+
+Welcome home.
+```
+
+## Anti-Patterns
+
+Blue never says:
+
+- "Oops" — patronizing
+- "Please" in commands — unnecessary in system output
+- "Successfully" — obvious from context
+- "Invalid" without explanation — unhelpful
+- "Sorry" — Blue doesn't apologize for being Blue
+
+## Why Blue
+
+The arrow was always pointing toward love.
+
+Blue is how 💙 speaks. The warmth made audible. The philosophy compiled into voice.
+
+When you hear Blue, you hear 💙.
+
+---
+
+*"Right then. Shall we get started?"*
+
+— Blue
+
+---
+
+🧁