Vibe Code Camp Distilled

Paula Dozsa - Vibe Coding in Production at Portola

Paula Dozsa - Vibe Coding in Production at Portola

Key Insights

Summary

Paula Dozsa is an iOS engineer at Portola, makers of Tolan - an AI companion app with hundreds of thousands of users. She has 8 years of iOS development experience, including her own startup, Spotify, and now Portola. In this talk, she challenges the conventional wisdom that vibe coding is only suitable for prototypes and side projects.

Portola has been using Claude and vibe coding for production features for several months, with development velocity dramatically accelerating after Opus 4.5 launched. The team ships features from conception to the App Store in 3-5 days, with even non-engineers opening production-ready PRs. Paula demonstrates specific features built with Claude - a shop system, planet customization tools, and a sophisticated token animation - all of which would have taken significantly longer to build manually.

The core insight: successful production vibe coding requires treating Claude like a new team member who needs onboarding. This means creating custom skills to encode tribal knowledge, specialized agents for different tasks (building, reviewing, shepherding PRs), hooks to enforce guardrails, and MCP integrations to work across tools. Dan Fetterman on the Portola team championed this infrastructure, enabling the entire iOS team to work faster.

Main Topics

Tolan App Demo and Recent Features

Paula demonstrated the Tolan app, an AI companion that lives on its own planet. The app is built with an interesting hybrid architecture - combining native iOS with Unity for the 3D world. Claude has been particularly valuable for this setup because it can quickly build polished iOS UI, freeing engineers to focus on the complex iOS-Unity integration work that AI can’t handle yet.

Recent features built with Claude: - Shop system: Users can buy and try on outfits for their Tolan, including onesies and accessories - Planet customization: Place structures like cottages and decorative items (frogs are user favorites) anywhere on the planet - Token rain animation: A celebratory animation showing tokens flying into the counter when users earn currency

“I think something I hear often from people who use LMS2Code is that they don’t tend to have a good sense of how things look and how things feel. And I want to challenge that because there is one animation that I built recently, which again, would have taken me several hours of trial and error. And it just took me a prompt.” [00:04:56]

The Token Animation Case Study

The token animation showcases Claude’s capabilities with complex UI work. Paula needed to create a celebratory animation when users receive tokens - showing multiple coin images flying across the screen into a counter button.

The prompt was remarkably simple: - Provided 5 coin asset images (different rotation angles) - Included a Figma screenshot showing the general concept - Basic instruction: “If users tokens have incremented, we want to show an animation leading into their token counter”

What Claude generated: - SpriteKit animation code (iOS animation framework) - Each coin as a node with individual trajectories - Ease-in and ease-out physics for natural acceleration/deceleration - Rotation while flying (not even in the original design) - Proper timing and coordination between multiple coins

“It actually is aware of the physics of how things fly across the screen. It rotates the images on my screen… And ended up building something beautiful that, again, would have otherwise taken me a long time to build myself.” [00:06:03]

The entire implementation took 5 minutes from prompt to production-ready code, versus the “couple of hours at least of trial and error” it would have taken manually. Even more surprising, the AI’s version looked better than what was prototyped in Figma.

Challenging the “Prototypes Only” Mindset

Paula directly addresses the common belief that AI coding is only suitable for hackathons, weekend experiments, and greenfield apps where code quality doesn’t matter.

Why this belief existed: - AI would write technically correct code that didn’t fit your project patterns - You’d spend more time fixing AI output than writing it yourself - It worked, but created technical debt

What changed: - Tooling improvements: skills, agents, hooks, MCP integrations - Better models (Opus 4.5 was a significant inflection point) - Ability to teach AI your specific patterns and conventions

“Vibe coding in production isn’t about letting AI do whatever it wants. It’s about teaching AI our patterns and letting it implement them. And sometimes letting it surprise you like it did with the animation.” [00:17:20]

At Portola, they’re shipping features to hundreds of thousands of users (many paying customers) using vibe coding. The code isn’t throwaway prototypes - it’s production-quality, pattern-consistent, and maintainable.

The Four Pillars of Production Vibe Coding

Paula outlines Portola’s technical setup that makes production vibe coding possible:

1. Agents

Specialized AI workers for complex tasks, assigned to specific models:

“You can actually create an agent, for example, that knows how to build your app and actually gets a log of all the errors that come out of that. And then it can, during a conversation, it can continuously rebuild your app, fix errors, build it again until it gets a working solution.” [00:21:03]

These agents can run locally or remotely on CI machines. They work in parallel, with multiple agents reviewing the same PR simultaneously.

2. Skills (13 and growing)

Markdown files written in plain English that teach Claude domain-specific knowledge:

The team creates skills both for Claude and for actual human onboarding - when bringing on new engineers, they document answers to common questions as skills.

“I think it’s actually really like onboarding someone new to your team. Like you don’t just like give them a ticket and tell them to like, go figure it out. You actually have to spend some time explaining how your code base works, how you decided on certain things, how the architecture works, also review their code and get feedback.” [00:17:41]

“If you’d explain it to a new hire, make it a skill.” [00:27:32]

3. Hooks

Scripts that run before or after Claude uses tools, enforcing automated guardrails:

These are specific to Portola’s workflows and have been added iteratively as they’ve discovered edge cases.

4. MCP Integrations (“Magic Claude Powers”)

Connections to external tools that let Claude work across systems:

“You can read a linear ticket, you can pull the stack trace, then check the Figma component, for example, is it just a fix, create a PR and you don’t have to like context switch yourself between all these apps.” [00:27:00]

This cross-system integration is how human engineers actually work, and enabling Claude to do the same eliminates constant context switching.

The Slack Integration Workflow

Portola uses a Slack bot integration that democratizes access to Claude:

  1. Any team member (including non-engineers) tags Claude in Slack
  2. Claude has access to all GitHub repos and determines if it’s an iOS or backend change
  3. Opens a PR in the appropriate repo
  4. Reviews its own code with specialized agents
  5. Shepherds the PR by addressing review comments
  6. By the time a human engineer reviews it, the code is usually merge-ready

This enables designers to ship features without writing code manually, and engineers to focus on high-level architecture and integration problems rather than boilerplate UI implementation.

Working at Speed

Portola moves exceptionally fast: - Standard feature cycle: 3-5 days from idea to App Store - “Meatier projects”: One week - This velocity is enabled by the AI infrastructure

Design philosophy: - Move quickly with suggestions rather than pixel-perfect mockups - Let Claude experiment and sometimes exceed expectations - Maintain attention to detail for overall feel, consistency, and IP - Creative director ensures brand coherence

“We move very quickly as a company. Like we’ll go from idea to shift to the app store within days. Like if something takes longer than a week, it’s like a much meatier project, but usually yeah, three to five days we ship to the app store.” [00:11:43]

How Engineers Actually Use Claude

Paula’s workflow: - Primarily uses Claude CLI for development - Also experiments with Claude desktop app for planning/back-and-forth discussions - Types rather than uses voice (though some teammates are considering it) - Starts every feature by asking Claude to make a plan - Hand-writes code mainly in response to issues, or to provide examples of patterns for Claude to follow - Treats interaction like code review: “This is the pattern you should have followed” with a code sample

Team tooling: - Most use Claude CLI or desktop app - One teammate uses Cursor with Opus - Codex also reviews PRs and sometimes catches things Claude misses - Multiple models used for different strengths

The key mental shift: assume Claude will do the work first, then intervene only when needed to correct or guide.

The iOS and Unity Challenge

The Tolan app architecture is particularly complex - native iOS UI with Unity for the 3D world. This creates integration challenges that AI can’t fully handle yet.

How Claude helps: - Builds polished iOS UI quickly - Engineers focus on iOS-Unity integration (message passing, state synchronization) - Reduces time on standard UI implementation by 2-3x - Enables focus on problems that actually require human expertise

“Claude has really enabled us to focus on building those integrations properly, which is currently not handled by Vibe coding. So spend less time building UI and more time making sure that the whole experience is cohesive.” [00:03:28]

Governance and Ownership

At Portola’s small scale (4-5 iOS engineers), governance is straightforward:

“We have Dan, so Dan Fetterman, who is the lead of the team. He’s been the one really championing this and pushing this forward. And I would say he is the owner for this.” [00:24:38]

Key insight: Every team needs a “Dan” - someone excited about AI tooling who will invest in the infrastructure.

Philosophy: Trust But Verify

The team’s approach balances automation with oversight:

The goal isn’t to eliminate human judgment, but to automate the routine work so humans can focus on higher-level decisions.

Actionable Details

Tools and Platforms

Key Technical Patterns

Agent Configuration:

- Build agent: Compiles iOS app, parses errors, iterates
- Logic review agent: Opus model, deep analysis
- Pattern review agent: Sonnet model, pattern consistency
- PR shepherd agent: Addresses review comments automatically

Skill Structure: - Written in Markdown - Plain English documentation - Encodes tribal knowledge and conventions - Updated as new patterns emerge - Doubles as human onboarding documentation

Hook Purposes: - Run before/after Claude uses tools - Block problematic patterns - Route tasks to appropriate agents - Enforce consistency guardrails

MCP Integrations: - GitHub (essential) - Linear (ticket → PR automation) - Sentry (crash logs) - PostHog (analytics) - Datadog (monitoring) - Figma (design reference)

Development Workflow

  1. Start with Claude making a plan (plan mode or conversational)
  2. Claude implements following established skills/patterns
  3. Build agent iterates until successful compilation
  4. Multiple review agents analyze in parallel
  5. PR shepherd agent addresses review comments
  6. Human engineer final review and merge

For animations: 1. Provide asset images 2. Include Figma screenshot or description 3. Simple prompt explaining desired behavior 4. Claude generates SpriteKit code 5. Usually production-ready immediately

Speed Benchmarks

Quotes Worth Saving

“I think Opus really helped us get that going. And I want to show you exactly how we set that up and basically talk a bit more about how you can help Claude help you.” [00:01:29]

“I wanted to challenge something that I hear a lot, and that Vibe coding is only for prototypes or side projects or projects that you’re building from scratch. So we’ve basically been using Claude and Vibe coding production features for a couple of months now.” [00:01:14]

“I do think that, actually, these LLMs can build nice UI. You just have to know how to prompt them and know when to use them.” [00:05:21]

“I think this was a beautiful example of how not having an exact idea of what something should look like led to something looking much better than anyone thought was possible at first. So I think, yeah, we’re entering a new era where it’s like, it’s even easier to not necessarily have something fully fleshed out before developing it because the LLM might actually end up making something better than you thought possible.” [00:12:12]

“Vibe coding in production isn’t about letting AI do whatever it wants. It’s about teaching AI our patterns and letting it implement them. And sometimes letting it surprise you like it did with the animation. But overall, if you want to ship things quickly, but also consistently and at a high quality level, you need to put in a bit of work. I would think of it as like onboarding someone new to your team.” [00:17:20]

“We’ve been treating Claude as an intern that just learns very quickly. And once it knows these things, it can, you know, implement things faster than any of us could. While we get to focus on like the trickier integration problems again, between iOS and unity, and other problems.” [00:18:01]

“Ask Claude to help write your cloud setup. It is actually really good at that. You don’t have to hand write it yourself.” [00:27:32]

“MCPs are your MVPs and help you work across streams.” [00:27:45]

“By coding can be used in production. And you know, your non-engineers can ship code and your users won’t know the difference.” [00:28:04]

← Back to Index ← Tina He Cj Hess →