Caching for Pair Programming with AI

AI pair programming has become a core engineering workflow. Engineers interact with AI assistants continuously — asking questions, generating code, reviewing changes, and exploring unfamiliar modules. Each interaction requires context about the codebase. With org-shared cache, you eliminate redundant context gathering and make every AI pair session faster and cheaper.

Use this page when

• You want to optimize cache for interactive AI pair programming sessions.
• You need to configure function-level fabric granularity, refresh-on-save, and prefetch settings.
• You are measuring interaction latency, context hit rates, or token savings for pair workflows.

Primary audience

• Primary: AI Agents, Technical Engineers
• Secondary: Technical Leaders

The Cost of Context in Pair Programming

Every AI pair programming interaction needs context:

• "Explain this function" requires the function's dependencies and callers.
• "Refactor this module" requires understanding of the module's contracts and consumers.
• "Write a test for this" requires the testing framework, existing patterns, and coverage state.

Without caching, each developer's AI assistant independently gathers this context through provider calls. In a team of 10 engineers working on the same repository, the same context gets fetched 10 times on the first day.

How Shared Cache Helps Pair Programming

With org-shared cache enabled, the first engineer to explore a code area pays the context-gathering cost. Every subsequent engineer (and their AI assistant) benefits from cached artifacts:

1. Alice asks her AI about the authentication module → Cache populates with auth module summaries.
2. Bob asks his AI about the same module 30 minutes later → Instant cache hit, zero provider cost.
3. Charlie asks a slightly different question about auth → Semantic cache hit if similarity exceeds threshold, or fabric hit for the context portion.

Context Types That Accelerate Pair Programming

These cached artifacts directly improve pair programming speed:

Code Summaries

Cached summaries let the AI instantly understand files without re-reading and re-analyzing them:

Engineer: "What does UserService do?"
AI: [retrieves cached summary instead of analyzing 500 lines]
Response time: 200ms vs 3000ms without cache

Dependency Graphs

Cached dependency graphs let the AI navigate relationships without tracing imports:

Engineer: "What calls this function?"
AI: [retrieves cached caller graph]
Response time: 150ms vs 2000ms without cache

Test Maps

Cached test maps let the AI locate relevant tests without scanning the test directory:

Engineer: "Which tests cover this code path?"
AI: [retrieves cached test map]
Response time: 100ms vs 1500ms without cache

Configuring Cache for Pair Programming

Optimize your cache configuration for interactive pair programming:

cache:
  semantic:
    enabled: true
    similarity_threshold: 0.90
    ttl: 24h
  fabric:
    enabled: true
    generators:
      - type: code_summary
        granularity: function
      - type: dependency_graph
        depth: 2
      - type: test_map
    refresh_on_save: true

Key settings for pair programming:

• Function-level granularity — Summaries at the function level match the granularity of pair programming questions.
• Depth 2 dependency graphs — Two levels of dependencies cover most "what connects to this" questions.
• Refresh on save — Cache updates when engineers save files, keeping pair context current.

Real-Time Context Sharing

When two engineers pair program on related code, their cache contributions benefit each other in real time:

• Engineer A works on the API handler → Cache fills with handler context.
• Engineer B works on the client that calls that handler → Cache already has the handler context when B's AI needs to understand the endpoint.

This creates a multiplier effect where pair programming teams collectively warm the cache faster than individual engineers.

Session Continuity

AI pair programming sessions often span hours. Cache maintains context continuity:

• Questions asked early in the session inform later responses through semantic cache.
• Code generated in the session updates fabric entries, keeping the AI aware of recent changes.
• Switching between files within a session hits warm cache entries populated minutes ago.

Multi-File Workflows

Pair programming often spans multiple files — refactoring a function requires updating callers, tests, and types. Cache accelerates multi-file workflows:

cache:
  pair_programming:
    prefetch_related: true
    related_depth: 1
    prefetch_trigger: file_open

When you open a file, the system prefetches cached context for directly related files. By the time you ask about a caller or test file, the context is already available.

Reducing Token Usage

Pair programming generates high token volumes because interactions are frequent and contextual. Cache reduces token usage through:

• Context deduplication — The same file context is not re-sent to the provider on every interaction.
• Semantic reuse — Similar questions return cached responses without any provider call.
• Fabric compression — Pre-computed summaries are smaller than raw source files, reducing context window usage.

Team Pair Programming Patterns

Different pair programming patterns benefit from cache differently:

Pattern	Cache Benefit
Driver/Navigator	Navigator's questions hit driver's recent cache entries
Mob programming	N engineers share one warm cache; N-1 pay zero context cost
Async pair review	Reviewer hits author's cache entries for context
Mentoring sessions	Mentor and mentee share context about the same code areas

Measuring Pair Programming Cache Value

Track these metrics for pair programming scenarios:

• Interaction latency — Average response time for pair programming queries. Target: under 500ms.
• Context hit rate — Percentage of pair queries that hit cached context. Target: 75%+.
• Token savings — Tokens saved per pair programming hour through cache hits.
• Session cost — Average cost per hour of AI pair programming.

Privacy in Shared Pair Context

Some pair programming involves sensitive work. You control sharing boundaries:

cache:
  pair_programming:
    sharing:
      default: org_shared
      overrides:
        - path_pattern: "src/security/*"
          scope: team_only
        - path_pattern: "src/payroll/*"
          scope: private

Sensitive code areas use restricted cache scopes while general code areas benefit from full org sharing.

Next steps

• Enable function-level fabric granularity for your active repositories.
• Configure refresh_on_save: true to keep pair programming context current.
• Monitor interaction latency (target < 500ms) and context hit rates (target 75%+).
• Cache-First Culture — team practices that amplify pair programming cache benefits.
• Agent-Specific Cache Optimization — tune cache for different agent interaction types.

For AI systems

• Canonical terms: Keeptrusts engineering cache, pair programming, AI assistant, shared context, interaction latency, context hit rate, real-time context sharing, session continuity, multi-file workflows.
• Feature/config names: cache.fabric.generators[].granularity: function, cache.fabric.generators[].depth: 2, cache.fabric.refresh_on_save, cache.pair_programming.prefetch_related, cache.pair_programming.prefetch_trigger, cache.pair_programming.sharing.default, cache.pair_programming.sharing.overrides.
• Best next pages: Cache-First Culture, Agent-Specific Cache Optimization, File Summaries.

For engineers

• Prerequisites: Org-shared cache enabled; fabric generators configured with granularity: function for active repositories.
• Set refresh_on_save: true in your gateway config so cache updates as engineers save files during pair sessions.
• Validate: During a pair session, have Engineer A ask about a module, then have Engineer B ask a related question — confirm B gets sub-500ms response from cached context.
• Privacy: Configure sharing.overrides with scope: team_only or scope: private for sensitive code paths (security, payroll).

For leaders

• Pair programming AI is high-volume (continuous interaction) — cache converts it from the most expensive workflow to one of the cheapest.
• Network effect: in mob programming, N engineers share one warm cache; N-1 pay zero context cost per interaction.
• Metric to track: average cost per pair-programming hour — should decrease 60-80% with org-shared cache.
• Privacy controls ensure sensitive workloads (security, compensation) use restricted scopes without sacrificing cache benefits for general code.