Sentor Demo SIte

Sentor

Git records what changed. Sentor records how and why it changed.

Sentor (pronounced "SEN-tor") is an engineering provenance platform built for the AI era, capturing the complete engineering story behind every AI-assisted code change.

Modern software engineering has changed dramatically.

AI coding assistants can now generate hundreds of lines of working code within minutes, dramatically increasing developer productivity. However, once those changes are committed, much of the engineering context is lost.

Weeks or months later, developers can usually answer what changed by reading Git history, but much harder questions remain:

Why was this approach chosen?
Which AI interaction influenced this implementation?
What engineering decisions were made?
What evidence supported those decisions?
What validation was performed before the change was committed?

As AI becomes an integral part of software engineering, explainability should not end when code is committed.

That is why we built Sentor.

What Sentor Does

Sentor captures the complete engineering story behind every AI-assisted code change.

Rather than preserving only the final source code, Sentor records the engineering journey that produced it.

For every meaningful software change, Sentor captures engineering provenance including:

Engineering sessions
AI prompts and responses
Engineering decisions and rationale
Validation evidence
Git-derived changed files
Explicit engineering relationships
The Git commit that records the final outcome

Developers can inspect a commit and understand not only what changed, but also how and why it came into existence.

Instead of treating software as a sequence of commits, Sentor preserves the reasoning, evidence and engineering context behind those commits.

Inspiration

The inspiration came from a simple observation.

AI-assisted software development has transformed how code is written, yet our engineering tools have not evolved at the same pace.

Today's AI tools are exceptional at generating code.

Git remains exceptional at preserving source history.

Neither preserves the engineering process itself.

As software becomes increasingly co-created by humans and AI, we believe developers need more than version history—they need engineering history.

Sentor is our exploration of what that future could look like.

How We Built It

We deliberately designed Sentor as a local-first engineering platform rather than another cloud service.

At its core is a Rust provenance engine responsible for:

Capturing engineering events
Storing immutable canonical provenance objects
Maintaining a rebuildable SQLite query index
Integrating with Git
Exposing deterministic provenance queries

The VS Code extension intentionally remains lightweight.

Rather than duplicating business logic, it consumes structured provenance produced by the Rust core and presents it where developers already work.

This architecture keeps engineering semantics authoritative while allowing multiple future interfaces to share the same provenance engine.

We also treated software design as a first-class engineering artefact.

Before implementation, we produced a formal engineering specification covering product design, architecture, repository standards, implementation governance, milestone tracking and acceptance criteria. These documents became the executable contract that guided autonomous implementation and testing throughout the project.

The implementation itself followed a specification-driven, test-driven workflow, allowing the architecture to remain consistent while enabling autonomous development against clearly defined engineering contracts.

Challenges

One of the biggest challenges was not recording engineering activity—it was deciding what we could truthfully claim.

AI-assisted development naturally introduces uncertainty.

Just because an AI response appears before a code change does not necessarily mean it caused that change.

Rather than making optimistic assumptions, we designed Sentor around conservative engineering provenance.

Relationships are only recorded when supported by:

Direct observation
Explicit user action
Deterministic derivation
Clearly identified inference

This principle influenced nearly every architectural decision, from storage and evidence classification to provenance queries and presentation.

We also challenged ourselves to build a system that remains local-first, deterministic and explainable without sacrificing future extensibility.

What We Learned

Building Sentor reinforced an important lesson.

AI is fundamentally changing how software is created, but most engineering tooling still focuses almost entirely on the final artefacts rather than the engineering process.

We also learned that autonomous software development becomes dramatically more reliable when implementation is driven by clear engineering specifications rather than conversational prompts alone.

By defining the product, architecture, milestones and acceptance criteria before implementation, autonomous coding became significantly more predictable, more consistent and easier to validate.

In practice, good specifications proved to be just as valuable as good code.

Why We Believe It Matters

Software engineering is entering a new era.

Version control solved the problem of preserving software history.

AI has transformed how software is produced.

The next challenge is preserving the engineering history behind software.

We believe developers should be able to understand not only what changed, but also how and why those changes came to exist—even months or years later.

That is the future Sentor is exploring.

Technology

Rust
SQLite
Git
VS Code Extension API
JSON
Specification-Driven Test-Driven Development (TDD)
OpenAI Codex
GPT-5.5

Looking Ahead

This project is our first step toward a future where software is not only versioned, but fully explainable.

As AI becomes an increasingly capable engineering collaborator, understanding how and why software evolves will become just as important as understanding what changed.

Our focus for this hackathon has been proving that engineering provenance can become a natural part of the developer workflow.

We hope Sentor contributes to a future where developers can build faster with AI without sacrificing understanding, trust or engineering integrity.