{
  "video": {
    "id": "9wZpvF3QleU",
    "title": "500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn",
    "duration": 1225,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer"
  },
  "analysis": {
    "video_id": "9wZpvF3QleU",
    "title": "500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn",
    "one_liner": "LinkedIn made off-the-shelf coding agents useful inside a 1,000-repo enterprise not by fine-tuning but by serving instructions as MCP tools — \"playbooks\" — behind three meta tools (search / get schema / execute), now 600+ playbooks used by 8,000+ people daily.",
    "summary": "Ajay Prakash argues that coding agents like Claude Code, Cursor and GitHub Copilot fail in a large enterprise because LLMs are trained on open-source repos and know nothing about LinkedIn's 1,000+ repos, internal frameworks and custom infra — so engineers hand-prompted the agents, found it slower than coding manually, and went back to manual coding. LinkedIn's answer was an internal MCP server exposing both tools (code search, docs, Jira, Slack, data platforms, feature flags) and, crucially, *playbooks*: task-specific instruction sets that the agent invokes exactly like a tool and receives as tool output. Because MCP degrades past 30–40 tools, everything is hidden behind three meta tools — search, get schema, execute — which is what let the catalogue scale. The system is preinstalled on every LinkedIn laptop, auto-updates hourly, and agents open PRs to fix stale playbooks at the end of a session, creating a self-improving loop.",
    "key_points": [
      "Opening demo, described as real practice at LinkedIn: an on-call engineer pastes an alert link into a coding agent; it fetches the company's debugging instructions, narrows to the specific service, pulls logs and metrics, finds the root cause, proposes mitigation steps, executes them on confirmation, updates the incident management system with metrics and dashboards, and opens a PR — minutes instead of hours.",
      "Why generic agents failed: LLMs are trained on open-source repos, and LinkedIn has 1,000+ repos, thousands of microservices, internal frameworks, its own databases, its own experimentation/tracking platform and its own config management system — new engineers need a week-long boot camp to learn them. Agents hallucinated or got stuck, and manual prompting cost more time than just writing the code.",
      "The bar they set: any coding agent should understand LinkedIn's internals well enough to ship code engineers trust — correct, and of the same quality an actual engineer would write.",
      "They built an internal MCP server early, right after Anthropic released MCP in early 2025. First tool was code search (keywords, custom filters, regex across thousands of repos); then docs, Jira, Slack, data platforms and feature flags — each tool compounding the value of the others.",
      "Tools alone weren't enough. Three named failures: (1) the tribal knowledge for doing a job end-to-end is scattered across docs, wikis and Slack, and is often outdated or duplicated, so agents got lost; (2) context overload — every tool output eats context until the agent compacts and loses information, then has to redo work; (3) no durable memory, so every task starts from scratch.",
      "Playbooks: instructions and prompts served over MCP. A playbook appears as an ordinary tool with a name and description; when the agent invokes it, the instructions and context come back as the tool output. Anyone at LinkedIn can write one and check it into a repository for everyone else.",
      "Two authoring principles: a playbook must be self-contained and cover exactly one task (so the agent picks the right one), and a big playbook must be split into smaller ones referenced from it — giving reusability plus progressive discovery, where the agent reads a sub-playbook only when it needs it.",
      "Self-improving loop: agents are encouraged to identify outdated, missing or inconsistent information at the end of a session, update the playbook, and open a PR — LinkedIn's answer to knowledge bases going stale.",
      "Architecture: one local MCP server preinstalled on every LinkedIn laptop, auto-updating hourly. Central playbooks are cross-cutting; local playbooks live in a repo and are picked up automatically only when the agent works there. A single server also centralises authentication and telemetry.",
      "Scaling past MCP's limits: rather than surfacing everything, three meta tools — search (by keyword and tag), get schema, execute — plus preconfigured system instructions in every coding agent on how to search efficiently. Today: 8,000+ daily users spanning engineers, PMs, designers and TPMs, with over 600 playbooks and over 300 tools."
    ],
    "takeaways": [
      "Don't fine-tune to teach an agent your company — serve instructions the same way you serve tools. Expose task-specific playbooks over MCP so the agent can discover and invoke them itself, instead of relying on engineers to hand-prompt tribal knowledge.",
      "Keep each playbook self-contained to one task and decompose big ones into referenced sub-playbooks, so the agent loads context progressively rather than reading everything up front.",
      "If you have more than ~30–40 tools, stop listing them in MCP. Put a search / get-schema / execute meta-tool layer in front and ship system instructions telling the agent how to search well.",
      "Close the staleness loop with the agent itself: have it flag discrepancies and open a PR against the playbook at the end of each session.",
      "Split central (cross-cutting) from local (repo-checked-in) instructions so teams can add repo-specific context without touching a central repository, and ship the whole thing preinstalled and auto-updating rather than asking engineers to configure it.",
      "Design for quality and reliability before you build the MCP server, and accept that in a large enterprise the latest models and tools are ineffective without agent infrastructure underneath them."
    ],
    "topics": [
      "agents",
      "context-engineering",
      "mcp",
      "coding-agents",
      "skills",
      "developer-productivity",
      "enterprise",
      "tool-scaling"
    ],
    "tools": [
      "LinkedIn",
      "MCP (Model Context Protocol)",
      "Anthropic",
      "Claude Code",
      "GitHub Copilot",
      "Cursor",
      "Claude Skills",
      "Jira",
      "Slack",
      "Airflow"
    ],
    "quotes": [
      {
        "text": "This is not fiction. So this is how teams at LinkedIn are using coding agents as effective co-workers with deep understanding of LinkedIn's internal systems and code.",
        "at": "02:48",
        "url": "https://www.youtube.com/watch?v=9wZpvF3QleU&t=168s"
      },
      {
        "text": "the engineers had to prompt these agents manually um to do the right thing which used to take more time than the manual coding itself. So a lot of engineers went back to manual coding.",
        "at": "04:39",
        "url": "https://www.youtube.com/watch?v=9wZpvF3QleU&t=279s"
      },
      {
        "text": "playbooks are very similar to uh skills but we developed this entire system around playbooks even before skills was a thing.",
        "at": "13:57",
        "url": "https://www.youtube.com/watch?v=9wZpvF3QleU&t=837s"
      },
      {
        "text": "this is a common problem with MCP. we cannot scale it beyond 30 or 40 tools without degrading the uh context or degrading the performance of the system.",
        "at": "17:23",
        "url": "https://www.youtube.com/watch?v=9wZpvF3QleU&t=1043s"
      }
    ],
    "words": 3314
  },
  "summary_url": "/#9wZpvF3QleU",
  "transcript": {
    "html": "/transcripts/9wZpvF3QleU.html",
    "txt": "/transcripts/9wZpvF3QleU.txt",
    "vtt": "/transcripts/9wZpvF3QleU.vtt"
  }
}