Yishai Beeri
CTO at LinearB
Tel Aviv, Israel
Actions
Yishai Beeri likes to solve problems, and that’s why he was so fascinated with programming when first encountered Logo back in the 80s, where the possibilities seemed endless.
He has made it a focus of his career to solve complex programming problems, as a consultant and entrepreneur. Between 2013 and 2020, Yishai worked in the CTO office of a fast moving cloud security startup, and after its acquisition in the Cloud Security unit of a networking giant. In 2020 Yishai joined LinearB to focus on Developer Productivity and Experience. As CTO he engages with hundreds of engineering leaders and helps build products that answer the industry's core questions about AI & Productivity for software engineering.
Links
Badges
Area of Expertise
Topics
Are Your Engineering Teams Really Prepared for the AI Revolution?!
AI for coding has gone from novel technology to widely adopted in a matter of months. Most engineering organizations now use AI to generate code, write tests, and assist in code reviews. New code is becoming dirt cheap to write - but our delivery pipelines remain miserably unprepared for the tsunami of new code flowing at a much more rapid pace.
Our delivery pipelines need a hard reset to allow use to embrace the AI revolution - and engineering leaders need to get started TODAY.
This talk will dive into where AI is already starting to break our delivery pipelines. While scaling CI/CD is easy, and we can always throw more CPU at it, scaling the humans in the process is the hard part. This talk will demonstrate how massive amounts of new AI-generated code are impacting our pipelines in ways that will require either greater headcount, or smarter, automated pipelines.
You'll come away with concrete ideas for modernizing your delivery pipeline to avoid the new bottlenecks and unlock the new levels of engineering productivity AI is promising.
From AI to Burnout: Shaping Developer Productivity in 2025
The software engineering landscape is undergoing a seismic shift, driven by the rapid evolution of generative AI, the complexities of developer productivity, and the need to balance innovation with human creativity. This talk reviews 2025's key trends - from AI-enhanced tools to the experimentation with agentic AI in software development life cycles - and ventures a peek into 2026.
Attendees will gain insights into how engineering teams can integrate AI into toolchains effectively, preserve creativity amidst automation, and navigate emerging challenges in developer experience and cybersecurity. With bold predictions and actionable frameworks, this session empowers leaders to balance efficiency with empathy, ensuring both organizational success and developer well-being in the face of accelerating technological change.
Key Takeaways:
- Understand the dual trajectory of AI in 2025: mature assistance tools versus experimental agentic AI.
- Integrate AI into existing workflows while preserving human creativity and innovation.
- Measure and enhance developer experience using a combination of qualitative and quantitative metrics.
- Mitigate burnout by fostering a balance between efficiency, empathy, and team well-being.
- Adopt a data-driven approach to tackle productivity challenges and maximize AI’s potential.
Your AI Code Reviews Are Missing the Point (And How to Fix It)
Short form:
AI code reviews often feel like tossing a coin. Heads - you get endless nitpicks about style. Tails - it finds real issues. And even when the signal is good, are we really getting quality and productivity benefits?
The secret isn't the AI, it's how you deploy it. Leveraging learnings from O(1K) teams and O(1M) AI code reviews, this talk explores what actually drives value in AI-assisted code reviews: rich context, scalable personalization, and a direct way to measure impact on developer productivity.
Learn to transform AI reviews from a compliance checkbox into a strategic advantage for your engineering organization.
Long Form:
Most AI code review implementations focus on the wrong metrics - counting comments generated or code accepted rather than measuring developer velocity and code quality improvements. The real value lies in intelligent context integration and organizational learning at scale.
This talk examines successful AI code review deployments across engineering organizations, revealing four critical success factors: seamless integration with your existing development context (codebase, tickets, architectural decisions), specialized review guidelines that scale from 5 to 50,000 repositories, comprehensive observability to understand where AI adds value versus where it creates noise, and strategic human-AI collaboration patterns.
We'll explore real case studies of teams who've moved beyond basic linting to utilizing AI code review that understands business logic, catches architectural anti-patterns, and actually accelerate PR cycles. You'll learn when AI reviews shine, when they don't, and how to measure the difference.
This isn't about replacing human reviewers - it's about building an intelligent system that amplifies human expertise and reduces cognitive load where it matters most.
AI code reviews often feel like tossing a coin. Heads - you get endless nitpicks about style. Tails - it finds real issues. And even when the signal is good, are we really getting quality and productivity benefits?
The secret isn't the AI, it's how you deploy it.
Leveraging learnings from O(1K) teams and O(1M) AI code reviews, this talk explores what actually drives value in AI-assisted code reviews: rich contextual, scalable personalization, and a direct way to measure impact on developer productivity. Learn to transform AI reviews from a compliance checkbox into a strategic advantage for your engineering organization.
Key Takeaways:
- Learn how connecting AI reviews to codebase history, work items, and architectural documentation transforms generic feedback into business-aware insights that actually matter
- Navigate the challenge of maintaining review guidelines and best practices across thousands of repositories - from monorepo strategies to automated guideline propagation and conflict resolution
- Track AI review impact on productivity metric such as cycle time, along with code quality metrics and developer satisfaction, plus warning signs that your AI is becoming a rubber stamp
- Connect AI code review with automations to tackle the new code acceptance bottleneck and unblock productivity for your teams
AI Code Review Under the Hood: The Feedback Engine Behind 99.4% Satisfaction
Short:
Most AI code review tools impress in demos and disappoint in production. This talk goes under the hood dissecting how LinearB's AI reviews over 5K pull requests daily with a 99.4% satisfaction rate. Hint: it wasn't done by nailing the model on day one, but by building a system that learns from every review.
We review what makes an AI code review system genuinely useful; our architecture choices for building context (e.g. dynamic RAG) and prompt engineering; and the evaluation system; and at the core - the AI driven feedback loop that powers continuous improvement.
Longer:
Most AI code review tools impress in demos and disappoint in production. LinearB AI reviews over 5K Pull requests daily with a 99.4% satisfaction rate - not because we nailed the model on day one, but because we built a system that gets smarter with every review.
This talk goes under the hood of LinearB AI Code Review. We'll cover what makes an AI code review system genuinely useful (hint: it's not just signal to noise ratios). We'll walk through context preparation strategies such as static embeddings, dynamic RAG, and hybrid approaches - with honest tradeoffs and why we made the choices we did. And we'll show how we elegantly support personalization from team practices up to org-wide standards.
But the core of the talk is the improvement loop: how we built an evaluation platform and AI-driven feedback pipeline that captures developer feedback, diagnoses where the system falls short, and ships fixes fast. Using AI to improve an AI tool is where things start to seem magical.
You'll leave with a practical framework for building AI developer tools that compound, turning every interaction into a step toward better.
Key Takeaways:
- What distinguishes AI Code Review systems developers embrace from ones they mute
- How to choose the right methods for context construction
- The evaluation + feedback AI architecture that powers continuous improvement at scale
Best For: Engineering leaders evaluating AI dev tools, platform engineers building them, and practitioners who want to understand what separates AI features that stick from those that get turned off.
What We Got Wrong Building AI Code Review at Scale
We made the same mistakes most teams make. We focused on the model. We got the signal to noise wrong. We underestimated what it actually takes to make review guidelines hold across a large codebase.
This talk is about what we learned fixing those mistakes. We will cover context construction: why we started with static embeddings, where they broke down, and what we traded off moving to dynamic RAG and hybrid approaches. We will cover personalization at scale: how to maintain meaningful review standards from a single team up to org-wide without them collapsing into noise. And we will cover the part that changed everything: building an evaluation platform and AI-driven feedback pipeline that captures developer feedback, diagnoses where the system falls short, and ships fixes fast.
The core insight is that the model is not the product. The system around it is. You will leave with a clear framework for building AI developer tools that get better over time, and a sharper sense of where most teams are still getting it wrong.
The 2x AI Delusion: Proving Real Developer Productivity Beyond the Hype
Short:
AI has upended software engineering, and the hype couldn't be louder. Token spend is highly visible on the CFO's radar, and CEOs read about 2x, 5x, and even 10x velocity gains all over social media.
Meanwhile, engineering leaders struggle to provide tangible proof of these leaps. They face mounting pressure from executive leadership to replicate those hyped results while justifying spiraling token costs.
This session breaks down why proving impact is so difficult, delivering a curated set of metrics and industry benchmarks to measure true AI adoption and output.
Attendees will get a rare look into advanced analyses for AI-assisted coding - covering session efficiency, human/agent friction, skill utilization, and token optimization.
Finally, walk away with a practical blueprint for combining deterministic automation with AI flows to neutralize bottlenecks, secure delivery guardrails, and unlock genuine engineering velocity.
Long:
AI has upended software engineering, and the hype couldn't be louder. Token spend is highly visible on the CFO's radar, and CEOs read about 2x, 5x, and even 10x velocity gains all over social media.
Meanwhile, engineering leaders struggle to provide tangible proof of these productivity leaps. They face mounting pressure from executive leadership to replicate those hyped results while justifying spiraling token costs.
Achieving and proving a 2x boost is notoriously difficult, and for good reason. In this talk, we unpack the art of Developer Productivity, showing how engineering metrics evolved through the AI revolution. We map where AI productivity shines, where it falls short, and where AI creates new bottlenecks that can even result in net-negative productivity.
This session reviews best practices and key metrics for measuring AI adoption and productivity, backed by industry benchmarks. Attendees will gain a rare look into advanced analyses for AI-assisted coding - covering session efficiency, human/agent friction, skills utilization, and token optimization.
The session concludes with a practical blueprint for combining deterministic automation with AI flows. This approach delivers the compliance and quality guardrails modern engineering organizations require, directly neutralizing new AI bottlenecks to unlock the real productivity boost everyone is chasing.
Key Takeaways:
Discover a curated set of metrics to measure AI adoption, productivity, and ROI.
Compare your team's data against current industry benchmarks to anchor leadership expectations.
Learn advanced analysis methods to uncover hidden inefficiencies in how teams use AI, including session effectiveness and tool utilization.
Walk away with an automation blueprint to successfully integrate AI flows with deterministic guardrails.
AI Software Factory under the hood: the Good, the Bad and the Ugly
Everyone is talking about AI turning software delivery into a "dark factory" - an automated floor where bots hum and human intervention fades away. But what happens when you actually build one?
This talk strips away the hype to explore the reality of the AI factory mindset: what accelerates delivery, where pipelines break, and the hidden toll AI automation takes on engineering teams. Drawing on recent 2026 AI benchmark research, we analyze the widening productivity gap between early adopters and struggling teams.
We will break down the three pillars of a sustainable AI software factory:
* The Good: CFO-level delivery metrics and friction removal strategies that double deployment velocity.
* The Bad: The bottlenecks AI creates - from endless code review queues to insidious quality issues and technical debt.
* The Ugly: The impact on DevEx, developer cognitive load, and team health when automation outpaces human oversight.
Leave this session with actionable adjustments for your ADLC so you can scale velocity without burning out your best engineers.
MakeIT 2026 / JCON OpenBlend Slovenia 2026 Sessionize Event
NDC London 2026 Sessionize Event
dev up 2025 Sessionize Event
DecompileD 2025 Sessionize Event
CNCF-hosted Co-located Events North America 2024 Sessionize Event
DevOpsDays Tel Aviv 2023 Sessionize Event
DevOpsDays Montréal 2024 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top