What if we’ve been modeling software systems wrong from…
0 reactions
What if we’ve been modeling software systems wrong from the start?
**What if we’ve been modeling software systems wrong from the start?**
Not in how we write code.
In what we choose to model.
We track everything:
* logs
* state transitions
* events
* traces
We can reconstruct what happened with insane precision.
But when something *actually* goes wrong, the question is never:
>
It’s:
>
And here’s the problem:
**that decision is not part of the system.**
We assume it exists somewhere:
* a meeting
* a ticket
* a Slack message
But it’s not:
* bound to the change
* recorded as a first-class event
* reconstructible
So we end up with systems that are:
* observable
* traceable
…but not truly auditable.
# Minimal example
{
"event": "STATE_CHANGE",
"entity": "deployment",
"from": "v1.2",
"to": "v1.3",
"timestamp": "2026-03-21T10:14:00Z"
}
Looks complete.
It isn’t.
What’s missing:
{
"event": "HUMAN_DECISION",
"actor": "user_123",
"action": "approve_deployment",
"rationale": "hotfix required for production issue",
"binds_to": "deployment:v1.3"
}
Without that second event:
* you can replay the system
* but you can’t reconstruct responsibility
# Why this matters now
With AI-assisted systems:
* `actions are faster`
* chains are longer
* boundaries are blurrier
We’re logging outputs…
but not the authority that allowed them.
# This isn’t a tooling issue
It’s a missing layer.
A system that doesn’t model decisions explicitly is:
>
# I wrote this up
Paper (open access):
https://doi.org/10.5281/zenodo.19709093
Curious how people here think about this:
* do you bind approvals to execution?
* is “auditability” just logs in practice?
* where does responsibility actually live in your systems?
Because right now it feels like:
we built observability
but skipped governance.
#technology
**What if we’ve been modeling software systems wrong from the start?**
Not in how we write code.
In what we choose to model.
We track everything:
* logs
* state transitions
* events
* traces
We can reconstruct what happened with insane precision.
But when something *actually* goes wrong, the question is never:
>
It’s:
>
And here’s the problem:
**that decision is not part of the system.**
We assume it exists somewhere:
* a meeting
* a ticket
* a Slack message
But it’s not:
* bound to the change
* recorded as a first-class event
* reconstructible
So we end up with systems that are:
* observable
* traceable
…but not truly auditable.
# Minimal example
{
"event": "STATE_CHANGE",
"entity": "deployment",
"from": "v1.2",
"to": "v1.3",
"timestamp": "2026-03-21T10:14:00Z"
}
Looks complete.
It isn’t.
What’s missing:
{
"event": "HUMAN_DECISION",
"actor": "user_123",
"action": "approve_deployment",
"rationale": "hotfix required for production issue",
"binds_to": "deployment:v1.3"
}
Without that second event:
* you can replay the system
* but you can’t reconstruct responsibility
# Why this matters now
With AI-assisted systems:
* `actions are faster`
* chains are longer
* boundaries are blurrier
We’re logging outputs…
but not the authority that allowed them.
# This isn’t a tooling issue
It’s a missing layer.
A system that doesn’t model decisions explicitly is:
>
# I wrote this up
Paper (open access):
https://doi.org/10.5281/zenodo.19709093
Curious how people here think about this:
* do you bind approvals to execution?
* is “auditability” just logs in practice?
* where does responsibility actually live in your systems?
Because right now it feels like:
we built observability
but skipped governance.
#technology
| 1,000 mlx | |
| 2 | |
| 0 |