Software projects accumulate decisions.
Why this database?
Why this architecture?
Why was MCP introduced?
Why does this service exist?
At the moment a decision is made, there is usually a reason.
But software doesn’t stay still.
The project changes.
Dependencies change.
Requirements change.
Assumptions change.
And eventually, a decision that was completely reasonable six months ago may no longer be correct.
The problem is:
Most development tools remember the decision, but not its lifecycle.
⸻
A decision is not just a piece of documentation
Consider this:
Decision
↓
Assumption
↓
Project changes
↓
Impact
↓
Review
A database choice might have been made because the project needed high write throughput.
Later, the architecture changes.
The original assumption may no longer be true.
But unless someone notices, the decision simply remains there.
This creates a form of technical debt that is difficult to see.
The code still works.
The documentation still exists.
But the reasoning behind it may already be obsolete.
⸻
This is where AI can become useful
An AI agent shouldn’t only answer:
“What does this code do?”
It should also be able to answer:
“Why was it designed this way?”
And eventually:
“Is that decision still valid?”
This requires more than code retrieval.
It requires understanding the relationship between:
- decisions
- assumptions
- changes
- impact
- validity
That’s the direction Contorium is exploring with its Project Intelligence Layer. (Contorium)
Instead of treating project knowledge as static documentation, decisions can have a lifecycle.
VALID → WARNING → NEEDS REVIEW
Now the project can tell you not only what it decided.
It can tell you what may need to be reconsidered.
⸻
Git tells you what changed
Git is excellent at tracking code history.
But code history doesn’t necessarily explain the reasoning behind a decision.
A commit can tell you:
This file changed.
Project intelligence can tell you:
This decision changed because the original assumption was no longer valid.
That’s a very different layer of information.
⸻
The next generation of AI development tools may not simply help us write code faster.
They may help us understand when the decisions behind that code stop making sense.
That’s a much more interesting problem.
And it’s one Contorium is trying to solve.
AI #AIAgents #SoftwareEngineering #MCP #OpenSource
https://www.contorium.dev/
https://github.com/ContoriumLabs/contorium
Top comments (0)