# 15 Lessons Learned Building ChatGPT Apps Source: https://www.youtube.com/watch?v=FMVRRM4MdCk Recap page: https://rapidrecap.app/video/FMVRRM4MdCk Generated: 2026-02-06T21:06:18.216+00:00 --- ## Quick Overview The primary lesson learned from building fifteen ChatGPT applications is that assuming the existing web development model applies to AI apps, especially concerning state management and data handling, leads to failure; the authors advocate for a shift toward declarative programming, aggressive front-loading of data, and managing context asymmetry to avoid common pitfalls like slow performance and broken user experiences. **Key Points:** - The assumption that standard web development patterns work for AI apps is fatally flawed in an agentic environment (00:35). - The authors learned 15 lessons, including the need to break down the 'three-body problem' of User, UI, and Model interaction (1:11). - A major pitfall is relying on standard web patterns like state management, which fails when the model's reality differs from the UI's reality (1:17, 1:57). - The recommended solution involves declarative programming and aggressive front-loading of data, rather than lazy-loading or waiting for user clicks to fetch data (2:56, 4:50). - The team built a custom Vite plugin to inject updates directly into the iframe context and used a local emulator for testing to manage complexity (5:59, 8:20). - The report criticizes the common practice of relying on simple UI controls like buttons, advocating instead for explicit communication of the model's intent (6:39, 8:28). - The ultimate goal is to move away from the deterministic web stack towards a probabilistic interface that better handles the AI's internal state (11:53). ![Screenshot at 00:00: The introductory screen for the AI Papers Podcast Daily, featuring an illustration of two podcasters and the call to action 'Become a Member Today!', setting the stage for a discussion on lessons learned from building AI applications.](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-00-00.jpg) **Context:** This video, presented as a 'field report' from the creators of Alpec, summarizes fifteen key lessons learned over three months while building roughly two dozen applications that leverage the ChatGPT ecosystem. The discussion centers on the fundamental architectural and design differences between traditional web development and building software that integrates large language models, emphasizing the problems that arise from incorrectly mapping old patterns onto new agentic systems. ## Detailed Analysis The central thesis is that traditional web development paradigms, particularly regarding state management, fail disastrously when applied to AI applications interacting with Large Language Models (LLMs). The authors spent three months building about twenty ChatGPT applications and distilled 15 lessons from their experience. A key problem is the 'context asymmetry' where the model's internal state diverges from what the user sees on the UI, leading to a broken, slow experience. The authors criticize developers for assuming standard web patterns (like those in React or Redux) will work. The proposed solution is a shift toward a declarative programming model, similar to how frameworks like Skybridge handle UI state, but applied to the AI stack. This involves aggressively front-loading data (sending as much data as possible in the initial tool call) rather than lazy-loading based on user interaction (like clicking 'show more'). Furthermore, they highlight the risk of security flaws (like cross-site scripting) if developers fail to explicitly whitelist internal APIs or domain connections used by the LLM. The team built custom tooling, including a Vite plugin, to manage these complexities, allowing them to test on local emulators and automate the syncing of the UI state with the model's context, ultimately aiming for a probabilistic interface rather than a strictly deterministic one. ### Lessons Learned Overview - Lesson 1 (00:05) is about breaking down the three-body problem (User, UI, Model) - Lesson 2 (1:14) covers the death of lazy loading in favor of aggressive front-loading - Lesson 3 (1:37) focuses on managing context asymmetry (1:36). ### Performance and Logic Issues - Sharing the full UI state causes performance degradation (2:50) - Logic errors occur when the model acts on data the UI cannot see (1:57). ### Architectural Solutions - The team built a custom Vite plugin to inject updates into the iFrame context and used a local emulator for testing (5:59, 8:20) - They advocate for declarative programming over imperative button clicks (6:24, 9:33). ### Security and Best Practices - Security policies (CSP) are strict, requiring explicit whitelisting of domains and APIs (8:24) - Avoiding simple workflow patterns like 'show more' buttons is crucial (7:39). ### Future Direction - The goal is to move toward a probabilistic interface that manages the evolving state of the AI, rather than relying on the static web stack (11:53, 12:07). ![Screenshot at 00:05: Discussion opening referencing the paper '15 Lessons Learned Building ChatGPT Apps' authored by Nikolay Rodionov of Alpec.](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-00-05.jpg) ![Screenshot at 01:17: Visual representation of the 'two bodies' problem: the User/UI relationship versus the Model's independent reality.](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-01-17.jpg) ![Screenshot at 02:56: Visual contrast between the problematic approach \(sending large JSON payloads\) and the proposed solution \(explicitly defining data fields\).](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-02-56.jpg) ![Screenshot at 04:41: Explanation of the problem where the model is blind to UI state changes unless explicitly told, causing the application to appear broken.](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-04-41.jpg) ![Screenshot at 09:33: Discussion on the pain point of the feedback loop when developing inside the ChatGPT environment, leading to slow development cycles.](https://ss.rapidrecap.app/screens/FMVRRM4MdCk/00-09-33.jpg)