Jira

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn

Sep 9, 2026 · 20:25

Ajay Prakash, senior staff software engineer at LinkedIn, explains how Contextual Agent Playbooks make coding agents reliable at enterprise scale, turning an on-call alert into a mitigated incident in minutes. Early vibe coding failed: agents trained on open source hallucinated across LinkedIn's 1,000 internal repos. An internal MCP server with code search, docs, and Jira fell short: tribal knowledge sat in stale wikis, context overloaded, and sessions started from scratch. Playbooks, instructions published as tools, work when self-contained and split into small referenced pieces, and agents open PRs to refresh stale ones. Since MCP degrades past 30 or 40 tools, everything surfaces behind three meta tools: search, get schema, execute, now 1,300 tools, 600 playbooks, 8,000 daily users.

Building GTM AI Agents: Lessons from Deploying to 6,000 Users — Sait Izmit, Snowflake

Aug 26, 2026 · 20:39

Sait Izmit of Snowflake says winning over 6,000 go-to-market users comes down to quality over coverage: he wrote 150 sales questions before testing, accepted 50% first accuracy, and chose 50 questions at 95% over 100 at 70%. The Snowflake Cowork agent, live since September, has answered over a million questions (~40,000 weekly); 60% of data arrived post-launch, and it now spans 15 semantic views, 85 tables, 3,000 columns, MCPs, and 20 skills. After pilot and a 600-user 10% beta with 70% retention, GA showed only 20% of the org tried it, so Izmit spends 60-70% of his time on demos and sales meetings. He warns the wow factor collapses quickly, so teams must move from data chat to workflow automation, build fast with today's stack, accept rearchitecture, and mine logs for feedback loops.

Agent Frameworks Considered Harmful — Rémi Louf, .txt

Aug 22, 2026 · 20:29

Rémi Louf, CEO of .txt, argues agent frameworks are harmful because they keep agents trapped in code; he built a runtime where agents are markdown files triggered by events. Taking two weeks away from his 15-person company, he wanted a morning briefing that processes voice notes, market news, and CRM updates. Each failure in the first week led to infrastructure: an append-only log, a real queue, and content-addressed prompts stored as hashes, enabling diffing and replaying runs. He insists typed tool calls and typed events are non-negotiable boundaries, since 20% of his events were malformed and rejected. After deploying it, 20 agents now run, and he replaced third-party APIs with open-source models. His advice: build before you buy.

Building Blocks for Uber’s Software Factory— Uday Kiran Medisetty & Adam Huda, Uber

Aug 21, 2026 · 18:26

Uber's Uday Kiran Medisetty and Adam Huda explain the six building blocks of their agentic software factory, which now generates more than 70% of pull requests and has doubled lines of code per engineer year over year. A model gateway handles 100 million requests a day across 800 projects with redaction of 20+ PII types and safety models under 100 milliseconds; an MCP gateway cuts token use over 40%, a skills marketplace runs 20,000 executions daily across 2,500 skills, and a context graph of 40 million entries replaces 20-30 systems. Adam shows one feature end-to-end, from Slack idea to draft PR that stops before CI, validating via simulator screenshots against Figma in an inner loop. The bottleneck, they argue, has moved to deciding whether a thing should be built at all.

Prototyping as Leadership: How a CTO Ships with AI Agents — Hursh Agrawal, The Browser Company

Aug 20, 2026 · 18:18

Hursh Agrawal, CTO and co-founder of The Browser Company, argues AI coding agents let leaders keep building: despite 15+ meetings, 7 direct reports, and a toddler, he ships 2–10 PRs/week. He says frontier models turn over every three months, so hands-on building is the only way to judge them and show engineers working prototypes. His method is an overnight loop: a coworker agent gathers Slack/Jira/Notion context into a prompt at 5pm, coding agent runs for hours, and a morning hour reviews tests, CI, and AI code review. He details three overnight uses: building features, hill-climbing evals from feedback JSONs, and training custom models like a PII classifier on AWS. He warns leaders to avoid critical path work and to rely on trustworthy CI, feature flags, a prototype branch, and readable PRs.

Your Finance Agent's Bottleneck Is You — Ramana Siddanth Emani, Auditoria AI

Jul 30, 2026 · 13:42

Ramana Siddanth Emani, data scientist at Auditoria AI, argues that the bottleneck in shipping production finance agents is the developer in the loop, not the model or GPUs. He presents harnessing coding agents across parallel git worktrees (50 with 48GB RAM) to automate bug fixes from QA and Jira tickets, with sub agents pulling traces, logs, running tests, and creating PRs, needing human input only at task assignment and final verification. In the finance sector, regulation demands human oversight, so agents handle the grind while developers focus on verification. Emani advocates for recursive self-improvement where agents analyze bottlenecks and upgrade loops; after a month, a developer can simply type 'fix this bug' and the agent handles everything, allowing developers to step out of the loop while remaining final verifiers.

State of Data — Sean Cai, Independent / State of Data

Jul 26, 2026 · 18:22

Sean Cai argues data markets, not compute, are now the binding constraint for turning generalist AI into expert systems, with the supply chain unbundling from vertical giants into specialist vendors. He distinguishes Type I (real workflow capture) from contrived Type II data, noting the industry sells Type II as Type I. He introduces Verifier's Law—ease of training proportional to task verifiability—to predict domain maturity: code first, then biology, security, finance. He exposes benchmark psychosis: a single number under one scaffold is a noisy sample, requiring cross-harness differencing. Labs like Anthropic's data spending forecasts product launches (e.g., cybersecurity data in January led to Claude Cyber in March). Data companies like Mercor pivot to enterprise, and Cai builds Antikythera mechanisms to monetize real-world workflows and provide RL-as-a-service.

Building an Autonomous Engineering Org - Angie Jones, Agentic AI Foundation

Jun 28, 2026 · 17:36

Angie Jones describes how she transformed Block's 3,500-person engineering org into an autonomous one using AI agents, starting with a maturity model and an AI champions program of 50 hand-picked engineers. She details making repos AI-ready with context and rules files, then enabling delegation from Slack, Jira, and GitHub, which boosted AI-authored code by 69% and automated PRs 21x. Multi-agent parallelism required cloud workspaces and a company world model across 25,000 repos, culminating in BuilderBot that allowed anyone to @mention it for fixes. However, the success led to layoffs, raising existential questions about the human cost of autonomous engineering.

Using Spec-Driven Development for Production Workflows - Erik Hanchett, AWS

Jun 28, 2026 · 17:47

Erik Hanchett (AWS) argues that spec-driven development—writing markdown specification files before any code—produces higher quality code by guiding AI coding assistants, which he compares to 'AI interns' that need explicit direction. He introduces Kiro, AWS’s new AI IDE and CLI, which offers a spec mode that generates requirements documents, design documents with mermaid diagrams, property-based tests using Fastcheck, and a task list. In a demo building a movie website, Kiro created an MVP-focused implementation verified by property tests. Hanchett also highlights integrating external data via the Model Context Protocol (MCP) and stresses the importance of human review. He advises balancing context in steering docs and using on-demand skills to control the workflow.

Why More Context Makes Your Agent Dumber and What to Do About It — Nupur Sharma, Qodo

Jun 8, 2026 · 26:27

Nupur Sharma from Qodo explains why giving an AI agent more context often makes it dumber, describing the 'U curve' where models attend only to the start and end of inputs while dropping the middle. She covers practical fixes: iterative retrieval, hierarchical summarization, and self-correction with honest cost tradeoffs. The talk introduces the 'orchestration paradox'—smart models waste most tokens figuring out how to solve a problem rather than solving it—and Qodo's 80/20 hybrid: high-reasoning models for open-ended discovery, lighter deterministic models for validation. Sharma walks through Qodo's code review architecture: a context collector feeds specialized agents (security, code quality, etc.), a judge node recombines results against PR history, and every accepted or rejected suggestion shifts weighting for future reviews.

Why your agents need decision traces, not just documents — Zach Blumenfeld, Neo4j

May 29, 2026 · 20:12

Zach Blumenfeld from Neo4j argues that context graphs—a graph-based layer storing decision traces, precedence, and causal chains—extend standard RAG to make AI agents more accurate and explainable. A financial analyst agent, for example, can reject or accept a request by retrieving past decision traces and structurally similar precedents via graph embeddings, not just semantic similarity. Neo4j's one-command tool `uvx create-context-graph` scaffolds a full-stack app with backend, frontend, demo data, and MCP server, supporting 22 built-in domains or custom ontology generation. The underlying `neo4j-agent-memory` package handles entity extraction through a spaCy-to-GLiNER-to-LLM pipeline with deduplication and integrates with pydantic AI, LangGraph, Crew, Google ADK, and others. The episode also covers data connectors for GitHub, Notion, Jira, and Slack, and the ability to store and query decision traces with timestamps, though automated trace quality evaluation is still evolving.

Demand-Driven Context: A Methodology for Coherent Knowledge Bases Through Agent Failure

May 5, 2026 · 1:08:15

Raj Navakoti, a staff software engineer at IKEA, presents a demand-driven context methodology for building coherent knowledge bases by letting AI agents fail on real problems and surfacing missing institutional knowledge. He argues that enterprises should shift from pushing monolithic documentation to a pull approach where agents reveal undocumented tribal knowledge through repeated failures on incidents and Jira tickets. Using a framework with skills, rules, and hooks, he demonstrates how agents can gradually improve confidence scores (from 1.4 to 4.4 over 14 incidents) by documenting discovered context blocks. Navakoti introduces a context gap scanner that automatically analyzes work items against existing documentation to identify critical gaps, outdated information, and duplications. He advocates storing curated knowledge in GitHub for version control and PR-based collaboration, and emphasizes that this approach helps teams know the unknown, enabling agents to manage knowledge rather than just consume it.

Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment — Maggie Appleton, GitHub

Apr 26, 2026 · 17:43

Maggie Appleton, a staff research engineer at GitHub Next, argues that the current paradigm of one developer with a fleet of solo agents leads to zero team alignment, making software a team sport that requires shared context. She presents ACE (Agent Collaboration Environment), a multiplayer research prototype that provides shared chat sessions backed by micro VMs and Git branches, enabling real-time collaboration where designers, PMs, and developers can all prompt agents together. The talk emphasizes that implementation is now cheap and fast, so the hard question is "should we build it?" — requiring early, constant alignment to avoid wasted work, coordination debt, and unrequested features. ACE aims to reclaim time for rigorous critical thinking by letting teams plan, build, and review in a single shared space, with proactive agents summarizing team activity and unfinished work. Appleton contends that quality becomes the differentiator in a world of cheap code, and tools like ACE can help teams build a few exceptional things rather than a thousand crappy ones.

Bending a Public MCP Server Without Breaking It — Nimrod Hauser, Baz

Apr 8, 2026 · 40:50

Nimrod Hauser, founding engineer at Baz, presents a hands-on guide to adapting third-party MCP servers for production, using Playwright's MCP server as an example. He demonstrates five best practices—curation, wrapping descriptions, deterministic guardrails, composing new tools, and treating tools as deterministic functions—to transform a brittle setup into resilient infrastructure. Hauser shows how curating tools from 21 to 16 reduces context load, while enhanced descriptions guide agents to use accessibility snapshots before clicking. Deterministic path validation prevents agents from saving screenshots outside a designated folder, and a new 'evidence tool' with tailored instructions improves spec review accuracy. The talk culminates with Baz's Spec Reviewer, an agentic code review tool that compares requirements against implementation, successfully passing a test after applying all optimizations.

Your Support Team Should Ship Code – Lisa Orr, Zapier

Dec 16, 2025 · 16:06

Lisa Orr of Zapier explains how the company empowers its support team to ship code using AI, tackling the app erosion caused by 8,000+ third-party integrations. Initially, they built an API playground that failed due to lack of workflow embedding, then pivoted to MCP tools in IDEs, but the slow Diagnosis tool led to an asynchronous agent. The resulting Scout Agent autonomously categorizes tickets, assesses fixability, generates merge requests, and enables rapid iteration in GitLab. Today, Scout drives 40% of support's integration fixes, doubling individual velocity from 1-2 to 3-4 tickets per week. Orr highlights support's three superpowers: closest to customer pain, real-time troubleshooting, and best at validation, with some team members becoming engineers.

No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer

Dec 2, 2025 · 20:31

Dex Horthy of HumanLayer argues that with deliberate context engineering — specifically a technique he calls "frequent intentional compaction" — today's AI coding agents can handle large brownfield codebases, not just greenfield projects. He presents a three-phase workflow (research, plan, implement) that keeps agents in the "smart zone" of the context window, avoiding the diminishing returns that set in around the 40% mark. Horthy demonstrates this approach solving a real problem in a 300k-line Rust codebase, shipping a week's worth of work in seven hours with code that passed expert review. He cautions against outsourcing thinking to AI, emphasising that plans must include actual code snippets for reliable execution and team alignment. The talk also addresses the cultural rift where senior engineers clean up slop from juniors' AI tools, calling for top-down adoption and team-wide workflow adaptation.

What Data from 20m Pull Requests Reveal About AI Transformation — Nick Arcolano, Jellyfish

Nov 24, 2025 · 17:57

Nick Arcolano, head of research at Jellyfish, presents data from 20 million pull requests across 200,000 engineers at 1,000 companies to reveal what AI transformation actually looks like. Median AI adoption of interactive coding tools (Copilot, Cursor, Claude Code) jumped from 22% in June 2024 to nearly 90% today, driving a 2x increase in PR throughput and 24% faster cycle times on average. Autonomous agents like Devin and Codex remain negligible—only 44% of companies have tried them, contributing less than 0.2% of PRs. PRs grow 18% larger with AI, but bug rates and reverts show no significant quality impact. Crucially, code architecture determines success: centralized and balanced repos see 4x throughput gains, while highly distributed architectures (many repos per engineer) show no correlation with AI adoption, likely due to cross-repo context limitations. Arcolano advises focusing on adoption first, then addressing architectural barriers to unlock productivity.

Layering every technique in RAG, one query at a time - David Karam, Pi Labs (fmr. Google Search)

Jul 29, 2025 · 20:22

David Karam of Pi Labs (formerly Google Search) walks through layering every technique in RAG, from in-memory retrieval to planet-scale search with 70+ corpus mix of token, embeddings, and knowledge graphs, jointly retrieved and re-ranked at 160,000 queries per second in under 200msec. He advocates a Quality Engineering Loop: baseline with simplest methods, analyze losses, then apply incremental techniques based on complexity-adjusted impact. Karam explains why queries like "falafel" are notoriously hard due to ambiguous intent, highlights failures of chunking documents, and shows when BM25 suffices, when relevance embeddings are needed, and when custom embeddings or domain-specific signals (price, popularity, user clicks) become essential. He covers query orchestration via fan-out, supplementary retrieval across back ends, and distillation for cost optimization, concluding that at sufficient complexity, problems must be punted to LLM or UX for graceful degradation.

Piloting agents in GitHub Copilot - Christopher Harrison, Microsoft

Jul 26, 2025 · 59:07

Christopher Harrison (Microsoft) demonstrates GitHub Copilot's agent capabilities for AI Engineers, arguing context is key to effective pair programming. He explains Copilot's modes—completion, chat, edit, local agent, and coding agent—and how Model Context Protocol (MCP) enables access to external tools like databases. Harrison shows how Copilot-instructions.md files provide project-specific guidance, and how coding agent runs within ephemeral GitHub Actions environments with strict security (no external access, only write to its own branch). He emphasizes that AI doesn't change DevOps fundamentals: tests still run locally and via PR workflows, and code review remains essential. The lab covers assigning issues to Copilot, configuring MCP servers, and using .instructions files for reusable patterns, with a repeat session at 3:30 PM.

Ship Production Software in Minutes, Not Months — Eno Reyes, Factory

Jul 25, 2025 · 16:06

Eno Reyes, cofounder and CTO of Factory, argues that AI agents can orchestrate the entire software development lifecycle, moving beyond vibe coding to agent-native development where enterprises delegate planning, coding, testing, and incident response to autonomous droids. He explains that AI tools are only as good as the context they receive—missing context from meetings, whiteboards, or Slack is the primary cause of failure, not LLM quality. Factory's droids search codebases, leverage organizational memory, and question unclear tasks before executing, from generating PRDs and tickets to creating runbooks and RCAs from sentry alerts. Reyes demonstrates how an agent can convert user transcripts and ad-hoc notes into a full feature plan, then break it into parallel tickets for multiple code droids. For incident response, droids pull logs, historical runbooks, and team discussions to produce mitigation plans in minutes, cutting response times in half and shifting from reactive to predictive operations. He emphasizes that the future belongs to engineers who manage agents—thinking clearly and communicating effectively—rather than those writing every line of code.

Devin 2.0 and the Future of SWE - Scott Wu, Cognition

Jul 25, 2025 · 16:13

Scott Wu of Cognition AI describes an AI 'Moore's Law' for coding agents, with capability doubling every 70 days, propelling Devin from simple migrations to autonomous project work. He traces Devin's evolution through tiers: first repetitive migrations using Playbooks for instruction-following, then isolated bugs with VM snapshots, then multi-file changes with codebase intelligence, and finally backlog killing with self-testing. Each tier required solving different bottlenecks—memory, language server integration, iterative planning, and confidence calibration. Wu argues that the interface and key capabilities shift every 2-3 months, and predicts another 16-64x improvement in the next year.

How to build world-class AI products — Sarah Sachs (AI lead @ Notion) & Carlos Esteban (Braintrust)

Jun 27, 2025 · 1:43:46

Sarah Sachs (AI lead at Notion) and Carlos Esteban (Braintrust) explain that building great AI products requires 10% prompting and 90% evals and observability, with Notion AI using Braintrust to iterate on prompts and models. Sachs details their cycle: curate small datasets, tie them to scoring functions (LLM-as-a-judge with per-sample prompts and heuristic checks), run evals before shipping, and use production logs to catch regressions. She notes Notion AI supports 100M+ users, switches models in under a day, and 60% of enterprise users are non-English—requiring multilingual eval rigor. Carlos and Doug then walk through Braintrust's framework: tasks (prompts, tools, agents), datasets, and scores (0-1). They demonstrate offline evals via playground and SDK, online scoring in production, user feedback capture, human review setup, and remote evals to bridge complex code with the playground. The workshop covers moving from pre-prod evals to production monitoring, closing the feedback loop by adding underperforming spans to datasets.

Windsurf everywhere, doing everything, all at once - Kevin Hou, Windsurf

Jun 23, 2025 · 16:03

Windsurf head of product Kevin Hou explains the company's philosophy of a shared human-AI timeline and its vision to be everywhere, do everything, and work all the time. The AI ingests context from tools like Google Docs, Figma, GitHub, and Notion, and takes actions beyond coding—opening PRs, deploying, and reviewing code. Windsurf generates 90 million lines of code daily and processes over 1,000 messages per minute. Its new model SWE-1, trained on software engineering workflows, achieves near-frontier performance with a fraction of the resources. Hou emphasizes a data flywheel where user feedback on real workflows drives continuous improvement, arguing that successful AI products in 2025 require harmony among model, data, and application.

Beyond Conversation: Why Documents Transform Natural Language into Code - Filip Kozera

Jun 10, 2025 · 10:57

Filip Kozera argues that chat-based interfaces like ChatGPT create ephemeral, polluted context windows and lack forced clarity, making them poor for specifying complex systems, while documents naturally force rigor and structured thinking. He advocates shifting from conversational brainstorming to document-driven workflows, where humans precisely articulate intent for AI agents. Kozera introduces background agents that run asynchronously, triggered by events like emails or meetings, and surface only when needing human approval, turning the human role into one of 'swiping left or right' to approve or edit outputs. He envisions a future where humans manage swarms of such agents, first adopted by prosumers and later by enterprises, with taste and intent becoming critical for imbuing personal brand into agent outputs. The episode presents a clear progression from chat-based brainstorming to structured document-driven agent systems.

The Robots are coming for your job, and that's okay - Elmer Thomas and Maria Bermudez

Jun 3, 2025 · 8:57

Elmer Thomas and Maria Bermudez of Twilio's developer education team explain how they built six single-purpose AI agents to automate repetitive documentation tasks like editing, alt text generation, and jargon simplification, rather than replacing human writers. The agents, powered by GPT-4/01 and validated with tools like Veil Lint and CI tests, reduce hallucinations through layered human review. Maria demos the automated editor, SEO metadata generator, alt text generator, and jargon simplifier. The team’s playbook: identify a pain point, pick a repeatable task, and iterate with weekly user feedback.

Self Coding Agents — Colin Flaherty, Augment Code

Apr 21, 2025 · 17:23

Colin Flaherty, founding researcher at Augment Code, describes how the company built an AI coding agent that wrote over 90% of its own 20,000-line codebase with human supervision. The agent autonomously added third-party integrations like Google Search and Linear by searching its own codebase and even used its own Google Search tool to look up Linear API docs. It profiled and optimized itself, replacing synchronous file hashing with a process pool after adding print statements and running sub-copies. Flaherty argues that agent capabilities improve with better context engines, code execution environments, and test harnesses—adding test-driven iteration boosted a bug-fixing benchmark by 20% versus 4% from just upgrading the foundation model. He cautions that agents are general-purpose, not category-specific, and have different strengths than humans, making knowledge bases crucial for onboarding. With code becoming cheap, the focus shifts to product insights and design, while better tests enable greater autonomy and accelerate agent self-improvement.

The Hidden Costs of Building Your Own RAG Stack — Ofer Vectara

Feb 22, 2025 · 15:14

Ofer from Vectara argues that building your own RAG stack comes with seven hidden costs: irrelevant responses and hallucinations, high latency, scaling and cost issues, security and compliance challenges, vendor chaos from multiple components, unsustainable expertise requirements, and limited non-English language support. He details how each pitfall compounds at enterprise scale, citing the need for hybrid search, reranking, and continuous evaluation to maintain quality. Vectara offers a turnkey RAG-as-a-service platform that handles parsing, chunking, embedding, vector search, retrieval, and hallucination detection. Ofer highlights Vectara’s open-source HHEM model for hallucination evaluation, downloaded over 3 million times, and a leaderboard showing some LLMs hallucinate at rates above 10%. The platform supports deployment in SaaS, VPC, or on-premises, with built-in access control and explainability.

Enhancing Quality and Security in CI: Gunjan Patel

Nov 27, 2024 · 18:27

Gunjan Patel, Director of Engineering at Palo Alto Networks, presents Ghost Pilot, an AI-powered CI pipeline that outsources boring software development tasks to enable self-evolving code. Unlike real-time Copilots, Ghost Pilot operates as a 'slow system' in CI, iteratively improving variable names and code comments, then generating unit tests by first listing edge cases and personalizing them via team context files. For security, it simulates three AI roles—Red Team engineer, developer, and engineering manager—who debate identified vulnerabilities, prioritize fixes by risk and effort, and propose changes with citations. Patel shares a reusable CI template with a Bring-Your-Own-LLM option, demonstrated by catching a logical Kubernetes bug missed by static analysis tools.