What If Engineering Teams Could Remember Their Mistakes?
Engineering teams don't really have a shortage of knowledge.
We write architecture decision records. We run experiments. We investigate incidents. We create post-mortems. We learn why something failed, fix it, and move forward.
But months later, another team can face a very similar decision without knowing that the organization has already learned something relevant to it.
That made our team ask a simple question:
What if an engineering organization could remember its experiences and bring them back exactly when they became useful again?
That question became PHOENIX — Engineering Experience Intelligence.
The problem we wanted to solve
Imagine a team makes an architecture decision.
They expect one outcome.
Production gives them another.
The team investigates what happened and learns an important lesson.
Normally, that lesson might end up inside a post-mortem, ADR, document, or someone's memory.
Phoenix tries to turn that process into a continuous loop:
Decision → Outcome → Experience → Reflection → Lesson → Better Next Decision
The important part isn't simply storing more documents.
It's making past experience useful before the next decision is made.
How Phoenix works
For our prototype, we created a fictional engineering organization called NovaStack with historical architecture decisions, experiments, incidents, outcomes, and lessons.
When a new engineering decision appears, Phoenix retrieves experiences from that history that may be relevant.
One example in our demo asks:
Should we migrate our notification service from RabbitMQ to Kafka?
Phoenix doesn't treat that question in isolation.
It can surface a previous Kafka migration where integration complexity was underestimated, an incident where consumer monitoring was introduced too late, and experiments that provide evidence about Kafka's capabilities.
Gemini then helps synthesize that history into a reflection for the current decision.
Importantly, Phoenix keeps the underlying evidence visible so the team can inspect why a conclusion was produced.
Looking backward before moving forward
One of our favorite parts of Phoenix is the Pre-Mortem.
Instead of asking only:
"What could go wrong?"
Phoenix asks something closer to:
"How have similar things gone wrong for us before?"
It reconstructs failure patterns from previous organizational experiences and connects them to safeguards for the current decision.
For example, if an earlier migration suffered because observability was added after production cutover, Phoenix can bring that experience into the current pre-mortem and suggest making telemetry a readiness requirement.
That creates a simple relationship:
Past failure → Lesson → Current risk → Preventive safeguard
Explainable AI mattered to us
We didn't want Phoenix to behave like a black-box assistant that simply says:
"You should do X."
The user can inspect Why does Phoenix think this?
Phoenix separates historical evidence from AI inference and exposes the records used to ground the analysis.
If the historical evidence is weak or contradictory, that should be visible too.
The goal is to help engineers make better-informed decisions — not make the decision for them.
Engineering DNA
Individual experiences can also reveal larger patterns.
If multiple projects repeatedly underestimate integration work, or several incidents happen because observability arrives too late, Phoenix can surface those recurring tendencies as part of the organization's Engineering DNA.
This turns isolated lessons into patterns the organization can recognize over time.
What we built
Our prototype includes:
- an Engineering Memory Command Center
- a Decisions Ledger
- an Experience Library
- Gemini-powered decision analysis
- evidence-grounded reasoning
- architecture comparisons
- explainable historical provenance
- a Pre-Mortem simulator
- mitigation/readiness tracking
- Engineering DNA
- exportable intelligence dossiers We built the application using Google AI Studio and Gemini, with a structured engineering-memory dataset behind the experience. The bigger idea The thing we kept coming back to while building Phoenix was this: Hindsight becomes much more valuable when it arrives before the next mistake. Engineering organizations already create the knowledge needed to make better future decisions. The challenge is remembering the right experience at the right moment. Phoenix is our attempt to make that possible.
Top comments (0)