01. OVERVIEW

AI assistance inside the debugging workflow.

Android engineers use the Android Bug Tool (ABT) to make sense of dense logs and bug reports. In this project, I explored how ML and generative AI could help engineers find signals, interpret events, and investigate problems while staying in the tools they already use.

The opportunity

Less searching

Surface potentially relevant log lines earlier in triage.

The experience

Better understanding

Make complex logs easier to read, explain, and visualize.

The constraint

Human judgment

Keep developers in control of investigation and interpretation.

MY CONTRIBUTION / WHAT I DID

Made AI useful within the Android debugging workflow.

I worked across engineering, research, product, and design to translate developer problems and emerging AI capabilities into a connected, reviewable product experience.

01. DISCOVERY

Mapped the debugging journey

I reviewed existing ABT workflows and information architecture, identified friction during early triage, and synthesized developer insights with research partners.

02. AI PRODUCT DESIGN

Defined where AI should intervene

I translated pain points into interaction opportunities for log highlighting, inline explanation, contextual investigation, and temporal visualization.

03. EXPERIENCE DESIGN

Designed connected interaction patterns

I created micro- and macro-interactions that link AI output to selected logs, bug context, follow-up actions, and developer verification.

04. PROTOTYPING & COLLABORATION

Made the direction tangible

I produced high-fidelity UI and end-to-end prototypes, collaborated with Android engineers and UX researchers on test scenarios, and iterated on the experience using feedback.

My role was AI / ML UX Designer. These contributions describe design and research collaboration; ML model development was a cross-functional responsibility.

02. PROBLEM & CONTEXT

Debugging started with too much information and too little direction.

During initial triage, engineers moved between raw logs, bug reports, and AI tools. Identifying the right signals required manual scanning, technical knowledge, and repeated context switching.

Pain point 01

Signal overload

Important log events competed with thousands of low-value entries.

Pain point 02

Fragmented tools

AI assistance was not consistently embedded in the debugging workflow.

Pain point 03

Interpretation cost

Even when engineers found a log, understanding it could require more investigation.

Design question

How might AI reduce debugging effort while preserving context and developer judgment?

03. RESEARCH & DISCOVERY

Understand how engineers investigate bugs before adding AI.

Working with Android engineers, UX researchers, and product partners, I examined early triage, developer workflow friction, existing AI experiments, and the information architecture of ABT.

Developer debugging workflow from the original case study
Developer workflow findings

Research highlighted repeated log scanning, uncertainty in early triage, and difficulty connecting AI explanations to the bug currently under investigation.

What needed to change
  • Relevant log signals needed to be more discoverable.
  • Explanations needed to stay connected to the selected log and bug.
  • Existing ABT navigation and developer mental models needed to be respected.
  • AI output needed to remain inspectable rather than authoritative.
“Initial bug triage often took multiple hours, as engineers manually scanned massive logs to find a starting point.”Developer insight from research sessions

Before and after the proposed interaction model

Before · Manual triage
Before AI-assisted debugging workflow

Searching and correlating raw log entries depended heavily on manual investigation.

Proposed · AI-assisted triage
Proposed AI-assisted debugging workflow

AI helps surface relevant signals and explain them within the existing workflow.

IA Review · Map where assistance belongs

I mapped ABT’s existing information architecture against the end-to-end debugging journey to identify intervention points without creating a disconnected AI destination.

Information architecture review and debugging workflow mapping
04. DESIGN DIRECTION

Turn the research into a connected AI experience.

Rather than introduce AI as a separate destination, I designed assistance around meaningful moments in the existing debugging journey—from triage to explanation to investigation.

  • Engineers struggled to find signals→ Highlight relevant logs to make likely starting points visible.
  • Raw log lines were hard to interpret→ Explain logs inline with plain-language context and supporting context.
  • AI was separate from debugging→ Embed contextual conversations that carry the current bug and selected logs forward.
  • Time relationships were hard to see→ Visualize log sequences to help engineers recognize patterns.
  • Unstructured output slowed scanning→ Explore a more legible log format and entry points into ABT.
  • 05. PRODUCT EXPERIENCE

    From a raw log to an informed next step.

    I designed five connected interaction patterns to support investigation without turning debugging into a separate AI chat experience.

    1 LOG UNDERSTANDING

    Highlight Relevant Logs

    Surface potentially meaningful entries and help engineers identify an initial hypothesis. Highlighting creates a starting point, while the full log context remains available.

    ABT relevant log design screen from original case study
    2 VISUAL EXPLORATION

    TimeScrubber: recognize patterns across time

    Use temporal visualization to reduce repeated manual scanning and make event sequences easier to compare during investigation.

    Design intent

    Replace “Where in these thousands of lines did something happen?” with an overview that helps engineers find and inspect relevant time windows.

    3 LOG EXPLANATION

    Explain inline. Investigate conversationally.

    Inline explanations provide fast clarification on a selected log. A contextual assistant supports deeper follow-up without asking the engineer to reconstruct the bug context in a separate tool.

    Inline and conversational log explanation UI
    Selected-log explanation.
    AI assistant contextual explanation design
    Contextual debugging assistance.

    Explain

    Plain-language summaries and relevance reasoning.

    Connect

    Trace explanations back to log lines and debugging context.

    Control

    Give engineers room to verify, question, or disregard AI suggestions.

    4 STRUCTURED OUTPUT

    Robin Logs: make raw output easier to scan

    Explore a more structured, intelligible log format with clearer groupings and supporting labels, including sensitive AI-related debugging flows.

    Robin Logs visual design
    5 ENTRY POINTS

    Bring AI into the ABT landing experience

    Make AI-assisted affordances discoverable at the points where engineers open a bug and begin triage, rather than hiding assistance behind an experimental setting.

    06. DESIGN OUTCOMES

    From manual discovery to assisted sensemaking.

    I designed a context-aware debugging experience that connects ML-driven assistance, visual cognition, and developer workflows. Through Robin Logs and TimeScrubber, I explored patterns for moving from manual log discovery toward assisted sensemaking within the Android ecosystem.

    MetricBeforeAfter*Why it changed · Design rationale
    Debugging Time~3 hrs~1.5 hrs (↓ ~50%)Relevance highlighting and log visualization (TimeScrubber) reduced time spent searching and orienting during early triage.
    Log Relevance Accuracy~61%89% (↑ ~1.45×)Robin Logs and AI-ranked log highlighting focused attention on high-signal log clusters without hiding raw data.
    Developer Trust in AILowHigh (↑ ~2.4×)Visible reasoning, inline explanations, and explicit feedback loops made AI behavior inspectable and verifiable.
    Feedback Completionn/a~80%Lightweight, in-context feedback UI lowered friction and supported trust calibration rather than passive consumption.

    *Directional indicators: Figures are based on internal prototype testing, validation sessions, and developer feedback, rather than measured production outcomes. Developer trust is a qualitative rating; the quoted ~2.4× change needs a defined numeric scale before it can be reported as a measured uplift.

    07. REFLECTION

    What I learned about designing AI for developers.

    This project changed how I decide where AI belongs, what evidence it should show, and how to evaluate its value.

    01. DESIGN AROUND THE INVESTIGATION

    Design around the investigation

    A separate AI destination adds friction. I now map the developer’s decision point before deciding where AI should appear.

    02. EVIDENCE & VERIFICATION

    Make evidence inspectable

    Explanations are not proof. I now connect AI output to source logs so engineers can verify or reject suggestions.

    03. INVESTIGATIVE VISUALIZATION

    Visualize to investigate

    TimeScrubber showed me that timelines should help developers test hypotheses, not just simplify large volumes of logs.

    04. EVALUATION RIGOR

    Measure before claiming impact

    Prototype feedback is not production evidence. I would define success measures earlier: signal discovery, explanation accuracy, and verification behavior.