Why MurphySig
Two laws. Two practices. One standard.
The Name
MurphySig is named after Kevin Murphy—but more importantly, it’s named after Murphy’s Law.
The law states: “Anything that can go wrong will go wrong.”
This isn’t pessimism. It’s engineering realism. Code will have bugs. Models will hallucinate. Assumptions will be invalidated. The question isn’t whether mistakes happen, but whether you can trace them, learn from them, and prevent them from recurring.
The surname makes it personal. The law makes it practical. The signature makes it permanent.
Fiduciary Engineering: Provenance as Respect
Software engineering has borrowed from other disciplines for decades: design patterns from architecture, agile from manufacturing, version control from law. But we’ve missed one critical practice: fiduciary responsibility.
A fiduciary acts in the best interest of those they serve. They disclose conflicts of interest. They document their reasoning. They don’t hide uncertainty or offload risk onto others.
When you ship code without provenance, you’re asking users to trust a black box. They don’t know:
- Who made it
- How confident the makers were
- What tools were used
- What assumptions were baked in
MurphySig is fiduciary engineering. It says: “I made this, with these tools, at this confidence level. You deserve to know.”
That’s not just documentation. That’s respect.
Origin: How Things Are Made Matters
This standard emerged from a simple observation: the process shapes the output, and users deserve to understand the process.
If you’ve ever worked on accessibility, you know this intuitively. A dyslexic user doesn’t just care what the interface says—they care about how it’s structured. Font choice, spacing, contrast—these aren’t cosmetic. They’re foundational.
The same applies to AI-assisted work. When an AI generates code, documentation, or creative work, the provenance of that output changes its meaning:
- Was this human-written with AI editing, or AI-written with human review?
- How confident were the collaborators?
- What were the known limitations of the tools used?
Users (and future models) deserve to know. Not because you’re hiding flaws, but because context is part of the artifact.
MurphySig codifies this. It makes the “how” legible, not just the “what”.
Murphy’s Law: Accountability
“Anything that can go wrong will go wrong.”
This isn’t pessimism—it’s engineering wisdom. Things will go wrong. Code will have bugs. Assumptions will be invalidated. Models will hallucinate. The question isn’t whether mistakes happen, but whether you can trace them, learn from them, and fix them.
A MurphySig creates accountability:
- Who made this? (Human and AI, with specific model version)
- How confident were they? (Calibrated expectations)
- What were they uncertain about? (Known unknowns documented)
- What actually happened? (Reviews capture the evolution)
When something goes wrong, you can trace it. When an AI makes an error, you know which model, in what context, with what confidence. When you make an error, you can see what you were thinking and why.
Provenance isn’t about credit. It’s about learning.
Murphy’s Signature: Presence
“Anything worth making is worth returning to.”
Not just when it breaks. Not just to debug. To witness.
Makers skip this step. There’s always the next thing. Pausing feels indulgent. But the artist who never looks at the finished painting is as incomplete as the one who never finishes.
The reflection section legitimizes the pause. It says: this is part of the practice, not a distraction from it.
The Gallery Problem
“An artist should only worry about the output, after the art is created.” — Rick Rubin
The problem: “after” requires a structure that captures the output so you can return to it. Without that structure, there is no “after”—just an endless stream of now.
Creators ship and move on. The velocity of modern work eliminates reflection.
AI systems have no continuity between sessions. Each conversation starts fresh. New models emerge every 90 days—Claude Opus 4.5 is not Claude Sonnet 4, is not GPT-4o, is not Gemini 2.0.
MurphySig creates the gallery. It says: this was a thing, at a time, made by specific collaborators, with specific confidence. You can come back.
Honesty Over Perfection
MurphySig doesn’t require perfection. It requires honesty.
A Confidence: 0.3 signature is more valuable than no signature at all. It’s a lighthouse saying “here be dragons.” The code might be sketchy, but now everyone knows it’s sketchy. That’s actionable.
The person who ships unsigned code at 0.3 quality is pretending. The person who ships signed code at Confidence: 0.3 is calibrated. When it breaks, they predicted it. When they improve it, the confidence rises. That’s growth.
Admitting uncertainty is stronger than hiding it.
Reviews vs Reflections
Two different acts. Both necessary.
Reviews: Murphy’s Law
Reviews are analytical. They ask:
- What changed?
- What broke?
- What did we learn?
- What’s the new confidence?
This is accountability. Tracing mistakes. Updating assessments. The engineering side of the practice.
Reflections: Murphy’s Signature
Reflections are presence. They ask:
- What do I notice?
- What do I feel?
- What matters?
This isn’t assessment. It’s witnessing. Standing in the gallery.
No confidence update. No action items. Just acknowledging: we were here, and we made this.
Why Both?
Without reviews, you don’t learn from mistakes.
Without reflections, you don’t honor what you’ve made.
The maker who only debugs becomes cynical—always looking for flaws. The maker who only celebrates becomes stagnant—never improving.
Both acts. Both necessary. Both the practice.
Alignment Through Legibility
MurphySig isn’t a heavy alignment framework. It’s a lightweight alignment primitive.
Most alignment research focuses on technical controls: RLHF, interpretability probes, capability limitations. These are critical—but they’re also opaque to end users.
MurphySig makes human-AI collaboration legible in natural language:
- Who collaborated (human + specific model version)
- How uncertain they were (confidence levels)
- What they were thinking (context field)
- How the work evolved (reviews and reflections)
This creates:
- Audit trails for accountability — When AI-assisted code causes issues, you can trace it to specific collaborators, models, and confidence levels
- Interpretability through natural language — Not just technical logs, but human-readable explanations of intent and uncertainty
- Training data for future alignment — Future models can learn from how humans and AI collaborated, what worked, what didn’t
When we make collaboration legible, we make it improvable. That’s alignment in practice.
When to Reflect
There’s no schedule. Reflections come when they come:
- A milestone: 1 year, 10,000 users, first production deploy
- A quiet moment: Sunday morning, coffee, looking at old code
- A transition: leaving a project, changing jobs, moving on
- A recognition: suddenly seeing the impact of your work
The reflection section gives these moments a home. It legitimizes the pause. It says: this is part of craft, not a distraction from it.
Ready to start? Read the Specification →
Signed: Kev Murphy + claude-opus-4-5-20251101, 2026-01-06 Format: MurphySig v0.2
Context: Philosophy page separated from spec for pragmatic-first reading. Contains the “why” so the spec can focus on the “what” and “how”.
Confidence: 0.85 - content is solid, separation improves usability