Software Has Technical Debt. But It Also Has Decision Debt.

We talk constantly about technical debt.

Bad abstractions.

Old dependencies.

Duplicated code.

Temporary workarounds that became permanent.

But there is another kind of debt that receives far less attention:

Decision debt.

A project makes a decision.

The decision is reasonable.

The project evolves.

The assumptions behind the decision change.

But nobody revisits it.

The decision survives.

The reason disappears.

And eventually, the team is maintaining something nobody can fully explain.

⸻

Every architecture has a hidden timeline

Imagine an authentication system.

At some point, the team decides:

Use JWT.

There was a reason.

Maybe the system needed stateless authentication.

Maybe multiple services needed to verify tokens.

Maybe the team wanted to avoid session storage.

That reason matters.

But six months later, the architecture changes.

Perhaps the system becomes a single application.

Perhaps the authentication requirements change.

Perhaps the original constraint disappears.

Now the question isn’t:

“Why did we choose JWT?”

The more important question is:

“Does the original reason still exist?”

⸻

This is where project intelligence becomes interesting

Traditional documentation tends to describe the current state.

Git describes changes.

But neither necessarily provides a structured lifecycle for engineering decisions.

Contorium takes a different approach.

A decision can be represented together with its:

• reasoning
• • assumptions
• • impact
• • validity
• • related project changes

The result is closer to a living knowledge graph than a static document. (Contorium)

. DECISION

. │

. WHY?

. │

. ASSUMPTION

. │

. ┌────────┴────────┐

. ↓. ↓

. Project Change. New Evidence

. │. │

. └────────┬────────┘

. ↓

. IMPACT

. ↓

. REVIEW

The important part is the final step.

Review.

A decision shouldn’t necessarily live forever.

⸻

AI can become the reviewer of project reasoning

This creates an interesting role for AI.

Instead of only asking an AI agent to modify code, we can ask:

Which architectural decisions may no longer be valid?

Or:

Which assumptions have changed?

Or:

What should the team review before making this change?

That moves AI from code generation toward engineering reasoning.

And that may be one of the more important transitions in AI-native development.

⸻

Projects should be able to question themselves

A mature software project should not merely remember:

“We decided X.”

It should eventually be able to ask:

“Why did we decide X?”

“What assumption supported X?”

“What changed since then?”

“Is X still valid?”

That is the kind of persistent project understanding Contorium is building toward with its Project Intelligence Layer. (Contorium)

The future of AI-assisted development may not simply be about generating more code.

It may be about making software projects capable of remembering, reasoning about, and revisiting their own decisions.

Git remembers the history of code.

Contorium is exploring the history of why the code became what it is.

AI #SoftwareEngineering #AIAgents #DeveloperTools #OpenSource #MCP

https://www.contorium.dev/

https://github.com/ContoriumLabs/contorium