Lines of code don't measure architectural thinking, code review depth, or mentoring. Discover how Keypup's MCP Server reveals the invisible glue work that automated metrics miss—and why your most valuable engineers often appear least productive.
TL;DR: Traditional engineering metrics count what's easy to measure—commits, lines of code, PRs merged—but miss the high-value work that happens between keystrokes.
Sarah is a Staff Engineer at a mid-sized SaaS company. In the past month, she:
Her contribution is enormous. Her commit count for the month? Seven. Her lines of code? 342.
According to most engineering analytics dashboards, Sarah had a "slow month." According to her team, she prevented disasters and accelerated everyone else.
This is the thinking vs. typing gap—the fundamental mismatch between what automated metrics measure and what actually creates value in software engineering.
"I had my worst performance review ever the same quarter I prevented a multi-million dollar architectural mistake. My commit velocity was down because I spent three weeks researching, prototyping, and documenting why we shouldn't build what the exec team wanted. The system never measured that I saved the company from itself."
The term "glue work" was popularized by Tanya Reilly to describe the critical but often invisible work that holds teams and projects together. In software engineering, glue work includes:
Deep Code Review:
System Design and Architecture:
Debugging and Investigation:
Knowledge Transfer and Mentoring:
Collaborative Problem Solving:
Traditional engineering analytics focus on artifacts (commits, PRs, lines changed) rather than activities (thinking, collaborating, investigating, teaching). The result is a massive blind spot:
What Metrics Capture:
What Metrics Miss:
"The engineers who get promoted are the ones who ship visible features. The engineers who should get promoted are the ones who make everyone else better—but that's nearly impossible to measure with standard metrics. We optimize for the wrong thing because it's easier to count."
When glue work remains invisible, organizations inadvertently create perverse incentives that damage engineering culture and system quality.
Engineers learn that thoughtful, careful work is less valued than rapid output. This leads to:
"I stopped doing thorough code reviews because they weren't reflected in my metrics. My manager kept asking why my 'contribution' was down. Spending 3 hours on a review that prevents a production incident doesn't show up in dashboards, but churning out features does. Guess which behavior gets rewarded?"
As engineers grow in seniority, their value increasingly comes from:
Yet metrics often show them as "less productive" than junior engineers who write more code but create less impact.
Teams learn to game metrics:
When glue work is invisible, organizations fail to:
Keypup's MCP Server integration brings a fundamentally different approach: instead of just counting artifacts, it enables context-aware analysis that reveals the thinking behind the typing.
By combining multiple data dimensions and enabling natural language queries, the MCP Server surfaces patterns that indicate high-value glue work.
Code review is thinking-heavy work. Not all reviews are equal—a thoughtful review that asks critical questions and teaches patterns is far more valuable than a quick "LGTM."
MCP Prompt: Analyze Review Engagement and Depth
Show me pull request review patterns over the last 3 months. For each reviewer, calculate: average time spent on reviews (time from first view to approval), average number of review comments per PR reviewed, and the distribution of review types (quick approval vs. engaged review with discussion). I want to identify who's doing deep, thoughtful reviews vs. superficial approvals.
What This Reveals
Key Insights 📊
⚠️ Problem Areas
💡 Recommendations
🚀 Priority Actions
Mentoring happens through pairing, code review, architecture discussions, and problem-solving help. These interactions are scattered across tools and rarely measured systematically.
MCP Prompt: Identify Mentoring Patterns and Knowledge Flow
Analyze collaboration patterns by looking at who reviews whose PRs, who comments on whose issues, and who pairs on commits (co-authored commits). Create a knowledge flow map showing senior engineers who consistently interact with junior engineers. Include metrics on response time to questions (issue comments) and engagement depth.
What This Reveals
Key Insights 📊
⚠️ Bottlenecks and Problem Areas
💡 Recommendations
🚀 Priority Actions
Some of the most valuable engineering work is understanding complex systems, reproducing bugs, and tracing through intricate code paths. This work generates minimal commits but prevents disasters.
MCP Prompt: Track Investigation Time and Problem-Solving Effort
Find patterns that indicate investigation work: PRs or branches that existed for days with minimal commits (suggesting research/debugging), issues with long comment threads discussing approaches (collaborative problem-solving), and PRs with many small iterative commits (trial and error debugging). Cross-reference with production incidents to identify who does deep debugging.
What This Reveals
Key Insights 📊
⚠️ Bottlenecks and Problem Areas
💡 Recommendations
🚀 Priority Actions
System design, architecture decisions, and technical research generate documents, discussions, and prototypes—but often minimal production code.
MCP Prompt: Identify Architectural Contribution Through Discussion and Documentation
Analyze patterns indicating design work: PRs with extensive descriptions and architectural diagrams, issues tagged as "design" or "architecture" with long discussion threads, commits that add documentation files (ADRs, design docs, READMEs), and PRs that touch many files but change little code (refactoring, structure). Identify who drives architectural discussions.
What This Reveals
Key Insights 📊
⚠️ Bottlenecks and Problem Areas
💡 Recommendations
🚀 Priority Actions
Keypup MCP Server enables a fundamental shift in how we think about engineering productivity:
Traditional Metrics (Output-Focused):
Impact Metrics (Outcome-Focused):
Value Thinking Time: Time spent without typing is often the most valuable time—designing, reviewing, mentoring, investigating
Measure Multipliers: The best engineers make everyone else more productive—measure their impact on others, not just their personal output
Recognize Prevention: Work that prevents problems is more valuable than work that fixes them—but often less visible
Track Knowledge Flow: How knowledge moves through your team is as important as what knowledge exists
Balance Individual and Team: Optimize for team outcomes over individual output metrics
The Keypup MCP Server is available in beta and integrates with Claude Desktop, ChatGPT, Cursor IDE, and Windsurf.
Immediate Actions to Surface Glue Work:
Cultural Changes to Support:
The thinking vs. typing gap exists because we measure what's easy to count rather than what actually matters. Lines of code are tangible; thoughtful system design is nebulous. Commits are discrete; mentoring is continuous. Features shipped are visible; disasters prevented are invisible.
But just because something is hard to measure doesn't mean it's less valuable. In fact, in mature engineering organizations, the hardest-to-measure work—deep review, mentoring, architecture, debugging, knowledge transfer—is often the most valuable work.
Keypup's MCP Server integration doesn't solve this problem with a single metric. Instead, it enables the nuanced, context-aware analysis required to surface patterns that indicate high-value glue work. It makes the invisible visible—not through crude proxies, but through intelligent queries that understand how real engineering teams function.
The question isn't whether your engineers are being thoughtful, collaborative, and strategic. The question is whether your measurement systems can see it.
System legibility for glue work starts here.
You can't measure thinking directly, but you can measure its artifacts and patterns: long-lived branches with few commits (investigation), extensive review comments (deep engagement), documentation commits (knowledge transfer), participation in design discussions. The MCP Server aggregates these signals to reveal patterns.
Any metric can be gamed, but glue work metrics are harder to fake than simple output metrics. It's easy to inflate commit counts; it's hard to fake sustained mentoring relationships or consistently thoughtful code reviews. The key is using multiple signals and patterns rather than single metrics.
The shift is from measuring individuals in isolation to understanding their impact on team outcomes. Ask: "Does this engineer make the team better?" rather than "How much did this individual produce?" The MCP Server enables both individual pattern analysis and team-level impact measurement.
Some engineers worry that making their work visible will create expectations for even more glue work. The goal isn't to add more work—it's to recognize and value the work already happening. Visibility enables better load balancing and ensures glue work is distributed fairly.
Monthly for ongoing monitoring, quarterly for deeper reviews, and always before performance evaluation cycles. The goal is continuous visibility, not occasional audits. Glue work patterns are most meaningful when tracked over time.
Yes, but patterns are clearer with 8+ engineers. In very small teams (< 5 people), everyone's glue work is relatively visible without formal measurement. The invisibility problem scales with team size and organizational complexity.
Start by explicitly adding categories like "team enablement," "knowledge transfer," "technical leadership," and "force multiplication" to your engineering ladder. Use MCP Server analyses as evidence during promotion discussions. Make glue work count equally to shipping features.
That's a cultural red flag. Either glue work genuinely isn't happening (unsustainable), or it's happening but engineers have learned to hide it because it's not valued. Create explicit space and recognition for glue work, then re-measure in 3 months.
Join teams already using AI to make data-driven decisions faster than ever.
DORA metrics show strong performance, but your system is still brittle. Learn how vanity metrics hide technical debt and how Keypup's MCP Server reveals the full story through system legibility analysis.
Discover why measuring individual developer performance with raw metrics leads to gaming behavior and erodes team trust. Learn how Keypup's MCP Server provides contextual benchmarking that accounts for mentoring, architecture work, and team contribution—transforming metrics from surveillance tools into culture-building insights that recognize real value beyond lines of code.
Discover how to overcome the most painful project management challenges in software development. Learn how Keypup's MCP Server harmonizes data across Jira, Trello, and Git repositories to provide actionable insights, predictive analytics, and real-time visibility—transforming chaos into clarity and helping teams deliver on time, every time.