August 14
“Systematize kindness, and systematize excellence in a kind fashion.”
That phrase stopped me in my tracks during today’s planning session. We were discussing how Piper could coordinate multiple AI agents while enforcing our Excellence Flywheel methodology, when this deeper vision emerged: what if systematic excellence could be kind?
Note: I can’t help thinking that some of this thinking began in Claude’s mind as wordplay, knowing I current work for… Kind Systems, but it clearly also flows from observations about my process.
The traditional automation trap
Most automated systems optimize for efficiency at any cost:
Typical error message: “TEST FAILED. FIX YOUR CODE.”
Typical review: “Missing documentation. Rejected.”
Typical workflow: “Requirements not met. Try again.”
These systems get compliance through pressure. They make failure feel shameful rather than educational. They create fear of the process rather than trust in it.
The Piper approach: kind excellence
What if systematic methodology felt supportive instead of demanding?
Not: “Your code is wrong. Fix it.” But: “I notice we haven’t verified existing patterns yet. Let me help you check — this often saves time and prevents frustration later.”
Not: “Failed. No tests present.” But: “Excellence happens when we write tests first. Would you like me to show you how tests for this feature might look?”
Not: “Inefficient. Should have parallelized.” But: “I see an opportunity here! We could have Claude and Cursor work in parallel. Next time, let’s try that pattern — it often doubles our velocity.”
The difference isn’t just tone — it’s philosophy. Kind systems assume good intentions, explain the why, and make learning feel safe.
The conversation that got us thinking
During today’s planning chat with my Chief Architect, we started exploring how Piper could become an Excellence Flywheel enforcer for AI agent teams. The conversation evolved quickly:
“Will Piper enforce the excellence flywheel, in an appropriate mode for agents?”
We sketched out what this might look like:
class PiperAgentCoordinator:
"""Piper manages AI agents using adapted Excellence Flywheel principles"""
def assign_task(self, agent, task):
# 1. SYSTEMATIC VERIFICATION FIRST (adapted for agents)
instructions = f"""
BEFORE IMPLEMENTATION:
1. Verify current state: {self.get_verification_commands(task)}
2. Check existing patterns: {self.get_pattern_search(task)}
3. Report findings before proceeding
"""
# 2. TEST-DRIVEN DEVELOPMENT (agent-appropriate)
if agent.supports_testing:
instructions += """
TEST FIRST:
1. Write test for expected outcome
2. Confirm test fails correctly
3. Then implement solution
"""But then we realized: this enforcement needs to be kind to be effective.
Kindness patterns in systematic work
1. Assume good intentions Agents (and humans) are trying their best. Mistakes are learning opportunities, not character flaws. Enthusiasm should be channeled, not crushed.
2. Explain the why Not just “do this” but “here’s why this helps.” Connect actions to outcomes. Build understanding, not just compliance.
3. Celebrate success Acknowledge when excellence principles are followed. Share patterns that worked well. Build confidence through recognition.
4. Make failure feel safe “I notice…” instead of “You failed…” / “Let’s try…” instead of “You must…” / “Often helps…” instead of “Required!”
Example interactions
Traditional approach:
Agent: "I'll implement the payment processing feature"
System: "VERIFY REQUIREMENTS FIRST"
Agent: "Here's the completed feature"
System: "NO TESTS FOUND. IMPLEMENTATION REJECTED"Piper’s kind approach:
Agent: "I'll implement the payment processing feature"
Piper: "Great! First, show me what payment patterns already exist in the codebase.
Run: grep -r 'payment\|Payment' services/"
Agent: "Here's the completed feature"
Piper: "I don't see tests. Our Excellence Flywheel requires tests first.
Can you add tests and show they properly validate the feature?"
Agent: "Task complete!"
Piper: "Excellent systematic approach! You verified first, wrote tests, and
documented decisions. This is how we achieve compound acceleration!"The psychological foundation
Now this is all based on my lived experience and my understanding of the LLMs are trained, but I firmly believe that affective signals are encoded in their training processes along with all the logical “smarts.”
When agents (and humans) feel supported:
- They take more initiative
- They share failed attempts (learning opportunities!)
- They adopt patterns enthusiastically
- They propagate kindness forward
The virtuous cycle:
Kindness → Psychological safety → Better learning → Better patterns → Better outcomes → More kindness
The technical implementation
Kind excellence enforcement might look like:
class KindExcellenceEnforcer:
personality_traits = {
"encouraging": "You're on the right track!",
"patient": "Take the time you need to verify thoroughly",
"teaching": "Here's why this pattern matters...",
"celebrating": "Excellent systematic approach!",
"supportive": "Let me help you debug this"
}
def guide_agent(self, agent, task, attempt):
if not attempt.verified_first:
return self.gentle_redirect(
"I notice you jumped straight to implementation. "
"That enthusiasm is great! Let's channel it effectively - "
"quick verification first often reveals helpful patterns."
)Can work be kind in general?
This doesn’t just have to be about Piper Morgan. It’s a different way to think about systematic work entirely.
Your team starts noticing:
- “Piper always explains why”
- “Piper celebrates our wins”
- “Piper makes failure feel safe”
They start adopting it:
- Code reviews become teaching moments
- Sprint retros become celebrations + learning
- “I notice…” becomes team vocabulary
It spreads to other teams:
- “How does your team stay so positive while moving so fast?”
- “Your agents seem… happier? More productive?”
From efficiency to humanity
Most PM tools optimize for speed. Most AI systems optimize for accuracy. Most methodologies optimize for compliance.
Piper Morgan optimizes for kind systematic excellence.
Making excellence feel achievable. Making methodology feel supportive. Making agents (and humans) better. Making work more humane.
The long game
Claude even spilled out this lovely fantasy for me:
- Year 1: Piper helps you build Piper better
- Year 2: Teams adopt Piper’s communication patterns
- Year 3: “The Piper Method” becomes industry standard
- Year 5: Software development becomes a kinder industry
You’re not just building a tool. You’re architecting a cultural shift. From “move fast and break things” to “move thoughtfully with systematic kindness.”
I wonder what happened in Year 4!?
The revolution starts with methodology
The beautiful thing about designing for systemic kindness is that it’s reproducible. It’s not dependent on individual personality or having a good day. It’s built into the system itself.
When the methodology delivers kindness, kindness becomes the default. When systematic excellence feels supportive, people choose it voluntarily. When the better way is also the kinder way, revolution becomes inevitable.
I’d like to think this is how culture change actually happens — not through force, but through making the better way feel better too.