Fun Fact!
The internal code name for CoreStory was "Kenobi". A nod to the Jedi Master known for bringing clarity to complex situations. Click anywhere to close
AI Workflow for Generating the Artifacts
This is a small portion of the workflow that results in generating the artifacts in CoreStory. Click anywhere to close
What is CoreStory?
CoreStory is an AI-powered platform that analyzes codebases across three levels of abstraction. Giving developers, architects, and business stakeholders the insights they need to modernize and maintain legacy systems. Built specifically for massive codebases where off-the-shelf LLMs, traditional tools, and human analysis alone fall short.
CoreStory emerged from a major rebrand of Crowdbotics, and is now the company's sole product offering.
Role
Senior Product Designer (only designer on project)
Timeline
February – September 2025
Team
Cross-functional (Engineering, AI/ML, Product)
Scope
Enterprise B2B web application
The Problem
Enterprise clients had massive systems built decades ago by people who no longer work there. Written in legacy languages like COBOL, FORTRAN, and early C++, these codebases have become black boxes. Modernization projects stalled because nobody could answer: "What does this system actually do?"
Companies were spending €50,000–80,000 rehiring retired developers just to interpret their own code. Delaying projects by months.
Why companies urgently need to modernize:
Unfixable Bugs
Critical bugs that nobody understands well enough to fix safely. Each patch risks breaking something else.
Customer Churn
Outdated systems can't keep up with customer expectations. Slow performance and missing features drive users away.
Monolithic Architecture
Tightly coupled systems where changing one thing affects everything. Impossible to scale or update independently.
Compliance Risk
Regulatory requirements (HIPAA, GDPR, Basel III) that legacy systems weren't built to handle. Failed audits and legal exposure.
Research
Methodology
Conducted 18 one-on-one discovery interviews with architects, developers, and technical leads across 4 industries (infrastructure, finance, healthcare, industrial automation) managing systems 12–25 years old. Each session lasted 30–45 minutes.
To handle the volume efficiently, I used AI to transcribe and synthesize findings in real-time. Spending just 10 minutes per call to extract structured insights while maintaining accuracy and depth.
I built an AI-powered workflow that automatically transcribes calls, extracts key themes, and generates structured insights. This not only cut synthesis time from hours to minutes, but also unlocked value from older interviews that lacked structured notes. Turning historical data into actionable insights.
Companies were paying €50–80K to rehire retired developers just to interpret their own legacy code. This pain point shaped the product's primary goal.
Knowledge Locked in Code
No documentation, cryptic comments, and systems understood by only 1–2 people who had since left. Tribal knowledge was the norm.
High-Stakes Errors
Miscategorized features caused real damage. One example: "patient consent" filed under "user settings" instead of "compliance" led to a failed audit and days of rework.
Existing Tools Fell Short
Current tools averaged 4.8/10. They showed code structure but not meaning, and couldn't answer "what does this do?" or "which parts handle compliance?"
Needs
Human-in-the-Loop Control
Correct AI misclassifications in real-time. Flag errors, adjust priorities, exclude irrelevant components. Without this, teams waste days fixing outputs manually.
Business Context Integration
Upload regulatory docs (HIPAA, GDPR, Basel III), compliance checklists, and domain rules. Generic outputs that miss critical business logic aren't useful in regulated industries.
Meaningful Q&A Over Code
Ask natural questions like "How do we ensure GDPR compliance in this module?" or "What handles patient consent?" and get answers grounded in the actual codebase.
Faster Discovery
Teams expected 40–50% reduction in discovery time. Enough to justify switching from manual grep searches and line-by-line analysis.
"This could be the reset button that prevents future retiree reunions."
Research Participant
Personas
Successful modernization requires developers, architects, and business stakeholders to operate from a shared understanding of what a legacy system does. I designed one interface that serves all three personas without compromising any.
Developers
Insights into code quality, complexity, and design patterns. AI-powered suggestions to optimize implementation.
Architects
Visualize system design, understand dependencies, analyze cohesion and coupling, and receive structural recommendations.
Business Stakeholders
Track feature completeness, understand compliance needs, allocate resources effectively, and identify business risks.
These insights directly shaped our design priorities: building trust through transparency, enabling human oversight of AI, and surfacing meaning rather than just structure.
Design Exploration
Navigation Patterns
Early
Revised
Final
This first iteration prioritized approachability with friendly icons for artifacts and intuitive exploration. Personas appeared as tabs at the top, while the chat remained anchored at the bottom for constant access. Users would open an artifact, then navigate back to return to this view. After internal testing, this direction was not selected due to inefficient use of space, insufficient emphasis on the chat feature, and user frustration with the navigation flow.
This iteration elevated chat to the top of the interface, making it clear that users could attach context files to each conversation. The full list of artifacts now appeared below without requiring navigation between tabs, since some artifacts served multiple personas and the tabbed approach felt limiting. However, this design also fell short because chat history was not immediately accessible, users found it unclear how to view previous conversations, and the artifact grid felt visually flat.
The final design consolidated chat and all artifacts into a vertical navigation bar on the left side of the screen. This approach kept the full artifact list persistently accessible without requiring users to navigate back to view the grid. The information hierarchy became significantly clearer, with chat history and artifact sections easy to scan, digest, and explore at a glance.
Landing Experience
Early
Revised
Final
This is the first page users see after logging in. From here, they can choose the project they're working on or start a new one. Although it seems simple and low in functionality, it's the perfect opportunity to make a first impression. This early concept was rejected because the styling of the graphics was deemed too distracting.
After a few iterations, the page became a lot more mature and focused. Internal testers were really happy with this result, but they still felt it could use a little bit of a wow factor.
The final result added a subtle glass effect, giving the UI a premium feel. This approach required a complete rewrite of the design system colors to ensure they work regardless of background color, don't feel out of place, and maintain enough contrast to be distinguishable as interactive elements.
Collaboration & Cadence
Partnering with AI/ML Engineers
In the beginning of the project, I joined daily reviews with the AI team to understand the capabilities and constraints of the system. Together with the PM and engineering lead, we planned multi-sprint roadmaps for executing the vision.
Cross-Functional Design Critiques
Weekly triad meetings where I presented work to the PM, engineering lead, and sometimes the CPO to ensure we were on the right track and plan for the following week. We also validated that designs worked for all target customers.
Prototyping & User Testing
Each week I created a fully interactive Figma prototype that was shared with the team for internal testing, usability testing, and sent to a limited number of design partners outside the company.
Prompt Design Collaboration
Due to my experience with LLMs and prompt engineering, I was included in meetings where we planned the workflows for generating all the artifacts and designed the prompts for each step of the process.
Every week, I created a fully interactive prototype in Figma and shared it internally with stakeholders for feedback. We often sent these prototypes to potential customers and existing customers for review as well, ensuring our designs were validated by real users throughout the process.
How CoreStory Works
01
Connect Repo
Developer
02
Add Context
Business / Architect
03
Generate Artifacts
Automated
Chat with Your Code- the core feature, used by all personas
Generated Artifacts
for Developers
Legacy File Analysis
Code Dependency Map
Code Relationship Graph
File Entry Points
External Library List
Code Modules
Module Details
Module Features
Inheritance Viewer
for Architects
Process Sequence Diagrams
UML Diagrams
Domain Objects
Core Logic
3rd Party Dependencies
for Business
Epics & Features
Business Process
User Personas
Process Flows
Acceptance Criteria List
+ Users can generate custom artifacts
Click anywhere to close
Designing for AI Trust
Users were skeptical of AI in high-stakes scenarios. I designed transparency into every interaction:
Confidence Levels
Human in the Loop
Source Traceability
Version Control
Each artifact displays a confidence score showing how certain the AI is about its analysis. This transparency builds trust by signaling to users that we're aware of limitations and uncertainties, rather than presenting everything as definitive. (Research showed users rated existing tools 4.8/10 because they couldn't verify outputs.)
Users can provide context upfront, change the prompt to refine outputs, and edit parts of artifacts with AI assistance. This collaborative approach ensures the AI works with users, not for them, maintaining human judgment at every step. (Addressing the "high-stakes errors" insight: miscategorized features had caused failed audits.)
Every AI-generated insight links directly back to the source code that informed it. Users can click through to see exactly why the AI made a particular conclusion. This verifiability builds trust by letting users fact-check the AI rather than blindly accepting its output. (Existing tools showed code structure but not meaning.)
Full version history with rollback, comparison, and visual diffs. Giving users control over AI-generated content is critical. Even though most artifacts are automatically created, users need to feel in charge. This sense of ownership builds confidence in the platform. (Enterprise users needed to own and audit every output.)
Outcome & Learnings
Impact
70–80%
Reduction in discovery time (weeks → days)
€50–80K
Saved per project by eliminating retiree dependency
7 months
From concept to pilot customers
User Feedback
"This is the reset button we've been waiting for. We can finally understand our own systems without tracking down people who left five years ago."
Infrastructure Architect
"The human-in-the-loop refinement is what makes this work."
Healthcare Developer
Reflection
Key Lesson
Users don't trust AI outputs they can't verify. The breakthrough came when we shifted focus from "showing AI results" to "letting users guide and validate AI reasoning." Human-in-the-loop wasn't a fallback; it was the core value proposition. Trust in AI systems must be designed in from day one. It's not something that can be added later.
Looking Ahead
Earlier access to real legacy codebases would have accelerated learning. Simulated examples helped, but nothing compares to the chaos of 30-year-old production code. I never thought my fascination with large language models and AI would lead to prompt engineering at work. But by following what excited and interested me, that skill became surprisingly valuable. "You can't connect the dots looking forward; you can only connect them looking backward." - Steve Jobs
Skills Strengthened
• Designing trust and transparency into AI interfaces
• Building for multiple personas with one unified system
• Collaborating with AI/ML engineers on prompt design
• Creating enterprise-grade design systems from scratch
Bonus Content
Design System
I built a comprehensive design system from scratch to ensure consistency across all modules and accelerate development velocity. I worked closely with frontend developers to ensure that components in Storybook matched Figma exactly, with all variations aligned and using the same nomenclature to streamline communication between design and engineering.
Fonts
Colours
Buttons
Modal Spacing
Progress Bars
More
A limited selection of font sizes ensures consistency and reduces mistakes and odd patterns. Using Inter for UI elements and system fonts for code, with consistent weights and line heights for readability across all contexts.
The color palette is intentionally limited compared to traditional design systems. This constraint minimizes the chance of mistakes on the frontend and forces better decision-making when creating new components. Includes semantic tokens with accessible contrast ratios and status colors for feedback states.
Complete button library with primary, secondary, ghost, and destructive variants. Secondary buttons use transparency instead of absolute values, allowing them to adapt to any background color while maintaining enough contrast to remain legible and distinguishable at all times.
In the rare case that a developer couldn't figure out how to use the measurements inside Figma, I created very detailed measurement specifications which were included in appropriate tickets.
Progress indicators for async operations and AI processing. Linear bars, circular spinners, skeleton loaders, and step indicators to keep users informed during wait times.
There were many other components in the design system as well, too many to share here. They were all created from scratch to ensure a consistent look and feel across the app.
A video to unify the team
The sudden pivot was difficult for the team. Everyone had to abandon projects they'd invested over a year in. To help lift spirits, I created this video in about four hours to celebrate our new direction. I also had one-on-one conversations with developers who felt their work had been discarded, helping them see how their efforts still mattered and keeping morale high during a challenging transition.