AI Engineer Europe 2026

Feedback Loops are All You Need

Mehedi Hassan· Product Engineer, Granola10:11

Loading slides…

Read the talk

Feedback Loops Are All You Need

Granola makes AI features easier to improve by exposing the agent’s decisions and turning its desktop interface into shareable web previews.

From a talk by Mehedi Hassan

Before you start: Basic familiarity with LLM tool calls, pull requests, and web front ends will help; Electron’s process model is explained in the article.

A summary that notices what you wrote down

How do you make meeting notes reflect what a person actually cared about? At Granola, that is a product engineering problem as much as a model problem. Mehedi Hassan approaches it from a career spanning jQuery, React’s reshaping of front-end development, and now LLMs. His focus here is the work around the model: making its behavior useful and making the resulting product easier to test.

Granola sits in the dock and captures both system audio and microphone audio to produce a real-time transcript. In the opening demonstration, Hassan uses a recording of the preceding talk. Alongside the transcript, users can write their own notes, giving the app a signal about what deserves emphasis rather than leaving it to summarize every topic equally.

When Hassan generates the summary, he points to how his note about twenty percent overlap influenced the output’s emphasis. The percentage belongs to the content of the preceding talk; it is not a measurement of Granola’s accuracy. The intended result resembles what the user would have written on a notepad, with the transcript supplying the detail. Hassan describes the ambition as best-in-class meeting notes across roles, delivered without getting in the user’s way.

0:150:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:15 · section reference included

A chat box meets specific expectations

That unobtrusive product philosophy becomes harder to maintain as AI features expand. Granola’s existing chat can answer questions about a single meeting, multiple meetings, or shared context. Hassan imagines building a version in one shot and shipping it in a fake Granola app. Getting the chat interface working is easy; the hypothetical users immediately expose what it does not understand.

Slide posing the production question beside a Granola chat response listing promised follow-ups.Open full source frame
What happens when you put a simple AI feature into production?

Their complaints span several different problems:

  • Task completion: It cannot produce the requested to-do list.
  • Latency: Web search takes too long.
  • Personal style: Follow-up emails do not sound like the person sending them.
  • Intent: A request for coaching about meetings produces an answer about a football coach.

These examples make the gap concrete: a general chatbot can respond fluently while still failing the particular job the product promises to do. Molding the model to that job becomes the difficult part.

1:522:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:52 · section reference included

One meeting, different useful outputs

Even when the information is correct, the output can miss the user’s needs. The opening summary suited Hassan, but another role might expect a different selection and organization of the same meeting content.

RoleExpected emphasis
SalesDeals
EngineeringAction items, blockers, Linear tickets
HRDifferent needs, left unspecified

One prompt generally cannot serve all of those expectations. The problem is not simply generating a good-looking summary; it is understanding why the model produced this summary for this use case. That requires inspecting behavior that otherwise feels opaque and difficult to steer.

4:014:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:01 · section reference included

Follow the agent from beginning to end

Granola’s response was to build its own tracing tools. This is a place where Hassan finds one-shot generation useful: it reduces the effort required to build internal software around the product. The trace exposes individual tool calls from beginning to end, recorded reasons for those calls, search trails, reasoning trails, and cost. Instead of seeing only the final answer, an investigator can follow the sequence that produced it.

The team tailored both the data structure and the interface to its own investigations. Engineering, product, data, and customer experience staff all need to use it; diagnosing a failure should not require writing complex CloudWatch queries. Hassan contrasts this with the earlier economics of internal tooling, when a team might have depended on a SaaS product because building a suitable interface took too much time. The displayed trace makes that interface concrete, showing reasoning, meeting search, calendar search, and expanded calendar results in one vertical sequence.

Slide pairing tracing guidance with a vertical trace showing reasoning, meeting search, calendar search, and expanded calendar results.Open full source frame
Tracing the agentic loop end-to-end.

The implementation he describes is deliberately small: wrap AI SDK calls, save records to a database, and build the front end around how people investigate failures. He also names OpenTelemetry and other providers as options. The related AI SDK telemetry documentation is an implementation reference, rather than a specification of Granola’s wrapper. The essential product decision is to make the collected data usable by the people who need to act on it.

Hassan describes Granola’s founder following an entire agent loop from front to back to find what went wrong. That changes the next iteration: a vague impression that an output feels wrong becomes an identifiable failure in the sequence. Tracing is valuable when it turns dissatisfaction into a specific thing to change.

4:394:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:39 · section reference included

Make desktop experiments easy to open

Inspecting model behavior addresses only part of the feedback loop. Users also experience the interface around the output. LLMs make it cheaper to build different features and multiple versions of the same feature, but those variants are useful only if people can try them. Granola’s desktop setup allowed one app instance at a time, which made testing variants in parallel awkward.

Previously, a tester had to install dependencies and run the Electron app locally. Sharing a change with a coworker meant asking that person to repeat the setup. Granola removed much of that friction by turning the Electron front end into an online web shell. Its CI now produces a preview link whenever a pull request opens, so colleagues can open the proposed interface directly. Hassan reports that this substantially sped up development.

The preview also gives an agent somewhere to exercise the change. In Hassan’s reported workflow, Cursor tests the preview after a pull request opens and uploads a screenshot to the PR. This adds visible testing evidence to the review; it does not establish that every behavior has been verified. The same accessible environment serves both human reviewers and the agent.

6:196:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:19 · section reference included

Separate the renderer from its desktop environment

The web shell depends on a boundary Electron already provides. Its main process handles native capabilities, while its renderer process supplies the web-based front end. IPC—inter-process communication—lets the renderer request functionality across that boundary; IPC is not itself a system API. Granola abstracted those calls so that the web environment could use web-standard implementations.

A small TypeScript example shows the shape of that boundary using a clipboard operation. The renderer receives one interface; the desktop entry point can supply its IPC-backed implementation, while the browser entry point supplies the Clipboard API:

typescript

interface ClipboardPort {
  writeText(text: string): Promise<void>;
}

function createCopyNotes(clipboard: ClipboardPort) {
  return async (notes: string): Promise<void> => {
    await clipboard.writeText(notes);
  };
}

// Browser entry point
const webClipboard: ClipboardPort = {
  writeText: (text) => navigator.clipboard.writeText(text),
};

const copyNotes = createCopyNotes(webClipboard);

const button = document.createElement('button');
button.textContent = 'Copy notes';
button.addEventListener('click', () => {
  void copyNotes('Follow up on the meeting action items.').catch(
    (error: unknown) => console.error('Could not copy notes', error),
  );
});
document.body.append(button);

Clipboard copying is an illustrative application of the abstraction, not a reported Granola feature from this demonstration. Browser clipboard writes require a secure context and are subject to browser permission and activation rules. The architectural point is that the consuming code does not need to know whether the implementation crosses Electron IPC or calls a browser API.

Granola applied the same separation to its React-facing infrastructure: routing, sessions, and the query layer moved to web standards. With those dependencies no longer tied to Electron, the renderer could run as a web app. The architecture slide brings the IPC and React abstractions together as the basis of the web shell.

Slide describing Electron IPC and React API abstractions alongside code for a web shell and environment-independent routing.Open full source frame
How the web shell works.

The payoff is the ability to experience several versions of a feature in practice. Instead of judging only a Figma design, the team can use each version, feel how it behaves, and compare alternatives before deciding what ships. More generated variants become more useful experiments because the cost of opening and testing them has fallen.

7:447:56
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:44 · section reference included

Build conviction through iteration

The useful improvement is a better feedback loop, not simply a better first generation. Hassan compares working with an LLM to playing tennis: the result develops through repeated exchanges. Traces make the model’s failures inspectable; accessible previews let people experience proposed changes. Together, they replace hoping a feature will work for customers with a stronger basis for believing it will connect. The desired experience can feel like magic to the user without remaining an unexplained black box to the team building it.

The closing platform question tests whether that approach requires replacing Electron with Tauri. Granola has considered the move several times and tried Tauri, but Hassan says Electron currently serves the team well. Hassan reports that Granola’s Tauri trials did not produce major performance gains, the team’s main criterion for the move. He also mentions changing APIs without identifying which platform he means. The experiments have not shipped: the practical improvement described here came from making the existing renderer portable and easier to test.

8:459:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:45 · section reference included

Resources

From the talk

  • Meeting-notes application that captures computer audio and enhances notes without adding a meeting bot.

  • Explains main and renderer processes, preload scripts, and communication between desktop capabilities and web interfaces.

  • Introduces the architecture of Tauri applications and their use of operating-system WebViews.

Transcript download
Full transcript

Loading transcript…