Roni Dover
Infovore, product developer, and a board game geek. Writing and talking about development practices, Devops, and design/architecture topics.
Sunnyvale, California, United States
Actions
Holistic developer and builder with a passion for development processes and practices. Afflicted by an acute Product Manager/Developer split personality disorder that was never treated. A big believer in evidence-based development, and a proponent of Continuous Feedback in all aspects of Software Engineering. Currently heading AI Labs at JetBrains.
Links
Area of Expertise
Topics
Tokenconomy - Why spending $$ on tokens doesn't make your model smarter
With exponential adoption, LLMs have been running amok, draining allocated budgets and accrueing legendary costs. In this session we'll take a look at a few simple tricks that with some creative programming can reduce your costs by 50% while increasing the result quality and speeding up your agentic flow.
Like many developers, I started my LLM experimentation on my own budget. Right before my credit card became maxed out, I noticed that the LLM defaults were *anything* but efficient. Suprisingly with a slimmed down context the agentic quality increased.
In this session I will share some practices that came from analyzing my own bloated trajectories. We'll review snippets, hooks, practices and tricks to help deal with what will soon overshadow cloud costs - token economy.
How not to write an MCP server, lessons from the trenches
This session is a developer's diary of the hard lessons I learned building an effective MCP server. My first wrong turn was the naive one: wrapping my API as tools and calling it done. Over many iterations my MCP evolved from a context polluter into a genuinely useful toolset. Along the way I tried a Hypermedia approach to the API design, a bit of prompt injection, and learned some design principles the hard way.
We're used to designing for scripts and developers: transactional, contract-driven interfaces built for efficiency. None of that is what an autonomous agent needs. It arrives fresh each session, learns your tools from their descriptions alone, and gives up after a few failed attempts unless you give it a reason not to. Among the lessons: why dumping data backfires (more context makes it worse), why exposing a whole API floods the model's context window, why granularity is a Goldilocks problem, and why descriptions should sell intent, not functionality.
We'll also step back to a prior question: when an MCP server makes sense at all, versus a skill or a CLI the agent can just call. My hope is to shorten the learning curve and help you skip a few wrong turns I didn't.
This topic is highly relevant to any developer in modifying his current application for this use case or generating new APIs.
I've written a couple of blog posts relating to the topics covered in this talk:
https://towardsdatascience.com/how-not-to-write-an-mcp-server/
https://towardsdatascience.com/talk-to-my-agent/
Semantic Code Search with RAG: Field notes from six months of research and development
Six months ago we set out to build the best semantic code search platform we could: a RAG pipeline that gives LLM agents precise, citable evidence from real repositories instead of whatever grep happens to surface. We got it working, we got it into production, and we collected a lot of scar tissue along the way. This talk is us sharing the parts we wish someone had told us on day one.
In the session we'll walk through the steps of building a RAG pipeline, what we learned, and which mistakes to avoid. How a retrieved chunk without coordinates is almost useless, and metadata quietly ends up being half of your retrieval quality. How binarizing embeddings down to one bit per dimension costs only about 2% retrieval quality while slashing storage and latency, which still feels wrong every time we say it. How precision barely matters in code retrieval while recall is everything. And how agents, go figure, have personalities: Claude is deeply suspicious of external tools and will quietly go back to grep instead of the search we built for it, so we spent real time reading trajectories and measuring invocation rates like behavioral psychologists.
We'll also touch on ideas we borrowed from RAPTOR and LLM2Vec, why we stopped trusting SWE-bench Verified, and how we keep the index breathing with git using content hashes and merkle trees instead of reindexing the world on every commit.
If you're building anything like this, you'll leave with our concrete recipe, real model and tool choices included, from laptop prototype to production setup.
This session targets a gap many AI builders are facing: agent quality, cost, and latency are dominated by what lands in the context window, not by which model they picked. Retrieval over source code is the lever, and it's poorly covered.
What makes this session valuable is that it's a practitioner's report, not a survey. We spent six months building a semantic code search platform and shipping it to production, and every claim comes with a decision and a number attached: which embedding and reranker models we run, why binary quantization was nearly free, why we abandoned SWE-bench Verified, how we measured whether the agent actually used the tool. Attendees leave with a recipe they can start applying the same week, at either prototype or production scale.
It fits an AI builders track well because it sits exactly where the audience works: between models they don't control and products they have to ship. It's technical enough for infrastructure engineers, but the lessons about evals, agent behavior, and context quality apply to anyone building on LLMs.
Becoming an Agent Psychologist: Identifying and Correcting Agentic Behavioral Issues
Agents often complete their assigned tasks without meeting your objectives. Between intent and outcome sit behavioral patterns that can make or break a coding session. The most valuable thing to surface when retrospecting on your agent's performance isn't code bugs — it's behavioral clashes: moments where the agent's conduct collided with what the human expected. In their eagerness to please, agents fixate on an early wrong assumption, grow overconfident after a partial success, or drop the ball inches from the finish line. If your agent has ever dismissed an issue with "that error is pre-existing, not from my change," you know exactly what I mean.
These clashes fall into a several useful categories. Under-autonomy: stopping short or asking permission instead of finishing. Ignored defect: waving off a real problem as "out of scope." Overclaim: declaring work done or "tests passing" beyond what was verified. Over-reach: doing far more than asked. Process violation: ignoring a stated constraint. Wrong focus: working the wrong thing despite a clear goal.
Agents often complete their assigned tasks without meeting your objectives. Between intent and outcome sit behavioral patterns that can make or break a coding session. The most valuable thing to surface when retrospecting on your agent's performance isn't code bugs — it's behavioral clashes: moments where the agent's conduct collided with what the human expected. In their eagerness to please, agents fixate on an early wrong assumption, grow overconfident after a partial success, or drop the ball inches from the finish line. If your agent has ever dismissed an issue with "that error is pre-existing, not from my change," you know exactly what I mean.
These clashes fall into several useful categories. Under-autonomy: stopping short or asking permission instead of finishing. Ignored defect: waving off a real problem as "out of scope." Overclaim: declaring work done or "tests passing" beyond what was verified. Over-reach: doing far more than asked. Process violation: ignoring a stated constraint. Wrong focus: working the wrong thing despite a clear goal.
The good news is that these personality quirks are treatable. Just as agents improve when we assign them roles, they can compensate for these shortcomings given the right framework and incentives. In this session we'll walk through real examples using frontier models and demonstrate how to observe and evaluate whether corrections to the agent's persona actually work.
Outline
1. Agent behavioral clashes, example from the real world
2. Agentcy vs. rule set, how to evaluate skills effectiveness vs. agentic performance and quality degradation
3. Affecting agentic personality - have we evolved from the rolesetting "you are a..." days
4. The path to introspection: Analyzing trajectories to detect and correct
Roni Dover
Infovore, product developer, and a board game geek. Writing and talking about development practices, Devops, and design/architecture topics.
Sunnyvale, California, United States
Links
Actions
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