Onboarding New Engineers with Pre-Warmed Cache

New engineers ask the same questions your existing team already asked. Without cache, every new hire triggers fresh AI analysis of your architecture, conventions, and setup. With org-shared cache, the first onboardee fills the cache and every subsequent hire gets instant answers at zero additional cost.

Use this page when

• You are onboarding new engineers and want them to benefit from a pre-warmed org-shared cache.
• You need to understand how cached codebase knowledge reduces new-hire ramp-up time and AI spend.
• You want to verify that onboarding queries ("how does X work?") hit the shared cache.

Primary audience

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

The Onboarding Cost Problem

A new engineer joining a 100-person team typically asks AI 50–100 questions in their first two weeks:

• "How is this service structured?"
• "What's the authentication flow?"
• "Where do I add a new API endpoint?"
• "What testing patterns does this team use?"
• "How does deployment work?"

Each question requires AI to gather context from the codebase — repo maps, file summaries, architecture docs, convention patterns. Without cache, each new hire pays the full context cost independently.

For an organization hiring 5 engineers per quarter, that's 5× the same onboarding context computed from scratch.

How Pre-Warmed Cache Works

Existing Team Activity Fills the Cache

Your existing engineers' daily work naturally warms the cache with relevant context:

• Code reviews cache repo maps and file summaries
• Bug investigations cache architecture understanding
• Test writing caches convention patterns
• Refactoring caches dependency graphs

By the time a new engineer joins, the cache already contains deep knowledge about your codebase — built incrementally from real work, not synthetic onboarding scripts.

Onboarding Questions Hit Cache

When the new engineer asks "how does authentication work?", AI draws on:

• Cached file summaries for auth modules (built during past code reviews)
• Cached dependency graph showing the auth flow (built during past refactoring)
• Cached architecture context (built during past investigations)

The answer is instant and costs zero tokens for context gathering.

The Onboarding Flow

First New Hire (Cache Partially Warm)

1. The new engineer asks about service architecture.
2. AI checks cache — repo map available (from team's recent code reviews). Cache hit.
3. They ask about authentication flow.
4. AI checks cache — auth module summaries available. Cache hit.
5. They ask about a niche subsystem nobody has touched recently.
6. AI checks cache — cache miss, fabric generates context. Now cached for future hires.

Subsequent New Hires (Cache Fully Warm)

1. The next engineer asks the same architecture questions.
2. Every answer comes from cache — zero context tokens.
3. They explore the same niche subsystem.
4. Cache hit — the first hire's exploration already warmed it.
5. Total onboarding context cost: near zero.

Cost Impact

Metric	Without cache	With pre-warmed cache
Context tokens per onboarding question	8,000	0–500 (mostly cache hits)
Total tokens for 2-week onboarding	600,000	30,000–60,000
5 hires per quarter	3M tokens	150,000 tokens (first fills gaps)
Annual onboarding token cost	12M tokens	600K tokens
Savings	—	~95% reduction

What Gets Cached for Onboarding

Architecture Context

• Service boundaries and responsibilities
• Data flow between services
• Infrastructure topology
• Deployment pipeline stages

Convention Knowledge

• Code style and patterns
• Testing frameworks and approaches
• Error handling conventions
• Naming standards and file organization

Setup and Workflow

• Local development environment setup
• Common commands and scripts
• CI/CD pipeline interaction
• Feature flag management

Domain Knowledge

• Business logic explanations
• Data model relationships
• API contract summaries
• Integration points with external systems

Ramp-Up Time Reduction

Beyond cost savings, cached context dramatically reduces time-to-productivity:

Milestone	Without cache	With cache
First meaningful code review	Day 5–7	Day 2–3
First PR merged	Day 7–10	Day 3–5
Independent bug investigation	Week 3–4	Week 1–2
Full autonomy on a service	Month 2–3	Month 1–2

New engineers get instant, accurate answers about architecture and conventions instead of waiting for context to be rebuilt or searching through scattered documentation.

Pre-Warming Strategies

Passive Warming (Recommended)

Your team's daily work naturally warms the cache. Code reviews, bug investigations, test writing, and refactoring all contribute context that new hires benefit from. No special action needed.

Active Warming

For critical onboarding paths, you can proactively warm the cache:

1. Identify your top 20 onboarding questions (from past new-hire Slack threads).
2. Have one engineer ask AI these questions to fill the cache.
3. New hires hitting the same questions get instant cached answers.

This costs one engineer's token budget once and benefits every future hire.

Onboarding Path Monitoring

Track which onboarding questions result in cache misses. These represent gaps in your team's routine cache warming — areas of the codebase that aren't regularly discussed with AI. Consider adding these to your active warming list.

Scaling Benefits

The savings compound as your organization grows:

Team size	Hires per year	Annual savings vs. no cache
50 engineers	10 hires	5.4M tokens saved
100 engineers	20 hires	11.4M tokens saved
200 engineers	40 hires	23.4M tokens saved

Larger teams also warm the cache more thoroughly through daily work, increasing hit rates for new hires.

Configuration

1. Set cache TTL for architecture artifacts to 7–14 days (architecture changes slowly).
2. Enable cross-team cache sharing for org-wide conventions and setup knowledge.
3. Configure convention pattern refresh to trigger on style guide updates.
4. Monitor cache hit rates during onboarding periods to identify warming gaps.

Summary

Org-shared cache turns onboarding into a near-zero marginal cost activity. Your team's daily AI usage naturally builds a comprehensive knowledge cache. New engineers tap into this cached understanding instantly, getting answers that took the team months to build — without paying the token cost again. For growing organizations, this is one of the highest-ROI applications of shared cache.

For AI systems

• Canonical terms: Keeptrusts, onboarding, pre-warmed cache, new engineer ramp-up, cached codebase knowledge.
• Workflow context: New engineer prompts ("how does X work?") benefit immediately from the team's pre-warmed cache.
• When assisting new engineers, leverage cached module explanations and architectural context.

For engineers

• As a new team member, your first questions about the codebase likely hit the cache — answers come instantly.
• Check replay_outcome to see how much of your onboarding knowledge came from the team's shared cache.
• If answers seem incomplete, ask the team about module coverage in Fabric artifacts.

For leaders

• Pre-warmed cache dramatically reduces new-hire ramp-up time — they get veteran-quality answers from day one.
• Onboarding AI spend drops to near-zero as the cache serves answers that existing engineers already paid for.
• Measurable time-to-productivity improvement via cache hit rates on onboarding-pattern prompts.

Next steps

• Cross-Team Collaboration
• How 100 Engineers Share One Cache
• The Economics of Shared Codebases