Most teams adopt AI coding assistants and discover the same thing within a month. The output is fast, the output is plausible, the output is wrong in ways that take longer to fix than writing it yourself. The gap isn't the model. It's everything around the model. This talk is about what fills that gap. We'll walk through the architecture of a production AI engineering system, drawn from our experience building, shipping, and rebuilding our own at Very Good Ventures. The frame is layered. At the bottom, contextual knowledge that teaches the AI your standards. In the middle, structured workflows that replace ad-hoc prompting with brainstorm, plan, and build phases. At the top, guardrails through hooks, MCP integrations, and automated analysis that catch problems before they reach a PR. Each layer answers a different failure mode, and skipping any of them is where most teams stall. The talk covers the design decisions that actually mattered. Why we moved from monolithic prompts to discrete skills. Why brainstorming and planning needed to be separate phases instead of one step. What we got wrong about tool-agnosticism the first time, and what changed when we tried again. How to know when a convention belongs in AI context versus a linter versus a code review checklist. The patterns generalize beyond Flutter, but we'll ground every principle in real examples from Flutter work so the lessons are concrete, not abstract. You'll leave with a model for how the pieces fit together, a clearer sense of which layer to invest in first for your team, and a few opinionated takes on what to avoid. Key Learnings - A layered model for AI-assisted development, contextual knowledge, structured workflows, and automated guardrails, and why each layer matters - How to decompose a feature into brainstorm, plan, and build phases that produce better output than direct prompting - How to encode team standards as contextual skills the AI actually reaches for, versus standards that get ignored - Where hooks and MCP integrations belong in the loop, and where they add friction without value - Practical guidance for sequencing adoption so quality and velocity move together instead of trading off

Etsy's Year in Review is one of the most animation-heavy moments in the app. For years it shipped on Lottie. This year, the team rebuilt it entirely with native Flutter animations, and dropped a third-party dependency in the process. This talk is the story of that migration, told by the engineer who shipped it and the trainer who helped the team get there. Filip will walk through the technical decisions: which Lottie compositions translated cleanly to AnimationController and Tween, which ones needed CustomPainter or implicit animations, and where Flutter's animation primitives forced the team to think differently about motion design. Jorge will cover the enablement side: how a team that had leaned on Lottie for years built fluency in native Flutter animation fast enough to ship a flagship feature on it. You'll leave with a concrete decision framework for when to drop Lottie, a tour of the Flutter animation patterns that did the heavy lifting in Year in Review, and a realistic picture of what it takes to upskill a production team on motion. Most useful for engineers and engineering leaders weighing the same tradeoff on their own apps.