Comprehension Lens

80% of engineer time is spent comprehending code, documentation, and business context.

Comprehension Lens is a suite of tools that reduce comprehension time, enhancing developer productivity and satisfaction - all with quantified ROI for easy business decisions.

There are currently two focus areas: Static Analysis and Backstory

• Static Analysis
  • How Does it Differ from Other Static Analysis Tools?
  • For Engineers
  • For Team Leads
  • Get Started with the Dashboard
    • Customize your Context
    • Directory Metrics
    • Error Causes Worth Fixing
    • Per-file Metrics
  • Get Started Coding
    • Toggle Preexisting Causes
    • Extensive Help and Examples
  • FAQs
• Backstory

Static Analysis

Static analysis answers the questions:

• How much can my team save by preventing code misunderstandings?
• Where can we save it?
• How much have we saved?

How Does it Differ from Other Static Analysis Tools?

• Identified error causes are backed by world-class research, not opinions
• Causes are quantified in business terms like dollars and ROI
• Causes' values are customized to your business context
• Causes -not- worth fixing are distinct

For Engineers

John opens his code review feedback. Ugh. Five more comments. One line works differently than he thought. Another line contains incorrect logic. He goes back to fix the problems and await further reviews. The next sprint his reviewer misses a logic error. The code reaches production. Frustrated users complain. John wants to suggest codebase improvements to reduce bugs, but others with more seniority dismiss his opinions.

Comprehension Lens Static Analysis helps you:

• Keep your team happy and spend less time in code reviews with fast-to-understand code
• Learn patterns that quantifiably improve delivery speed and reliability
• Improve code review suggestions with quantified, research-backed insights

For Team Leads

Team Lead Chris wants to refactor code to prevent bugs in the future. He meets with leadership and product. He knows that preventing the problems is important, but can't quantify the value. The meeting ends with prioritizing new features over preventing bugs. The team feels frustrated, ineffective, and demoralized. They spend extra sprints fixing bugs while unable to improve their situation.

Comprehension Lens Static Analysis helps you:

• Build momentum for refactoring efforts with quick wins and quantified business value
• Improve team delivery speed, reliability, and satisfaction through reduced review time, rework, and bugs
• Communicate efficiently with leadership, product managers, and team members using ROI and other business values

Get Started with the Dashboard

For a high level view of comprehension issues in your codebase, right click on a file or folder in the explorer. Select "Comprehension Dashboard". The first time you open the dashboard, you'll see a customization wizard that enables you to tailor estimations for your business context (or skip them). Future opens go directly to the dashboard.

Customize your Context

Business contexts and codebases differ. Improve your dashboard's accuracy with the customization wizard. Skip it to use reasonable defaults.

Directory Metrics

Rollup metrics for the selected directory are visible at the top of the dashboard. Per-file metrics are available below.

Error Causes Worth Fixing

Sometimes fixing a problem costs more than it's worth. For example, preventing problems in a file that changes once a year is probably not worth it. Preventing the same problems in a file that changes 20 times a year is.

With comprehension lens, fix only the error causes whose ROI exceeds other business opportunities. Ignore those with negative value.

Per-file Metrics

Each file has detailed metrics used in its value calculations, plus additional business values like Payback Period.

Get Started Coding

Once you install Comprehension Lens, nothing happens. This is intentional to minimize interruption.

Upon saving a file, opportunities to prevent error causes appear (i.e., error causes created since the last git commit). Unopened files and files in inactive tabs are not analyzed.

Toggle Preexisting Causes

By default, only prevention opportunities appear. Toggle "Fix" mode when you're ready to fix preexisting error causes.

Extensive Help and Examples

Error cause documentation includes valid and invalid patterns, examples, and links to underlying research. Complex refactors like negation also include detailed refactoring approaches.

FAQs

• Will installing Comprehension Lens interrupt our work? No. All tools are designed to preserve flow. Nothing happens on installation. Static Analysis defaults to only showing comprehension suggestions on changed code.
• Can I trust the numbers? We won't give you numbers we don't trust ourselves. Our core values include precision, accuracy, and learning. Pursuing those, we rigorously evaluate all research - even the replication packages. We exclude research with validity problems or data that are insufficient to quantify changes. Where your context varies from other companies and teams, we enable customization. Finally we learn from the data and customer interactions, updating our model when practice differs from research. We aren't perfect, but we get better every day.
• What's the cost? There's a free tier that will always be free. Paid tiers' features and cost are TBD, but we aim to average around 1/10th the value they provide.
• What if there's a problem? All errors clearly communicate the problem AND how to resolve it. If problem descriptions or resolutions are ever insufficient, get them fixed and get support via the dashboard's support link.

Backstory

Backstory answers the question: Why does this code exist?

As an engineer, Jane needs to implement a feature. She's confused by the code she needs to change. It doesn't make sense. There's no clear reason for those extra conditions. The names don't help. She's afraid to make changes because she doesn't know what will break. She spends hours digging through tracker tickets, git blame, PR descriptions and comments, documentation, contacting colleagues, and waiting for responses - all to determine the backstory for a section of code.

Comprehension Lens helps you quickly find code backstory for faster onboarding and daily problem solving in unfamiliar code.

It works by combining static analysis, git APIs, issue tracking apis, documentation, and AI summarization.