How AI Helps Us Cut Project Onboarding Time
We once spent 3 weeks onboarding a senior developer into a running project. He was experienced, read the docs carefully, asked the right questions. But on day 15, when he needed to fix a payment flow, he still had to call the previous dev and ask "where does this service get called from?". It wasn't because the docs were missing. Architecture docs, wiki, README, even video recordings from the last handover. Everything was there. But we all know what happens with those: people skim through, nod along, then go blank when they touch real logic.
This isn't unique to our team. Handing someone docs and hoping they'll read and understand is passive knowledge transfer, and passive transfer has a terrible success rate. "Reading" isn't "understanding", and "understanding" isn't "being able to explain it yourself". Anyone who's ever trained a new hire knows this.
We tried something different.
Socrates didn't lecture. He asked.
Over 2,400 years ago, the philosopher Socrates had a very particular way of teaching: he never lectured. He just asked questions. Deliberately, persistently, until the other person realized on their own where they were wrong.
The principle is simple: when you're asked a question, you're forced to think. You can't fake understanding if you have to explain it in your own words. The moment you hesitate, give a wrong answer, or say "I'm not sure about this part", the blind spot is exposed. And that's when real learning starts, because now the teacher knows exactly what to teach.
This method works but has a very practical limitation: it requires someone knowledgeable sitting 1:1 with each person. Scaling to 5 people is already hard. 50 is impossible. Until we realized AI can do this, and it never gets tired.
Teach-Me
So we built teach-me, a skill in our internal AI system that does one thing: onboard developers into projects using the Socratic method. Instead of handing over docs and hoping for the best, teach-me actively asks questions to find out what the dev doesn't know, then teaches exactly that.
The process starts with teach-me analyzing the codebase and synthesizing it: high-level architecture, main modules, business flows. The dev reads through this first to get the big picture. This part is just preparation.
The important part comes next. The AI starts asking.
Not "do you understand?" in a perfunctory way. It asks specific questions: "How does the authentication module handle token refresh when a session expires?" or "If the payment service doesn't respond within 30 seconds, what happens?"
The dev has to answer in their own words. Through those answers, what they understand correctly, what they got wrong, what they have no idea about, it all comes out. No one needs to guess, because the dev has already revealed it through how they explain things.
When it finds a blind spot, the AI doesn't go back and re-teach everything from the beginning. It only explains the part that's missing, then asks again to confirm. Someone already familiar with a similar system might only need to learn 20% of the new material, the rest gets confirmed and skipped. The loop continues: ask, find gap, teach gap, ask again, until the threshold is met and it moves to the next module.
And the AI doesn't teach in A-Z order of the documentation. It starts with what matters most, critical path first, edge cases later. The traditional way, a dev spends 4-6 weeks reading front to back without knowing what to prioritize. With this approach, by week one they've grasped the core system. Week two they start contributing real code. The rest they learn as needed. Nobody has to understand the entire system before they're allowed to touch code.
Management sees it. No need to ask.
One thing we really like about this process: the entire onboarding journey is recorded. Questions the AI asked, the dev's answers, which parts they passed, which parts need revisiting. All of it becomes a report.
Managers don't need to pull a dev aside and ask "how's onboarding going?" only to get a vague answer. The data is right there: dev A understands 80% of the authentication module but only 30% of the payment flow. You know exactly where to help, instead of waiting 2 weeks to discover "I didn't really get that part". When a dev is struggling, management sees it early and can step in right away, instead of letting someone spin their wheels alone before anyone notices.
Faster onboarding isn't because we skipped any steps. It's because the biggest waste in the old process got eliminated: re-teaching what people already know, and missing what they don't. The AI does exactly what Socrates did 2,400 years ago: asks the right questions, finds the right gaps, teaches the right parts. The only difference is it works 24/7 and doesn't lose patience after the third person.
Are your developers actually understanding the system, or are they just reading docs and nodding?